1 /* romanboy --- Shows a 3d immersion of the real projective plane
2 that rotates in 3d or on which you can walk and that can deform
3 smoothly between the Roman surface and the Boy surface. */
6 static const char sccsid[] = "@(#)romanboy.c 1.1 14/10/03 xlockmore";
9 /* Copyright (c) 2013-2014 Carsten Steger <carsten@mirsanmir.org>. */
12 * Permission to use, copy, modify, and distribute this software and its
13 * documentation for any purpose and without fee is hereby granted,
14 * provided that the above copyright notice appear in all copies and that
15 * both that copyright notice and this permission notice appear in
16 * supporting documentation.
18 * This file is provided AS IS with no warranties of any kind. The author
19 * shall have no liability with respect to the infringement of copyrights,
20 * trade secrets or any patents by this file or any part thereof. In no
21 * event will the author be liable for any lost revenue or profits or
22 * other special, indirect and consequential damages.
25 * C. Steger - 14/10/03: Initial version
29 * This program shows a 3d immersion of the real projective plane
30 * that smoothly deforms between the Roman surface and the Boy
31 * surface. You can walk on the projective plane or turn in 3d. The
32 * smooth deformation (homotopy) between these two famous immersions
33 * of the real projective plane was constructed by François Apéry.
35 * The real projective plane is a non-orientable surface. To make
36 * this apparent, the two-sided color mode can be used.
37 * Alternatively, orientation markers (curling arrows) can be drawn as
38 * a texture map on the surface of the projective plane. While
39 * walking on the projective plane, you will notice that the
40 * orientation of the curling arrows changes (which it must because
41 * the projective plane is non-orientable).
43 * The real projective plane is a model for the projective geometry in
44 * 2d space. One point can be singled out as the origin. A line can
45 * be singled out as the line at infinity, i.e., a line that lies at
46 * an infinite distance to the origin. The line at infinity is
47 * topologically a circle. Points on the line at infinity are also
48 * used to model directions in projective geometry. The origin can be
49 * visualized in different manners. When using distance colors, the
50 * origin is the point that is displayed as fully saturated red, which
51 * is easier to see as the center of the reddish area on the
52 * projective plane. Alternatively, when using distance bands, the
53 * origin is the center of the only band that projects to a disk.
54 * When using direction bands, the origin is the point where all
55 * direction bands collapse to a point. Finally, when orientation
56 * markers are being displayed, the origin the the point where all
57 * orientation markers are compressed to a point. The line at
58 * infinity can also be visualized in different ways. When using
59 * distance colors, the line at infinity is the line that is displayed
60 * as fully saturated magenta. When two-sided colors are used, the
61 * line at infinity lies at the points where the red and green "sides"
62 * of the projective plane meet (of course, the real projective plane
63 * only has one side, so this is a design choice of the
64 * visualization). Alternatively, when orientation markers are being
65 * displayed, the line at infinity is the place where the orientation
66 * markers change their orientation.
68 * Note that when the projective plane is displayed with bands, the
69 * orientation markers are placed in the middle of the bands. For
70 * distance bands, the bands are chosen in such a way that the band at
71 * the origin is only half as wide as the remaining bands, which
72 * results in a disk being displayed at the origin that has the same
73 * diameter as the remaining bands. This choice, however, also
74 * implies that the band at infinity is half as wide as the other
75 * bands. Since the projective plane is attached to itself (in a
76 * complicated fashion) at the line at infinity, effectively the band
77 * at infinity is again as wide as the remaining bands. However,
78 * since the orientation markers are displayed in the middle of the
79 * bands, this means that only one half of the orientation markers
80 * will be displayed twice at the line at infinity if distance bands
81 * are used. If direction bands are used or if the projective plane
82 * is displayed as a solid surface, the orientation markers are
83 * displayed fully at the respective sides of the line at infinity.
85 * The immersed projective plane can be projected to the screen either
86 * perspectively or orthographically. When using the walking modes,
87 * perspective projection to the screen will be used.
89 * There are three display modes for the projective plane: mesh
90 * (wireframe), solid, or transparent. Furthermore, the appearance of
91 * the projective plane can be as a solid object or as a set of
92 * see-through bands. The bands can be distance bands, i.e., bands
93 * that lie at increasing distances from the origin, or direction
94 * bands, i.e., bands that lie at increasing angles with respect to
97 * When the projective plane is displayed with direction bands, you
98 * will be able to see that each direction band (modulo the "pinching"
99 * at the origin) is a Moebius strip, which also shows that the
100 * projective plane is non-orientable.
102 * Finally, the colors with with the projective plane is drawn can be
103 * set to two-sided, distance, or direction. In two-sided mode, the
104 * projective plane is drawn with red on one "side" and green on the
105 * "other side". As described above, the projective plane only has
106 * one side, so the color jumps from red to green along the line at
107 * infinity. This mode enables you to see that the projective plane
108 * is non-orientable. In distance mode, the projective plane is
109 * displayed with fully saturated colors that depend on the distance
110 * of the points on the projective plane to the origin. The origin is
111 * displayed in red, the line at infinity is displayed in magenta. If
112 * the projective plane is displayed as distance bands, each band will
113 * be displayed with a different color. In direction mode, the
114 * projective plane is displayed with fully saturated colors that
115 * depend on the angle of the points on the projective plane with
116 * respect to the origin. Angles in opposite directions to the origin
117 * (e.g., 15 and 205 degrees) are displayed in the same color since
118 * they are projectively equivalent. If the projective plane is
119 * displayed as direction bands, each band will be displayed with a
122 * The rotation speed for each of the three coordinate axes around
123 * which the projective plane rotates can be chosen.
125 * Furthermore, in the walking mode the walking direction in the 2d
126 * base square of the projective plane and the walking speed can be
127 * chosen. The walking direction is measured as an angle in degrees
128 * in the 2d square that forms the coordinate system of the surface of
129 * the projective plane. A value of 0 or 180 means that the walk is
130 * along a circle at a randomly chosen distance from the origin
131 * (parallel to a distance band). A value of 90 or 270 means that the
132 * walk is directly from the origin to the line at infinity and back
133 * (analogous to a direction band). Any other value results in a
134 * curved path from the origin to the line at infinity and back.
136 * By default, the immersion of the real projective plane smoothly
137 * deforms between the Roman and Boy surfaces. It is possible to
138 * choose the speed of the deformation. Furthermore, it is possible
139 * to switch the deformation off. It is also possible to determine
140 * the initial deformation of the immersion. This is mostly useful if
141 * the deformation is switched off, in which case it will determine
142 * the appearance of the surface.
144 * As a final option, it is possible to display generalized versions
145 * of the immersion discussed above by specifying the order of the
146 * surface. The default surface order of 3 results in the immersion
147 * of the real projective described above. The surface order can be
148 * chosen between 2 and 9. Odd surface orders result in generalized
149 * immersions of the real projective plane, while even numbers result
150 * in a immersion of a topological sphere (which is orientable). The
151 * most interesting even case is a surface order of 2, which results
152 * in an immersion of the halfway model of Morin's sphere eversion (if
153 * the deformation is switched off).
155 * This program is inspired by François Apéry's book "Models of the
156 * Real Projective Plane", Vieweg, 1987.
159 #include "curlicue.h"
162 #define M_PI 3.14159265358979323846
165 #define DISP_WIREFRAME 0
166 #define DISP_SURFACE 1
167 #define DISP_TRANSPARENT 2
168 #define NUM_DISPLAY_MODES 3
170 #define APPEARANCE_SOLID 0
171 #define APPEARANCE_DISTANCE_BANDS 1
172 #define APPEARANCE_DIRECTION_BANDS 2
173 #define NUM_APPEARANCES 3
175 #define COLORS_TWOSIDED 0
176 #define COLORS_DISTANCE 1
177 #define COLORS_DIRECTION 2
182 #define NUM_VIEW_MODES 2
184 #define DISP_PERSPECTIVE 0
185 #define DISP_ORTHOGRAPHIC 1
186 #define NUM_DISP_MODES 2
188 #define DEF_DISPLAY_MODE "random"
189 #define DEF_APPEARANCE "random"
190 #define DEF_COLORS "random"
191 #define DEF_VIEW_MODE "random"
192 #define DEF_MARKS "False"
193 #define DEF_DEFORM "True"
194 #define DEF_PROJECTION "random"
195 #define DEF_SPEEDX "1.1"
196 #define DEF_SPEEDY "1.3"
197 #define DEF_SPEEDZ "1.5"
198 #define DEF_WALK_DIRECTION "83.0"
199 #define DEF_WALK_SPEED "20.0"
200 #define DEF_DEFORM_SPEED "10.0"
201 #define DEF_INIT_DEFORM "1000.0"
202 #define DEF_SURFACE_ORDER "3"
205 # define DEFAULTS "*delay: 10000 \n" \
206 "*showFPS: False \n" \
208 # define release_romanboy 0
209 # include "xlockmore.h" /* from the xscreensaver distribution */
210 #else /* !STANDALONE */
211 # include "xlock.h" /* from the xlockmore distribution */
212 #endif /* !STANDALONE */
217 # include <X11/keysym.h>
220 #include "gltrackball.h"
226 ModStruct romanboy_description =
227 {"romanboy", "init_romanboy", "draw_romanboy",
228 NULL, "draw_romanboy", "change_romanboy",
229 "free_romanboy", &romanboy_opts, 25000, 1, 1, 1, 1.0, 4, "",
230 "Rotate a 3d immersion of the real projective plane in 3d or walk on it",
238 static char *color_mode;
239 static char *view_mode;
243 static float speed_x;
244 static float speed_y;
245 static float speed_z;
246 static float walk_direction;
247 static float walk_speed;
248 static float deform_speed;
249 static float init_deform;
250 static int surface_order;
253 static XrmOptionDescRec opts[] =
255 {"-mode", ".displayMode", XrmoptionSepArg, 0 },
256 {"-wireframe", ".displayMode", XrmoptionNoArg, "wireframe" },
257 {"-surface", ".displayMode", XrmoptionNoArg, "surface" },
258 {"-transparent", ".displayMode", XrmoptionNoArg, "transparent" },
259 {"-appearance", ".appearance", XrmoptionSepArg, 0 },
260 {"-solid", ".appearance", XrmoptionNoArg, "solid" },
261 {"-distance-bands", ".appearance", XrmoptionNoArg, "distance-bands" },
262 {"-direction-bands", ".appearance", XrmoptionNoArg, "direction-bands" },
263 {"-colors", ".colors", XrmoptionSepArg, 0 },
264 {"-twosided-colors", ".colors", XrmoptionNoArg, "two-sided" },
265 {"-distance-colors", ".colors", XrmoptionNoArg, "distance" },
266 {"-direction-colors", ".colors", XrmoptionNoArg, "direction" },
267 {"-view-mode", ".viewMode", XrmoptionSepArg, 0 },
268 {"-walk", ".viewMode", XrmoptionNoArg, "walk" },
269 {"-turn", ".viewMode", XrmoptionNoArg, "turn" },
270 {"-deform", ".deform", XrmoptionNoArg, "on"},
271 {"+deform", ".deform", XrmoptionNoArg, "off"},
272 {"-orientation-marks", ".marks", XrmoptionNoArg, "on"},
273 {"+orientation-marks", ".marks", XrmoptionNoArg, "off"},
274 {"-projection", ".projection", XrmoptionSepArg, 0 },
275 {"-perspective", ".projection", XrmoptionNoArg, "perspective" },
276 {"-orthographic", ".projection", XrmoptionNoArg, "orthographic" },
277 {"-speed-x", ".speedx", XrmoptionSepArg, 0 },
278 {"-speed-y", ".speedy", XrmoptionSepArg, 0 },
279 {"-speed-z", ".speedz", XrmoptionSepArg, 0 },
280 {"-walk-direction", ".walkDirection", XrmoptionSepArg, 0 },
281 {"-walk-speed", ".walkSpeed", XrmoptionSepArg, 0 },
282 {"-deformation-speed", ".deformSpeed", XrmoptionSepArg, 0 },
283 {"-initial-deformation", ".initDeform", XrmoptionSepArg, 0 },
284 {"-roman", ".initDeform", XrmoptionNoArg, "0.0" },
285 {"-boy", ".initDeform", XrmoptionNoArg, "1000.0" },
286 {"-surface-order", ".surfaceOrder", XrmoptionSepArg, 0 },
289 static argtype vars[] =
291 { &mode, "displayMode", "DisplayMode", DEF_DISPLAY_MODE, t_String },
292 { &appear, "appearance", "Appearance", DEF_APPEARANCE, t_String },
293 { &color_mode, "colors", "Colors", DEF_COLORS, t_String },
294 { &view_mode, "viewMode", "ViewMode", DEF_VIEW_MODE, t_String },
295 { &deform, "deform", "Deform", DEF_DEFORM, t_Bool },
296 { &marks, "marks", "Marks", DEF_MARKS, t_Bool },
297 { &proj, "projection", "Projection", DEF_PROJECTION, t_String },
298 { &speed_x, "speedx", "Speedx", DEF_SPEEDX, t_Float},
299 { &speed_y, "speedy", "Speedy", DEF_SPEEDY, t_Float},
300 { &speed_z, "speedz", "Speedz", DEF_SPEEDZ, t_Float},
301 { &walk_direction, "walkDirection", "WalkDirection", DEF_WALK_DIRECTION, t_Float},
302 { &walk_speed, "walkSpeed", "WalkSpeed", DEF_WALK_SPEED, t_Float},
303 { &deform_speed, "deformSpeed", "DeformSpeed", DEF_DEFORM_SPEED, t_Float},
304 { &init_deform, "initDeform", "InitDeform", DEF_INIT_DEFORM, t_Float },
305 { &surface_order, "surfaceOrder", "SurfaceOrder", DEF_SURFACE_ORDER, t_Int }
308 ENTRYPOINT ModeSpecOpt romanboy_opts =
309 {sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, NULL};
312 /* Offset by which we walk above the projective plane */
315 /* Number of subdivisions of the projective plane */
319 /* Number of subdivisions per band */
325 GLXContext *glx_context;
333 /* 3D rotation angles */
334 float alpha, beta, delta;
335 /* Movement parameters */
336 float umove, vmove, dumove, dvmove;
338 /* Deformation parameters */
341 /* The type of the generalized Roman-Boy surface */
343 /* The viewing offset in 3d */
345 /* The 3d coordinates of the projective plane and their derivatives */
348 /* The precomputed colors of the projective plane */
350 /* The precomputed texture coordinates of the projective plane */
352 /* The "curlicue" texture */
354 /* Aspect ratio of the current window */
356 /* Trackball states */
357 trackball_state *trackball;
359 /* A random factor to modify the rotation speeds */
363 static romanboystruct *romanboy = (romanboystruct *) NULL;
366 /* Add a rotation around the x-axis to the matrix m. */
367 static void rotatex(float m[3][3], float phi)
385 /* Add a rotation around the y-axis to the matrix m. */
386 static void rotatey(float m[3][3], float phi)
404 /* Add a rotation around the z-axis to the matrix m. */
405 static void rotatez(float m[3][3], float phi)
423 /* Compute the rotation matrix m from the rotation angles. */
424 static void rotateall(float al, float be, float de, float m[3][3])
437 /* Multiply two rotation matrices: o=m*n. */
438 static void mult_rotmat(float m[3][3], float n[3][3], float o[3][3])
448 o[i][j] += m[i][k]*n[k][j];
454 /* Compute a 3D rotation matrix from a unit quaternion. */
455 static void quat_to_rotmat(float p[4], float m[3][3])
458 double r00, r01, r02, r12, r22;
460 r00 = 1.0-2.0*(p[1]*p[1]+p[2]*p[2]);
461 r01 = 2.0*(p[0]*p[1]+p[2]*p[3]);
462 r02 = 2.0*(p[2]*p[0]-p[1]*p[3]);
463 r12 = 2.0*(p[1]*p[2]+p[0]*p[3]);
464 r22 = 1.0-2.0*(p[1]*p[1]+p[0]*p[0]);
466 al = atan2(-r12,r22)*180.0/M_PI;
467 be = atan2(r02,sqrt(r00*r00+r01*r01))*180.0/M_PI;
468 de = atan2(-r01,r00)*180.0/M_PI;
470 rotateall(al,be,de,m);
474 /* Compute a fully saturated and bright color based on an angle. */
475 static void color(romanboystruct *pp, double angle, float col[4])
480 if (pp->colors == COLORS_TWOSIDED)
484 angle = fmod(angle,2.0*M_PI);
486 angle = fmod(angle,-2.0*M_PI);
487 s = floor(angle/(M_PI/3));
488 t = angle/(M_PI/3)-s;
524 if (pp->display_mode == DISP_TRANSPARENT)
531 /* Set up the projective plane colors and texture. */
532 static void setup_roman_boy_color_texture(ModeInfo *mi, double umin,
533 double umax, double vmin,
534 double vmax, int numu, int numv)
538 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
543 for (i=0; i<=numv; i++)
545 for (j=0; j<=numu; j++)
548 if (pp->appearance != APPEARANCE_DIRECTION_BANDS)
553 if (pp->colors == COLORS_DIRECTION)
554 color(pp,2.0*M_PI-fmod(2.0*u,2.0*M_PI),&pp->col[4*k]);
555 else /* pp->colors == COLORS_DISTANCE */
556 color(pp,v*(5.0/6.0),&pp->col[4*k]);
557 pp->tex[2*k+0] = -16*g*u/(2.0*M_PI);
558 if (pp->appearance == APPEARANCE_DISTANCE_BANDS)
559 pp->tex[2*k+1] = 32*v/(2.0*M_PI)-0.5;
561 pp->tex[2*k+1] = 32*v/(2.0*M_PI);
567 /* Draw a 3d immersion of the projective plane. */
568 static int roman_boy(ModeInfo *mi, double umin, double umax,
569 double vmin, double vmax, int numu, int numv)
572 static const GLfloat mat_diff_red[] = { 1.0, 0.0, 0.0, 1.0 };
573 static const GLfloat mat_diff_green[] = { 0.0, 1.0, 0.0, 1.0 };
574 static const GLfloat mat_diff_trans_red[] = { 1.0, 0.0, 0.0, 0.7 };
575 static const GLfloat mat_diff_trans_green[] = { 0.0, 1.0, 0.0, 0.7 };
576 float p[3], pu[3], pv[3], pm[3], n[3], b[3], mat[3][3];
577 int i, j, k, l, m, o, g;
578 double u, v, ur, vr, oz;
579 double xx[3], xxu[3], xxv[3];
581 double d, dd, radius;
582 double cu, su, cgu, sgu, cgm1u, sgm1u, cv, c2v, s2v, cv2;
583 double sqrt2og, h1m1og, gm1, nomx, nomy, nomux, nomuy, nomvx, nomvy;
584 double den, den2, denu, denv;
585 float qu[4], r1[3][3], r2[3][3];
586 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
590 d = ((6.0*dd-15.0)*dd+10.0)*dd*dd*dd;
591 r = 1.0+d*d*(1.0/2.0+d*d*(1.0/6.0+d*d*(1.0/3.0)));
594 if (pp->view == VIEW_WALK)
603 h1m1og = 0.5*(1.0-1.0/g);
615 nomx = sqrt2og*cv2*cgm1u+h1m1og*s2v*cu;
616 nomy = sqrt2og*cv2*sgm1u-h1m1og*s2v*su;
617 nomux = -sqrt2og*cv2*gm1*sgm1u-h1m1og*s2v*su;
618 nomuy = sqrt2og*cv2*gm1*cgm1u-h1m1og*s2v*cu;
619 nomvx = -sqrt2og*s2v*cgm1u+2.0*h1m1og*c2v*cu;
620 nomvy = -sqrt2og*s2v*sgm1u-2.0*h1m1og*c2v*su;
621 den = 1.0/(1.0-0.5*M_SQRT2*d*s2v*sgu);
623 denu = 0.5*M_SQRT2*d*g*cgu*s2v;
624 denv = M_SQRT2*d*sgu*c2v;
628 /* Avoid degenerate tangential plane basis vectors. */
629 if (0.5*M_PI-fabs(v) < FLT_EPSILON)
631 if (0.5*M_PI-v < FLT_EPSILON)
632 v = 0.5*M_PI-FLT_EPSILON;
634 v = -0.5*M_PI+FLT_EPSILON;
639 nomx = sqrt2og*cv2*cgm1u+h1m1og*s2v*cu;
640 nomy = sqrt2og*cv2*sgm1u-h1m1og*s2v*su;
641 nomux = -sqrt2og*cv2*gm1*sgm1u-h1m1og*s2v*su;
642 nomuy = sqrt2og*cv2*gm1*cgm1u-h1m1og*s2v*cu;
643 nomvx = -sqrt2og*s2v*cgm1u+2.0*h1m1og*c2v*cu;
644 nomvy = -sqrt2og*s2v*sgm1u-2.0*h1m1og*c2v*su;
645 den = 1.0/(1.0-0.5*M_SQRT2*d*s2v*sgu);
647 denu = 0.5*M_SQRT2*d*g*cgu*s2v;
648 denv = M_SQRT2*d*sgu*c2v;
650 xxu[0] = nomux*den+nomx*denu*den2;
651 xxu[1] = nomuy*den+nomy*denu*den2;
652 xxu[2] = cv2*denu*den2;
653 xxv[0] = nomvx*den+nomx*denv*den2;
654 xxv[1] = nomvy*den+nomy*denv*den2;
655 xxv[2] = -s2v*den+cv2*denv*den2;
659 pu[l] = xxu[l]*radius;
660 pv[l] = xxv[l]*radius;
662 n[0] = pu[1]*pv[2]-pu[2]*pv[1];
663 n[1] = pu[2]*pv[0]-pu[0]*pv[2];
664 n[2] = pu[0]*pv[1]-pu[1]*pv[0];
665 t = 1.0/(pp->side*4.0*sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]));
669 pm[0] = pu[0]*pp->dumove-pv[0]*0.25*pp->dvmove;
670 pm[1] = pu[1]*pp->dumove-pv[1]*0.25*pp->dvmove;
671 pm[2] = pu[2]*pp->dumove-pv[2]*0.25*pp->dvmove;
672 t = 1.0/(4.0*sqrt(pm[0]*pm[0]+pm[1]*pm[1]+pm[2]*pm[2]));
676 b[0] = n[1]*pm[2]-n[2]*pm[1];
677 b[1] = n[2]*pm[0]-n[0]*pm[2];
678 b[2] = n[0]*pm[1]-n[1]*pm[0];
679 t = 1.0/(4.0*sqrt(b[0]*b[0]+b[1]*b[1]+b[2]*b[2]));
684 /* Compute alpha, beta, gamma from the three basis vectors.
685 | -b[0] -b[1] -b[2] |
686 m = | n[0] n[1] n[2] |
687 | -pm[0] -pm[1] -pm[2] |
689 pp->alpha = atan2(-n[2],-pm[2])*180/M_PI;
690 pp->beta = atan2(-b[2],sqrt(b[0]*b[0]+b[1]*b[1]))*180/M_PI;
691 pp->delta = atan2(b[1],-b[0])*180/M_PI;
693 /* Compute the rotation that rotates the projective plane in 3D. */
694 rotateall(pp->alpha,pp->beta,pp->delta,mat);
703 h1m1og = 0.5*(1.0-1.0/g);
713 nomx = sqrt2og*cv2*cgm1u+h1m1og*s2v*cu;
714 nomy = sqrt2og*cv2*sgm1u-h1m1og*s2v*su;
715 den = 1.0/(1.0-0.5*M_SQRT2*d*s2v*sgu);
723 r += mat[l][m]*xx[m];
727 pp->offset3d[0] = -p[0];
728 pp->offset3d[1] = -p[1]-DELTAY;
729 pp->offset3d[2] = -p[2];
733 /* Compute the rotation that rotates the projective plane in 3D,
734 including the trackball rotations. */
735 rotateall(pp->alpha,pp->beta,pp->delta,r1);
737 gltrackball_get_quaternion(pp->trackball,qu);
738 quat_to_rotmat(qu,r2);
740 mult_rotmat(r2,r1,mat);
743 if (pp->colors == COLORS_TWOSIDED)
745 glColor3fv(mat_diff_red);
746 if (pp->display_mode == DISP_TRANSPARENT)
748 glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_red);
749 glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_green);
753 glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_red);
754 glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_green);
757 glBindTexture(GL_TEXTURE_2D,pp->tex_name);
762 /* Set up the projective plane coordinates and normals. */
763 if (pp->appearance != APPEARANCE_DIRECTION_BANDS)
765 for (i=0; i<=numv; i++)
767 if (pp->appearance == APPEARANCE_DISTANCE_BANDS &&
768 ((i & (NUMB-1)) >= NUMB/4+1) && ((i & (NUMB-1)) < 3*NUMB/4))
770 for (j=0; j<=numu; j++)
780 h1m1og = 0.5*(1.0-1.0/g);
792 nomx = sqrt2og*cv2*cgm1u+h1m1og*s2v*cu;
793 nomy = sqrt2og*cv2*sgm1u-h1m1og*s2v*su;
794 nomux = -sqrt2og*cv2*gm1*sgm1u-h1m1og*s2v*su;
795 nomuy = sqrt2og*cv2*gm1*cgm1u-h1m1og*s2v*cu;
796 nomvx = -sqrt2og*s2v*cgm1u+2.0*h1m1og*c2v*cu;
797 nomvy = -sqrt2og*s2v*sgm1u-2.0*h1m1og*c2v*su;
798 den = 1.0/(1.0-0.5*M_SQRT2*d*s2v*sgu);
800 denu = 0.5*M_SQRT2*d*g*cgu*s2v;
801 denv = M_SQRT2*d*sgu*c2v;
805 /* Avoid degenerate tangential plane basis vectors. */
806 if (0.5*M_PI-fabs(v) < FLT_EPSILON)
808 if (0.5*M_PI-v < FLT_EPSILON)
809 v = 0.5*M_PI-FLT_EPSILON;
811 v = -0.5*M_PI+FLT_EPSILON;
816 nomx = sqrt2og*cv2*cgm1u+h1m1og*s2v*cu;
817 nomy = sqrt2og*cv2*sgm1u-h1m1og*s2v*su;
818 nomux = -sqrt2og*cv2*gm1*sgm1u-h1m1og*s2v*su;
819 nomuy = sqrt2og*cv2*gm1*cgm1u-h1m1og*s2v*cu;
820 nomvx = -sqrt2og*s2v*cgm1u+2.0*h1m1og*c2v*cu;
821 nomvy = -sqrt2og*s2v*sgm1u-2.0*h1m1og*c2v*su;
822 den = 1.0/(1.0-0.5*M_SQRT2*d*s2v*sgu);
824 denu = 0.5*M_SQRT2*d*g*cgu*s2v;
825 denv = M_SQRT2*d*sgu*c2v;
827 xxu[0] = nomux*den+nomx*denu*den2;
828 xxu[1] = nomuy*den+nomy*denu*den2;
829 xxu[2] = cv2*denu*den2;
830 xxv[0] = nomvx*den+nomx*denv*den2;
831 xxv[1] = nomvy*den+nomy*denv*den2;
832 xxv[2] = -s2v*den+cv2*denv*den2;
840 r += mat[l][m]*xx[m];
841 s += mat[l][m]*xxu[m];
842 t += mat[l][m]*xxv[m];
844 p[l] = r*radius+pp->offset3d[l];
848 n[0] = pu[1]*pv[2]-pu[2]*pv[1];
849 n[1] = pu[2]*pv[0]-pu[0]*pv[2];
850 n[2] = pu[0]*pv[1]-pu[1]*pv[0];
851 t = 1.0/sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);
855 pp->pp[3*o+0] = p[0];
856 pp->pp[3*o+1] = p[1];
857 pp->pp[3*o+2] = p[2];
858 pp->pn[3*o+0] = n[0];
859 pp->pn[3*o+1] = n[1];
860 pp->pn[3*o+2] = n[2];
864 else /* pp->appearance == APPEARANCE_DIRECTION_BANDS */
866 for (j=0; j<=numu; j++)
868 if ((j & (NUMB-1)) >= NUMB/2+1)
870 for (i=0; i<=numv; i++)
880 h1m1og = 0.5*(1.0-1.0/g);
892 nomx = sqrt2og*cv2*cgm1u+h1m1og*s2v*cu;
893 nomy = sqrt2og*cv2*sgm1u-h1m1og*s2v*su;
894 nomux = -sqrt2og*cv2*gm1*sgm1u-h1m1og*s2v*su;
895 nomuy = sqrt2og*cv2*gm1*cgm1u-h1m1og*s2v*cu;
896 nomvx = -sqrt2og*s2v*cgm1u+2.0*h1m1og*c2v*cu;
897 nomvy = -sqrt2og*s2v*sgm1u-2.0*h1m1og*c2v*su;
898 den = 1.0/(1.0-0.5*M_SQRT2*d*s2v*sgu);
900 denu = 0.5*M_SQRT2*d*g*cgu*s2v;
901 denv = M_SQRT2*d*sgu*c2v;
905 /* Avoid degenerate tangential plane basis vectors. */
906 if (0.5*M_PI-fabs(v) < FLT_EPSILON)
908 if (0.5*M_PI-v < FLT_EPSILON)
909 v = 0.5*M_PI-FLT_EPSILON;
911 v = -0.5*M_PI+FLT_EPSILON;
916 nomx = sqrt2og*cv2*cgm1u+h1m1og*s2v*cu;
917 nomy = sqrt2og*cv2*sgm1u-h1m1og*s2v*su;
918 nomux = -sqrt2og*cv2*gm1*sgm1u-h1m1og*s2v*su;
919 nomuy = sqrt2og*cv2*gm1*cgm1u-h1m1og*s2v*cu;
920 nomvx = -sqrt2og*s2v*cgm1u+2.0*h1m1og*c2v*cu;
921 nomvy = -sqrt2og*s2v*sgm1u-2.0*h1m1og*c2v*su;
922 den = 1.0/(1.0-0.5*M_SQRT2*d*s2v*sgu);
924 denu = 0.5*M_SQRT2*d*g*cgu*s2v;
925 denv = M_SQRT2*d*sgu*c2v;
927 xxu[0] = nomux*den+nomx*denu*den2;
928 xxu[1] = nomuy*den+nomy*denu*den2;
929 xxu[2] = cv2*denu*den2;
930 xxv[0] = nomvx*den+nomx*denv*den2;
931 xxv[1] = nomvy*den+nomy*denv*den2;
932 xxv[2] = -s2v*den+cv2*denv*den2;
940 r += mat[l][m]*xx[m];
941 s += mat[l][m]*xxu[m];
942 t += mat[l][m]*xxv[m];
944 p[l] = r*radius+pp->offset3d[l];
948 n[0] = pu[1]*pv[2]-pu[2]*pv[1];
949 n[1] = pu[2]*pv[0]-pu[0]*pv[2];
950 n[2] = pu[0]*pv[1]-pu[1]*pv[0];
951 t = 1.0/sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);
955 pp->pp[3*o+0] = p[0];
956 pp->pp[3*o+1] = p[1];
957 pp->pp[3*o+2] = p[2];
958 pp->pn[3*o+0] = n[0];
959 pp->pn[3*o+1] = n[1];
960 pp->pn[3*o+2] = n[2];
965 if (pp->appearance != APPEARANCE_DIRECTION_BANDS)
967 for (i=0; i<numv; i++)
969 if (pp->appearance == APPEARANCE_DISTANCE_BANDS &&
970 ((i & (NUMB-1)) >= NUMB/4) && ((i & (NUMB-1)) < 3*NUMB/4))
972 if (pp->display_mode == DISP_WIREFRAME)
973 glBegin(GL_QUAD_STRIP);
975 glBegin(GL_TRIANGLE_STRIP);
976 for (j=0; j<=numu; j++)
983 glTexCoord2fv(&pp->tex[2*o]);
984 if (pp->colors != COLORS_TWOSIDED)
986 glColor3fv(&pp->col[4*o]);
987 glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,
990 glNormal3fv(&pp->pn[3*o]);
991 glVertex3fv(&pp->pp[3*o]);
998 else /* pp->appearance == APPEARANCE_DIRECTION_BANDS */
1000 for (j=0; j<numu; j++)
1002 if ((j & (NUMB-1)) >= NUMB/2)
1004 if (pp->display_mode == DISP_WIREFRAME)
1005 glBegin(GL_QUAD_STRIP);
1007 glBegin(GL_TRIANGLE_STRIP);
1008 for (i=0; i<=numv; i++)
1010 for (k=0; k<=1; k++)
1015 glTexCoord2fv(&pp->tex[2*o]);
1016 if (pp->colors != COLORS_TWOSIDED)
1018 glColor3fv(&pp->col[4*o]);
1019 glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,
1022 glNormal3fv(&pp->pn[3*o]);
1023 glVertex3fv(&pp->pp[3*o]);
1036 /* Generate a texture image that shows the orientation reversal. */
1037 static void gen_texture(ModeInfo *mi)
1039 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
1041 glGenTextures(1,&pp->tex_name);
1042 glBindTexture(GL_TEXTURE_2D,pp->tex_name);
1043 glPixelStorei(GL_UNPACK_ALIGNMENT,1);
1044 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
1045 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
1046 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
1047 glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
1048 glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
1049 glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,TEX_DIMENSION,TEX_DIMENSION,0,
1050 GL_LUMINANCE,GL_UNSIGNED_BYTE,texture);
1054 static void init(ModeInfo *mi)
1056 static const GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 };
1057 static const GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
1058 static const GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
1059 static const GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
1060 static const GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
1061 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
1063 if (deform_speed == 0.0)
1064 deform_speed = 10.0;
1066 if (init_deform < 0.0)
1068 if (init_deform > 1000.0)
1069 init_deform = 1000.0;
1071 if (walk_speed == 0.0)
1074 if (pp->view == VIEW_TURN)
1076 pp->alpha = frand(360.0);
1077 pp->beta = frand(360.0);
1078 pp->delta = frand(360.0);
1086 pp->umove = frand(2.0*M_PI);
1087 pp->vmove = frand(2.0*M_PI);
1091 if (sin(walk_direction*M_PI/180.0) >= 0.0)
1096 pp->dd = init_deform*0.001;
1099 pp->offset3d[0] = 0.0;
1100 pp->offset3d[1] = 0.0;
1101 pp->offset3d[2] = -1.8;
1104 setup_roman_boy_color_texture(mi,0.0,2.0*M_PI,0.0,2.0*M_PI,pp->g*NUMU,NUMV);
1107 glEnable(GL_TEXTURE_2D);
1109 glDisable(GL_TEXTURE_2D);
1111 glMatrixMode(GL_PROJECTION);
1113 if (pp->projection == DISP_PERSPECTIVE || pp->view == VIEW_WALK)
1115 if (pp->view == VIEW_WALK)
1116 gluPerspective(60.0,1.0,0.01,10.0);
1118 gluPerspective(60.0,1.0,0.1,10.0);
1122 glOrtho(-1.0,1.0,-1.0,1.0,0.1,10.0);
1124 glMatrixMode(GL_MODELVIEW);
1127 # ifdef HAVE_JWZGLES /* #### glPolygonMode other than GL_FILL unimplemented */
1128 if (pp->display_mode == DISP_WIREFRAME)
1129 pp->display_mode = DISP_SURFACE;
1132 if (pp->display_mode == DISP_SURFACE)
1134 glEnable(GL_DEPTH_TEST);
1135 glDepthFunc(GL_LESS);
1136 glShadeModel(GL_SMOOTH);
1137 glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
1138 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
1139 glEnable(GL_LIGHTING);
1140 glEnable(GL_LIGHT0);
1141 glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
1142 glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
1143 glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular);
1144 glLightfv(GL_LIGHT0,GL_POSITION,light_position);
1145 glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
1146 glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0);
1147 glDepthMask(GL_TRUE);
1148 glDisable(GL_BLEND);
1150 else if (pp->display_mode == DISP_TRANSPARENT)
1152 glDisable(GL_DEPTH_TEST);
1153 glShadeModel(GL_SMOOTH);
1154 glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
1155 glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
1156 glEnable(GL_LIGHTING);
1157 glEnable(GL_LIGHT0);
1158 glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
1159 glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
1160 glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular);
1161 glLightfv(GL_LIGHT0,GL_POSITION,light_position);
1162 glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
1163 glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0);
1164 glDepthMask(GL_FALSE);
1166 glBlendFunc(GL_SRC_ALPHA,GL_ONE);
1168 else /* pp->display_mode == DISP_WIREFRAME */
1170 glDisable(GL_DEPTH_TEST);
1171 glShadeModel(GL_FLAT);
1172 glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
1173 glDisable(GL_LIGHTING);
1174 glDisable(GL_LIGHT0);
1175 glDisable(GL_BLEND);
1180 /* Redisplay the Klein bottle. */
1181 static void display_romanboy(ModeInfo *mi)
1183 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
1185 if (!pp->button_pressed)
1189 pp->dd += pp->defdir*deform_speed*0.001;
1193 pp->defdir = -pp->defdir;
1197 pp->dd = 2.0-pp->dd;
1198 pp->defdir = -pp->defdir;
1201 if (pp->view == VIEW_TURN)
1203 pp->alpha += speed_x * pp->speed_scale;
1204 if (pp->alpha >= 360.0)
1206 pp->beta += speed_y * pp->speed_scale;
1207 if (pp->beta >= 360.0)
1209 pp->delta += speed_z * pp->speed_scale;
1210 if (pp->delta >= 360.0)
1213 if (pp->view == VIEW_WALK)
1215 pp->dvmove = (pp->dir*sin(walk_direction*M_PI/180.0)*
1216 walk_speed*M_PI/4096.0);
1217 pp->vmove += pp->dvmove;
1218 if (pp->vmove > 2.0*M_PI)
1220 pp->vmove = 4.0*M_PI-pp->vmove;
1221 pp->umove = pp->umove-M_PI;
1222 if (pp->umove < 0.0)
1223 pp->umove += 2.0*M_PI;
1224 pp->side = -pp->side;
1226 pp->dvmove = -pp->dvmove;
1228 if (pp->vmove < 0.0)
1230 pp->vmove = -pp->vmove;
1231 pp->umove = pp->umove-M_PI;
1232 if (pp->umove < 0.0)
1233 pp->umove += 2.0*M_PI;
1235 pp->dvmove = -pp->dvmove;
1237 pp->dumove = cos(walk_direction*M_PI/180.0)*walk_speed*M_PI/4096.0;
1238 pp->umove += pp->dumove;
1239 if (pp->umove >= 2.0*M_PI)
1240 pp->umove -= 2.0*M_PI;
1241 if (pp->umove < 0.0)
1242 pp->umove += 2.0*M_PI;
1246 glMatrixMode(GL_PROJECTION);
1248 if (pp->projection == DISP_PERSPECTIVE || pp->view == VIEW_WALK)
1250 if (pp->view == VIEW_WALK)
1251 gluPerspective(60.0,pp->aspect,0.01,10.0);
1253 gluPerspective(60.0,pp->aspect,0.1,10.0);
1257 if (pp->aspect >= 1.0)
1258 glOrtho(-pp->aspect,pp->aspect,-1.0,1.0,0.1,10.0);
1260 glOrtho(-1.0,1.0,-1.0/pp->aspect,1.0/pp->aspect,0.1,10.0);
1262 glMatrixMode(GL_MODELVIEW);
1265 mi->polygon_count = roman_boy(mi,0.0,2.0*M_PI,0.0,2.0*M_PI,pp->g*NUMU,NUMV);
1269 ENTRYPOINT void reshape_romanboy(ModeInfo *mi, int width, int height)
1271 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
1274 if (width > height * 5) { /* tiny window: show middle */
1279 pp->WindW = (GLint)width;
1280 pp->WindH = (GLint)height;
1281 glViewport(0,y,width,height);
1282 pp->aspect = (GLfloat)width/(GLfloat)height;
1286 ENTRYPOINT Bool romanboy_handle_event(ModeInfo *mi, XEvent *event)
1288 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
1290 if (event->xany.type == ButtonPress && event->xbutton.button == Button1)
1292 pp->button_pressed = True;
1293 gltrackball_start(pp->trackball, event->xbutton.x, event->xbutton.y,
1294 MI_WIDTH(mi), MI_HEIGHT(mi));
1297 else if (event->xany.type == ButtonRelease &&
1298 event->xbutton.button == Button1)
1300 pp->button_pressed = False;
1303 else if (event->xany.type == MotionNotify && pp->button_pressed)
1305 gltrackball_track(pp->trackball, event->xmotion.x, event->xmotion.y,
1306 MI_WIDTH(mi), MI_HEIGHT(mi));
1315 *-----------------------------------------------------------------------------
1316 *-----------------------------------------------------------------------------
1318 *-----------------------------------------------------------------------------
1319 *-----------------------------------------------------------------------------
1323 *-----------------------------------------------------------------------------
1324 * Initialize romanboy. Called each time the window changes.
1325 *-----------------------------------------------------------------------------
1328 ENTRYPOINT void init_romanboy(ModeInfo *mi)
1332 MI_INIT (mi, romanboy);
1333 pp = &romanboy[MI_SCREEN(mi)];
1335 if (surface_order < 2)
1337 else if (surface_order > 9)
1340 pp->g = surface_order;
1342 pp->pp = calloc(3*pp->g*(NUMU+1)*(NUMV+1),sizeof(float));
1343 pp->pn = calloc(3*pp->g*(NUMU+1)*(NUMV+1),sizeof(float));
1344 pp->col = calloc(4*pp->g*(NUMU+1)*(NUMV+1),sizeof(float));
1345 pp->tex = calloc(2*pp->g*(NUMU+1)*(NUMV+1),sizeof(float));
1347 pp->trackball = gltrackball_init(True);
1348 pp->button_pressed = False;
1350 /* Set the display mode. */
1351 if (!strcasecmp(mode,"random"))
1353 pp->display_mode = random() % NUM_DISPLAY_MODES;
1355 else if (!strcasecmp(mode,"wireframe"))
1357 pp->display_mode = DISP_WIREFRAME;
1359 else if (!strcasecmp(mode,"surface"))
1361 pp->display_mode = DISP_SURFACE;
1363 else if (!strcasecmp(mode,"transparent"))
1365 pp->display_mode = DISP_TRANSPARENT;
1369 pp->display_mode = random() % NUM_DISPLAY_MODES;
1374 /* Orientation marks don't make sense in wireframe mode. */
1375 if (pp->display_mode == DISP_WIREFRAME)
1378 /* Set the appearance. */
1379 if (!strcasecmp(appear,"random"))
1381 pp->appearance = random() % NUM_APPEARANCES;
1383 else if (!strcasecmp(appear,"solid"))
1385 pp->appearance = APPEARANCE_SOLID;
1387 else if (!strcasecmp(appear,"distance-bands"))
1389 pp->appearance = APPEARANCE_DISTANCE_BANDS;
1391 else if (!strcasecmp(appear,"direction-bands"))
1393 pp->appearance = APPEARANCE_DIRECTION_BANDS;
1397 pp->appearance = random() % NUM_APPEARANCES;
1400 /* Set the color mode. */
1401 if (!strcasecmp(color_mode,"random"))
1403 pp->colors = random() % NUM_COLORS;
1405 else if (!strcasecmp(color_mode,"two-sided"))
1407 pp->colors = COLORS_TWOSIDED;
1409 else if (!strcasecmp(color_mode,"distance"))
1411 pp->colors = COLORS_DISTANCE;
1413 else if (!strcasecmp(color_mode,"direction"))
1415 pp->colors = COLORS_DIRECTION;
1419 pp->colors = random() % NUM_COLORS;
1422 /* Set the view mode. */
1423 if (!strcasecmp(view_mode,"random"))
1425 pp->view = random() % NUM_VIEW_MODES;
1427 else if (!strcasecmp(view_mode,"walk"))
1429 pp->view = VIEW_WALK;
1431 else if (!strcasecmp(view_mode,"turn"))
1433 pp->view = VIEW_TURN;
1437 pp->view = random() % NUM_VIEW_MODES;
1440 /* Set the 3d projection mode. */
1441 if (!strcasecmp(proj,"random"))
1443 /* Orthographic projection only makes sense in turn mode. */
1444 if (pp->view == VIEW_TURN)
1445 pp->projection = random() % NUM_DISP_MODES;
1447 pp->projection = DISP_PERSPECTIVE;
1449 else if (!strcasecmp(proj,"perspective"))
1451 pp->projection = DISP_PERSPECTIVE;
1453 else if (!strcasecmp(proj,"orthographic"))
1455 pp->projection = DISP_ORTHOGRAPHIC;
1459 /* Orthographic projection only makes sense in turn mode. */
1460 if (pp->view == VIEW_TURN)
1461 pp->projection = random() % NUM_DISP_MODES;
1463 pp->projection = DISP_PERSPECTIVE;
1466 /* make multiple screens rotate at slightly different rates. */
1467 pp->speed_scale = 0.9 + frand(0.3);
1469 if ((pp->glx_context = init_GL(mi)) != NULL)
1471 reshape_romanboy(mi,MI_WIDTH(mi),MI_HEIGHT(mi));
1472 glDrawBuffer(GL_BACK);
1482 *-----------------------------------------------------------------------------
1483 * Called by the mainline code periodically to update the display.
1484 *-----------------------------------------------------------------------------
1486 ENTRYPOINT void draw_romanboy(ModeInfo *mi)
1488 Display *display = MI_DISPLAY(mi);
1489 Window window = MI_WINDOW(mi);
1492 if (romanboy == NULL)
1494 pp = &romanboy[MI_SCREEN(mi)];
1496 MI_IS_DRAWN(mi) = True;
1497 if (!pp->glx_context)
1500 glXMakeCurrent(display,window,*(pp->glx_context));
1502 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
1505 display_romanboy(mi);
1512 glXSwapBuffers(display,window);
1517 *-----------------------------------------------------------------------------
1518 * The display is being taken away from us. Free up malloc'ed
1519 * memory and X resources that we've alloc'ed.
1520 *-----------------------------------------------------------------------------
1523 ENTRYPOINT void free_romanboy(ModeInfo *mi)
1525 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
1528 (void) free((void *)pp->pp);
1530 (void) free((void *)pp->pn);
1532 (void) free((void *)pp->col);
1534 (void) free((void *)pp->tex);
1538 ENTRYPOINT void change_romanboy(ModeInfo *mi)
1540 romanboystruct *pp = &romanboy[MI_SCREEN(mi)];
1542 if (!pp->glx_context)
1545 glXMakeCurrent(MI_DISPLAY(mi),MI_WINDOW(mi),*(pp->glx_context));
1548 #endif /* !STANDALONE */
1550 XSCREENSAVER_MODULE ("RomanBoy", romanboy)