54074e65f84a8eb792d0cb4a064fb2b4523225d1
[xscreensaver] / hacks / glx / gleidescope.c
1 /* -*- Mode: C; tab-width: 4 -*- */
2 /* vim: set ai ts=4 sw=4: */
3
4 #if !defined( lint ) && !defined( SABER )
5 /*static const char sccsid[] = "@(#)gleidescope.c       1.0 03/06/27 xlockmore";*/
6 #endif
7
8 /* enable -grab switch for animations */
9 #undef  GRAB
10
11 #undef DISPLAY_TEXTURE
12
13 /*-
14  * Permission to use, copy, modify, and distribute this software and its
15  * documentation for any purpose and without fee is hereby granted,
16  * provided that the above copyright notice appear in all copies and that
17  * both that copyright notice and this permission notice appear in
18  * supporting documentation.
19  *
20  * This file is provided AS IS with no warranties of any kind.  The author
21  * shall have no liability with respect to the infringement of copyrights,
22  * trade secrets or any patents by this file or any part thereof.  In no
23  * event will the author be liable for any lost revenue or profits or
24  * other special, indirect and consequential damages.
25  *
26  *      Revision History:
27  *
28  *      20030627        1.0             acd             First Release.
29  *                                                              Texture loading code from 'glplanet'
30  *                                                                      by Jamie Zawinski <jwz@jwz.org>
31  *      20030810        1.1             acd             Added size flag.
32  *                                                              Now grabs screen / video / picture
33  *                                                                      (uses code from 'glslideshow' by
34  *                                                                      Mike Oliphant, Ben Buxton, Jamie Zawinski).
35  *                                                              Added -duration.
36  *                                                              Added mouse code.
37  *                                                              Added fade code (also from glslideshow).
38  *      20031013        1.2             acd             Migrated to compile without warnings under
39  *                                                                      xscreensaver 4.13.
40  *      20031023        1.3             acd             Better code to limit twisting speeds.
41  *                                                              Tweaked initial rotation values.
42  *                                                              Move, Rotate, Zoom now chosen at random if
43  *                                                                      no preference is given.
44  *                                                              Made grid slightly bigger so you can't see
45  *                                                                      the edge when zooming and moving.
46  *      20061226        1.4             acd             Now uses GL Display Lists.
47  *      20070318        1.5             acd             Generates textures.
48  *                                                              Fixed texture size problem (and introduced another).
49  *      20070412        1.6             acd             Textures now have independant sizes.
50  *      20070413        1.7             acd             Added Lissajous movement pattern.
51  *      20070414        1.8             acd             Added corners movement pattern.
52  *      20080319        1.9             acd             Changes to arguments for saner gleidescope.xml.
53  *
54  * TODO
55  * generate textures myself - render random shapes to 256x256 texture. (done)
56  * lower res for checks and random - use 256 and 4x4 or 8x8 pixels. (disabled for now)
57  * gnome-saver doesn't let you specify source directory so add that to this.
58  * image loading routine is too slow - rotation grinds to a halt - stop using it. (better in version 5)
59  * image loading also looks bad for non-square images - edges are black. (fixed)
60  * possible to see edge of the world on widescreen terminals - use larger grid and hidden hex removal?
61  * fading textures may have different max_tx - use two sets. (done)
62  * choice of movement patterns. (3 implemented, chooseable at compile time)
63  * look into rangle and tangle.
64  */
65
66 /*
67 **----------------------------------------------------------------------------
68 ** Defines
69 **----------------------------------------------------------------------------
70 */
71
72 #ifdef STANDALONE
73 # define DEFAULTS \
74                 "*delay:                20000           \n"     \
75                 "*showFPS:              False           \n"     \
76                 "*size:                 0                       \n"     \
77                 "*useSHM:               True            \n"
78
79 # define refresh_gleidescope 0
80 # include "xlockmore.h"                         /* from the xscreensaver distribution */
81 #else  /* !STANDALONE */
82 # include "xlock.h"                                     /* from the xlockmore distribution */
83 #endif /* !STANDALONE */
84
85 #ifdef USE_GL
86
87 #include "colors.h"
88 #include "xpm-ximage.h"
89 #include "grab-ximage.h"
90
91 #ifdef GRAB
92 void grab_frame(Display *display, Window window);
93 #endif
94
95 /* acd TODO should all these be in gleidestruct? */
96 /* they can't be, because of the idiotic way the xlockmore "argtype vars"
97    interface works. -jwz */
98 #ifdef GRAB
99 static Bool             grab;                   /* grab images */
100 #endif
101 static Bool             move;                   /* moving camera */
102 static Bool             nomove;                 /* no moving camera */
103 static Bool             rotate;                 /* rotate in place */
104 static Bool             norotate;               /* no rotate in place */
105 static Bool             zoom;                   /* zooming camera */
106 static Bool             nozoom;                 /* no zooming camera */
107 static char             *image;                 /* name of texture to load */
108 static int              duration;               /* length of time to display grabbed image */
109
110 #define MAX_CAM_SPEED                   1.0
111 #define MAX_ANGLE_VEL                   1.0
112 #define INITIAL_ANGLE_VEL               0.2
113 #define INITIAL_ANGLE_ACC               0.001
114 #define TWISTING_PROBABILITY    1000    /* 1 in ... of change of acceleration */
115
116 #define RADIANS (M_PI / 180)
117 #define ANGLE_120       (M_PI * 2 / 3)
118 #define ANGLE_240       (M_PI * 4 / 3)
119
120 #define DEF_GRAB        "False"
121 #define DEF_MOVE        "False"
122 #define DEF_NOMOVE      "False"
123 #define DEF_ROTATE      "False"
124 #define DEF_NOROTATE    "False"
125 #define DEF_ZOOM        "False"
126 #define DEF_NOZOOM      "False"
127 #define DEF_IMAGE       "DEFAULT"
128 #define DEF_DURATION    "30"
129
130
131 static XrmOptionDescRec opts[] =
132 {
133 #ifdef GRAB
134         {"-grab",               ".gleidescope.grab",            XrmoptionNoArg,         "true"},
135 #endif
136         {"-move",               ".gleidescope.move",            XrmoptionNoArg,         "true"},
137         {"-no-move",    ".gleidescope.nomove",          XrmoptionNoArg,         "true"},
138         {"-rotate",             ".gleidescope.rotate",          XrmoptionNoArg,         "true"},
139         {"-no-rotate",  ".gleidescope.norotate",        XrmoptionNoArg,         "true"},
140         {"-zoom",               ".gleidescope.zoom",            XrmoptionNoArg,         "true"},
141         {"-no-zoom",    ".gleidescope.nozoom",          XrmoptionNoArg,         "true"},
142         {"-image",              ".gleidescope.image",           XrmoptionSepArg,        "DEFAULT"},
143         {"-duration",   ".gleidescope.duration",        XrmoptionSepArg,        "30"},
144 };
145
146
147 static argtype vars[] = {
148 #ifdef GRAB
149         {&grab,                 "grab",         "Grab",         DEF_GRAB,       t_Bool},
150 #endif
151         {&move,                 "move",         "Move",         DEF_MOVE,       t_Bool},
152         {&nomove,               "nomove",       "noMove",       DEF_NOMOVE,     t_Bool},
153         {&rotate,               "rotate",       "Rotate",       DEF_ROTATE,     t_Bool},
154         {&norotate,             "norotate",     "noRotate",     DEF_NOROTATE,   t_Bool},
155         {&zoom,                 "zoom",         "Zoom",         DEF_ZOOM,       t_Bool},
156         {&nozoom,               "nozoom",       "noZoom",       DEF_NOZOOM,     t_Bool},
157         {&image,                "image",        "Image",        DEF_IMAGE,      t_String},
158         {&duration,             "duration",     "Duration",     DEF_DURATION,           t_Int},
159 };
160
161 static OptionStruct desc[] = {
162 #ifdef GRAB
163         {"-grab",               "grab images to create animation"},
164 #endif
165         {"-move",               "camera will move"},
166         {"-no-move",    "camera won't move"},
167         {"-rotate",             "camera will rotate"},
168         {"-no-rotate",  "camera won't rotate"},
169         {"-zoom",               "camera will zoom"},
170         {"-no-zoom",    "camera won't zoom"},
171         {"-image",              "xpm / xbm image file to use for texture"},
172         {"-duration",   "length of time texture will be used"},
173 };
174
175 ENTRYPOINT ModeSpecOpt gleidescope_opts = {
176         sizeof opts / sizeof opts[0], opts,
177         sizeof vars / sizeof vars[0], vars,
178         desc
179 };
180
181 #ifdef USE_MODULES
182 ModStruct   gleidescope_description = { 
183      "gleidescope", "init_gleidescope", "draw_gleidescope", "release_gleidescope",
184      "draw_gleidescope", "init_gleidescope", NULL, &gleidescope_opts,
185      1000, 1, 2, 1, 4, 1.0, "",
186      "GL Kaleidescope", 0, NULL};
187 #endif
188
189 /*
190 **-----------------------------------------------------------------------------
191 **      Typedefs
192 **-----------------------------------------------------------------------------
193 */
194
195 typedef struct hex_s {
196         GLfloat x, y, z;                /* position */
197 } hex_t;
198
199 typedef struct {
200         GLfloat x;
201         GLfloat y;
202         GLfloat z;
203 } vectorf;
204
205 typedef struct {
206         GLfloat x;
207         GLfloat y;
208 } vector2f;
209
210 typedef struct {
211         GLuint                  id;                             /* opengl texture id */
212         GLfloat                 width, height;  /* texture width and height */
213         GLfloat                 min_tx, min_ty; /* minimum texture sizes */
214         GLfloat                 max_tx, max_ty; /* maximum texture sizes */
215         time_t                  start_time;
216         Bool                    button_down_p;
217     Bool                        mipmap_p;
218     Bool                        waiting_for_image_p;
219         /* r_phase is for triangle rotation speed */
220         GLfloat                 x_period, y_period, r_period;
221         GLfloat                 x_phase, y_phase, r_phase;
222 } texture;
223
224 #define MAX_FADE        500     /* number of fade cycles */
225
226 typedef struct {
227         float                   cam_x_speed, cam_z_speed, cam_y_speed;
228         int                             cam_x_phase, cam_z_phase, cam_y_phase;
229         float                   tic;
230         GLXContext              *glx_context;
231         Window                  window;
232         texture                 textures[2];    /* texture handles */
233         GLuint                  visible;                /* index for current texture */
234         GLint                   fade;
235         time_t                  start_time;
236         Bool                    button_down_p;
237
238     int         size;
239         int             list;
240
241     float       tangle;         /* texture angle (degrees) */
242     float       tangle_vel;     /* texture velocity */
243     float       tangle_acc;     /* texture acceleration */
244
245     float       rangle;         /* rotate angle */
246     float       rangle_vel;     /* rotate velocity */
247     float       rangle_acc;     /* rotate acceleration */
248
249     /* mouse */
250     int xstart;
251     int ystart;
252     double xmouse;
253     double ymouse;
254
255     Bool mipmap_p;
256     Bool waiting_for_image_p;
257
258 } gleidestruct;
259
260 #define frandrange(x, y)        (x + frand(y - x))
261
262 #define XOFFSET (0.8660254f)    /* sin 60' */
263 #define YOFFSET (1.5000000f)    /* cos 60' + 1 */
264
265 #if 0
266
267 #define SIZE    3
268
269 /* generates a grid with edges of given size */
270 /* acd TODO - replace hex[] with this and allow size and distance as parameters */
271
272 int
273 generate_grid(int size)
274
275         int     i, x, y;
276
277         gp->size--;
278
279         i = gp->size;
280         for (y = -size ; y <= size ; y++) {
281                 for (x = -i ; x <= i ; x += 2) {
282                         printf("{XOFFSET * %d, YOFFSET * %d, 0},\n", x, y);
283                 }
284                 printf("\n");
285                 if (y < 0) {
286                         i++;
287                 } else {
288                         i--;
289                 }
290         }
291         return 0;
292 }
293 #endif
294
295 /* acd - this is terrible - 120+ hexes */
296 static const hex_t hex[] = {
297         /* edges of size 7 */
298         /* number of hexagons required to cover screen depends on camera distance */
299         /* at a distance of 10 this is just about enough. */
300         {XOFFSET * -6, YOFFSET * -6, 0},
301         {XOFFSET * -4, YOFFSET * -6, 0},
302         {XOFFSET * -2, YOFFSET * -6, 0},
303         {XOFFSET * 0, YOFFSET * -6, 0},
304         {XOFFSET * 2, YOFFSET * -6, 0},
305         {XOFFSET * 4, YOFFSET * -6, 0},
306         {XOFFSET * 6, YOFFSET * -6, 0},
307
308         {XOFFSET * -7, YOFFSET * -5, 0},
309         {XOFFSET * -5, YOFFSET * -5, 0},
310         {XOFFSET * -3, YOFFSET * -5, 0},
311         {XOFFSET * -1, YOFFSET * -5, 0},
312         {XOFFSET * 1, YOFFSET * -5, 0},
313         {XOFFSET * 3, YOFFSET * -5, 0},
314         {XOFFSET * 5, YOFFSET * -5, 0},
315         {XOFFSET * 7, YOFFSET * -5, 0},
316
317         {XOFFSET * -8, YOFFSET * -4, 0},
318         {XOFFSET * -6, YOFFSET * -4, 0},
319         {XOFFSET * -4, YOFFSET * -4, 0},
320         {XOFFSET * -2, YOFFSET * -4, 0},
321         {XOFFSET * 0, YOFFSET * -4, 0},
322         {XOFFSET * 2, YOFFSET * -4, 0},
323         {XOFFSET * 4, YOFFSET * -4, 0},
324         {XOFFSET * 6, YOFFSET * -4, 0},
325         {XOFFSET * 8, YOFFSET * -4, 0},
326
327         {XOFFSET * -9, YOFFSET * -3, 0},
328         {XOFFSET * -7, YOFFSET * -3, 0},
329         {XOFFSET * -5, YOFFSET * -3, 0},
330         {XOFFSET * -3, YOFFSET * -3, 0},
331         {XOFFSET * -1, YOFFSET * -3, 0},
332         {XOFFSET * 1, YOFFSET * -3, 0},
333         {XOFFSET * 3, YOFFSET * -3, 0},
334         {XOFFSET * 5, YOFFSET * -3, 0},
335         {XOFFSET * 7, YOFFSET * -3, 0},
336         {XOFFSET * 9, YOFFSET * -3, 0},
337
338         {XOFFSET * -10, YOFFSET * -2, 0},
339         {XOFFSET * -8, YOFFSET * -2, 0},
340         {XOFFSET * -6, YOFFSET * -2, 0},
341         {XOFFSET * -4, YOFFSET * -2, 0},
342         {XOFFSET * -2, YOFFSET * -2, 0},
343         {XOFFSET * 0, YOFFSET * -2, 0},
344         {XOFFSET * 2, YOFFSET * -2, 0},
345         {XOFFSET * 4, YOFFSET * -2, 0},
346         {XOFFSET * 6, YOFFSET * -2, 0},
347         {XOFFSET * 8, YOFFSET * -2, 0},
348         {XOFFSET * 10, YOFFSET * -2, 0},
349
350         {XOFFSET * -11, YOFFSET * -1, 0},
351         {XOFFSET * -9, YOFFSET * -1, 0},
352         {XOFFSET * -7, YOFFSET * -1, 0},
353         {XOFFSET * -5, YOFFSET * -1, 0},
354         {XOFFSET * -3, YOFFSET * -1, 0},
355         {XOFFSET * -1, YOFFSET * -1, 0},
356         {XOFFSET * 1, YOFFSET * -1, 0},
357         {XOFFSET * 3, YOFFSET * -1, 0},
358         {XOFFSET * 5, YOFFSET * -1, 0},
359         {XOFFSET * 7, YOFFSET * -1, 0},
360         {XOFFSET * 9, YOFFSET * -1, 0},
361         {XOFFSET * 11, YOFFSET * -1, 0},
362
363         {XOFFSET * -12, YOFFSET * 0, 0},
364         {XOFFSET * -10, YOFFSET * 0, 0},
365         {XOFFSET * -8, YOFFSET * 0, 0},
366         {XOFFSET * -6, YOFFSET * 0, 0},
367         {XOFFSET * -4, YOFFSET * 0, 0},
368         {XOFFSET * -2, YOFFSET * 0, 0},
369         {XOFFSET * 0, YOFFSET * 0, 0},
370         {XOFFSET * 2, YOFFSET * 0, 0},
371         {XOFFSET * 4, YOFFSET * 0, 0},
372         {XOFFSET * 6, YOFFSET * 0, 0},
373         {XOFFSET * 8, YOFFSET * 0, 0},
374         {XOFFSET * 10, YOFFSET * 0, 0},
375         {XOFFSET * 12, YOFFSET * 0, 0},
376
377         {XOFFSET * -11, YOFFSET * 1, 0},
378         {XOFFSET * -9, YOFFSET * 1, 0},
379         {XOFFSET * -7, YOFFSET * 1, 0},
380         {XOFFSET * -5, YOFFSET * 1, 0},
381         {XOFFSET * -3, YOFFSET * 1, 0},
382         {XOFFSET * -1, YOFFSET * 1, 0},
383         {XOFFSET * 1, YOFFSET * 1, 0},
384         {XOFFSET * 3, YOFFSET * 1, 0},
385         {XOFFSET * 5, YOFFSET * 1, 0},
386         {XOFFSET * 7, YOFFSET * 1, 0},
387         {XOFFSET * 9, YOFFSET * 1, 0},
388         {XOFFSET * 11, YOFFSET * 1, 0},
389
390         {XOFFSET * -10, YOFFSET * 2, 0},
391         {XOFFSET * -8, YOFFSET * 2, 0},
392         {XOFFSET * -6, YOFFSET * 2, 0},
393         {XOFFSET * -4, YOFFSET * 2, 0},
394         {XOFFSET * -2, YOFFSET * 2, 0},
395         {XOFFSET * 0, YOFFSET * 2, 0},
396         {XOFFSET * 2, YOFFSET * 2, 0},
397         {XOFFSET * 4, YOFFSET * 2, 0},
398         {XOFFSET * 6, YOFFSET * 2, 0},
399         {XOFFSET * 8, YOFFSET * 2, 0},
400         {XOFFSET * 10, YOFFSET * 2, 0},
401
402         {XOFFSET * -9, YOFFSET * 3, 0},
403         {XOFFSET * -7, YOFFSET * 3, 0},
404         {XOFFSET * -5, YOFFSET * 3, 0},
405         {XOFFSET * -3, YOFFSET * 3, 0},
406         {XOFFSET * -1, YOFFSET * 3, 0},
407         {XOFFSET * 1, YOFFSET * 3, 0},
408         {XOFFSET * 3, YOFFSET * 3, 0},
409         {XOFFSET * 5, YOFFSET * 3, 0},
410         {XOFFSET * 7, YOFFSET * 3, 0},
411         {XOFFSET * 9, YOFFSET * 3, 0},
412
413         {XOFFSET * -8, YOFFSET * 4, 0},
414         {XOFFSET * -6, YOFFSET * 4, 0},
415         {XOFFSET * -4, YOFFSET * 4, 0},
416         {XOFFSET * -2, YOFFSET * 4, 0},
417         {XOFFSET * 0, YOFFSET * 4, 0},
418         {XOFFSET * 2, YOFFSET * 4, 0},
419         {XOFFSET * 4, YOFFSET * 4, 0},
420         {XOFFSET * 6, YOFFSET * 4, 0},
421         {XOFFSET * 8, YOFFSET * 4, 0},
422
423         {XOFFSET * -7, YOFFSET * 5, 0},
424         {XOFFSET * -5, YOFFSET * 5, 0},
425         {XOFFSET * -3, YOFFSET * 5, 0},
426         {XOFFSET * -1, YOFFSET * 5, 0},
427         {XOFFSET * 1, YOFFSET * 5, 0},
428         {XOFFSET * 3, YOFFSET * 5, 0},
429         {XOFFSET * 5, YOFFSET * 5, 0},
430         {XOFFSET * 7, YOFFSET * 5, 0},
431
432         {XOFFSET * -6, YOFFSET * 6, 0},
433         {XOFFSET * -4, YOFFSET * 6, 0},
434         {XOFFSET * -2, YOFFSET * 6, 0},
435         {XOFFSET * 0, YOFFSET * 6, 0},
436         {XOFFSET * 2, YOFFSET * 6, 0},
437         {XOFFSET * 4, YOFFSET * 6, 0},
438         {XOFFSET * 6, YOFFSET * 6, 0},
439 };
440
441 /*
442 **----------------------------------------------------------------------------
443 ** Local Variables
444 **----------------------------------------------------------------------------
445 */
446
447 static  gleidestruct *gleidescope = NULL;
448
449 #if 0
450 /*
451  *load defaults in config structure
452  */
453 static void setdefaultconfig(void)
454 {
455 #ifdef GRAB
456         grab = False;
457 #endif
458         move = False;
459         rotate = False;
460         zoom = False;
461         image = NULL;
462 }
463 #endif
464
465 ENTRYPOINT Bool
466 gleidescope_handle_event(ModeInfo *mi, XEvent *event)
467 {
468         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
469
470         /*
471         printf("event:%d\n", event->xany.type);
472         printf("button:%d\n", event->xbutton.button);
473         */
474         switch(event->xany.type)
475         {
476                 case ButtonPress:
477
478                         if (event->xbutton.button == Button1 ||
479                 event->xbutton.button == Button3)
480                         {
481                                 /* store initial values of mouse */
482                                 gp->xstart = event->xbutton.x;
483                                 gp->ystart = event->xbutton.y;
484
485                                 /* button is down */
486                                 gp->button_down_p = True;
487                                 return True;
488                         }
489 #if 0   /* TODO */
490                         else if (event->xbutton.button == Button4)
491                         {
492                                 /* zoom in */
493                                 return True;
494                         }
495                         else if (event->xbutton.button == Button5)
496                         {
497                                 /* zoom out */
498                                 return True;
499                         }
500 #endif
501                         break;
502
503                 case ButtonRelease:
504
505                         if (event->xbutton.button == Button1 ||
506                 event->xbutton.button == Button3)
507                         {
508                                 /* button is up */
509                                 gp->button_down_p = False;
510                                 return True;
511                         }
512                         break;
513
514                 case MotionNotify:
515
516                         if (gp->button_down_p)
517                         {
518                                 /* update mouse position */
519                                 gp->xmouse += (double)(event->xmotion.x - gp->xstart) / MI_WIDTH(mi);
520                                 gp->ymouse += (double)(event->xmotion.y - gp->ystart) / MI_HEIGHT(mi);
521                                 gp->xstart = event->xmotion.x;
522                                 gp->ystart = event->xmotion.y;
523
524                                 return True;
525                         }
526                         break;
527         }
528
529         return False;
530 }
531
532
533 static void
534 image_loaded_cb (const char *filename, XRectangle *geometry,
535                  int image_width, int image_height, 
536                  int texture_width, int texture_height,
537                  void *closure)
538 {
539         texture *tp = (texture *) closure;
540
541 #if 0
542         gp->max_tx = (GLfloat) image_width  / texture_width;
543         gp->max_ty = (GLfloat) image_height / texture_height;
544 #endif
545
546         /* new - taken from flipscreen */
547         tp->width = texture_width;
548         tp->height = texture_height;
549         tp->min_tx = (GLfloat) geometry->x / tp->width;
550         tp->min_ty = (GLfloat) geometry->y / tp->height;
551         tp->max_tx = (GLfloat) (geometry->x + geometry->width)  / tp->width;
552         tp->max_ty = (GLfloat) (geometry->y + geometry->height) / tp->height;
553
554 #ifdef DEBUG
555         printf("Image w,h: (%d, %d)\n", image_width, image_height);
556         printf("Texture w,h: (%d, %d)\n", texture_width, texture_height);
557         printf("Geom x,y: (%d, %d)\n", geometry->x, geometry->y);
558         printf("Geom w,h: (%d, %d)\n", geometry->width, geometry->height);
559         printf("Max Tx,Ty: (%f, %f)\n", tp->max_tx, tp->max_ty);
560 #endif
561
562         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
563         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
564                         (tp->mipmap_p ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR));
565
566         tp->waiting_for_image_p = False;
567         tp->start_time = time ((time_t *) 0);
568 }
569
570 static void
571 getSnapshot(ModeInfo *mi, texture *texture)
572 {
573         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
574
575 #ifdef DEBUG
576         printf("getSnapshot");
577 #endif
578
579         if (MI_IS_WIREFRAME(mi))
580                 return;
581
582     gp->mipmap_p = True;
583     load_texture_async (mi->xgwa.screen, mi->window,
584                         *gp->glx_context, 0, 0, gp->mipmap_p, 
585                         texture->id, image_loaded_cb, texture);
586         texture->start_time = time((time_t *)0);
587 }
588
589 #define TEXTURE_SIZE    256
590
591 static void
592 plot(unsigned char *buffer, int x, int y, int r, int g, int b, int a) {
593         int c;
594         if (x < 0 || x >= TEXTURE_SIZE || y < 0 || y >= TEXTURE_SIZE) {
595                 return;
596         }
597         c = ((x * TEXTURE_SIZE) + y) * 4;
598         /*printf("(%d,%d)[%d]\n", x, y, c);*/
599         buffer[c + 0] = r;
600         buffer[c + 1] = g;
601         buffer[c + 2] = b;
602         buffer[c + 3] = a;
603 }
604
605 #if 0
606 static void
607 plot2(unsigned char *buffer, int x, int y, int r, int g, int b, int a) {
608         int c;
609         if (x < 0 || x >= TEXTURE_SIZE || y < 0 || y >= TEXTURE_SIZE) {
610                 return;
611         }
612         c = ((x * TEXTURE_SIZE) + y) * 4;
613         /*printf("(%d,%d)[%d]\n", x, y, c);*/
614         buffer[c + 0] = r;
615         buffer[c + 1] = g;
616         buffer[c + 2] = b;
617         buffer[c + 3] = a;
618         
619         if (y + 1 < TEXTURE_SIZE) {
620                 buffer[c + 4] = r;
621                 buffer[c + 5] = g;
622                 buffer[c + 6] = b;
623                 buffer[c + 7] = a;
624         }
625
626         if (x + 1 < TEXTURE_SIZE) {
627                 c += (TEXTURE_SIZE * 4);
628                 buffer[c + 0] = r;
629                 buffer[c + 1] = g;
630                 buffer[c + 2] = b;
631                 buffer[c + 3] = a;
632                 if (y + 1 < TEXTURE_SIZE) {
633                         buffer[c + 4] = r;
634                         buffer[c + 5] = g;
635                         buffer[c + 6] = b;
636                         buffer[c + 7] = a;
637                 }
638         }
639 }
640 #endif
641
642 /* draw geometric shapes to texture */
643 /* modifies passed in buffer */
644 static void
645 draw_shapes (unsigned char *buffer) {
646         int a = 0xff;
647         int x, y, w, h;
648         int i, j;
649         int s;
650         float left, right;
651
652         for (i = 0 ; i < TEXTURE_SIZE * TEXTURE_SIZE * 4 ; i += 4) {
653                 buffer[i + 0] = 0x00;
654                 buffer[i + 1] = 0x00;
655                 buffer[i + 2] = 0x00;
656                 buffer[i + 3] = 0xff;
657         }
658
659         for (s = 0 ; s < 25 ; s++) {
660                 int shape = random() % 3;
661
662                 /* 8 bits */
663                 int r = (random() & 0xff);
664                 int g = (random() & 0xff);
665                 int b = (random() & 0xff);
666
667                 switch (shape) {
668                         case 0:
669                                 /* rectangle */
670                                 x = (random() % TEXTURE_SIZE) - (TEXTURE_SIZE / 4);     /* top left */
671                                 y = (random() % TEXTURE_SIZE) - (TEXTURE_SIZE / 4);
672                                 w = 10 + random() % (TEXTURE_SIZE / 4); /* size */
673                                 h = 10 + random() % (TEXTURE_SIZE / 4);
674 #ifdef DEBUG
675                                 printf("Rectangle: (%d, %d)(%d, %d)\n", x, y, w, h);
676 #endif
677                                 if (x < 0) {
678                                         x = 0;
679                                 }
680                                 if (y < 0) {
681                                         y = 0;
682                                 }
683                                 for (i = x ; i < x + w && i < TEXTURE_SIZE; i++) {
684                                         for (j = y ; j < y + h && j < TEXTURE_SIZE; j++) {
685                                                 plot(buffer, i, j, r, g, b, a);
686                                         }
687                                 }
688                                 break;
689
690                         case 1:
691                                 /* circle */
692                                 x = random() % TEXTURE_SIZE;    /* centre */
693                                 y = random() % TEXTURE_SIZE;
694                                 h = 10 + random() % (TEXTURE_SIZE / 8); /* radius */
695 #ifdef DEBUG
696                                 printf("Circle: %d, %d, %d\n", x, y, h);
697 #endif
698                                 for (i = 0 ; i < h ; i++) {
699                                         int xdist = i * i;
700                                         for (j = 0 ; j < h ; j++) {
701                                                 int ydist = j * j;
702                                                 /*
703                                                 printf("xdist: %d\n", xdist);
704                                                 printf("ydist: %d\n", ydist);
705                                                 printf("radius: %d\n", h * h);
706                                                 */
707                                                 if ((xdist + ydist) < (h * h)) {
708                                                         plot(buffer, x + i, y + j, r, b, g, a);
709                                                         /* check we haven't already done these */
710                                                         if (j != 0) {
711                                                                 plot(buffer, x + i, y - j, r, b, g, a);
712                                                         }
713                                                         if (i != 0) {
714                                                                 plot(buffer, x - i, y + j, r, b, g, a);
715                                                                 if (j != 0) {
716                                                                 plot(buffer, x - i, y - j, r, b, g, a);
717                                                                 }
718                                                         }
719                                                 }
720                                         }
721                                 }
722                                 break;
723
724                         case 2:
725                                 /* triangle */
726                                 x = random() % TEXTURE_SIZE;    /* top */
727                                 y = random() % TEXTURE_SIZE;
728                                 h = 10 + random() % (TEXTURE_SIZE / 4); /* height */
729 #ifdef DEBUG
730                                 printf("Triangle: %d, %d, %d\n", x, y, h);
731 #endif
732                                 left = x;
733                                 right = x;
734                                 for (i = 0 ; i < h ; i++) {
735                                         for (j = left ; j < right ; j++) {
736                                                 plot(buffer, j, y + i, r, g, b, a);
737                                         }
738                                         left -= .5;
739                                         right += .5;
740                                 }
741                                 break;
742                 }
743         }
744 }
745
746 static void
747 setup_random_texture (ModeInfo *mi, texture *texture)
748 {
749         int width = 0, height = 0;
750         char buf[1024];
751         unsigned char *my_data = NULL;
752 #if 0
753         int i, j, c;
754         int style;
755         int r0, g0, b0, a0, r1, g1, b1, a1;
756 #endif
757
758 #ifdef DEBUG
759         printf("RandomTexture\n");
760 #endif
761
762         /* use this texture */
763         glBindTexture(GL_TEXTURE_2D, texture->id);
764
765         clear_gl_error();
766
767         /*
768          * code for various generated patterns - noise, stripes, checks etc.
769          * random geometric shapes looked the best.
770          */
771
772 #if 0
773         style = random() & 0x3;
774         r0 = random() & 0xff; 
775         g0 = random() & 0xff; 
776         b0 = random() & 0xff; 
777         a0 = 0xff;
778         r1 = random() & 0xff; 
779         g1 = random() & 0xff; 
780         b1 = random() & 0xff; 
781         a1 = 0xff;
782
783         switch (style) {
784                 case 0: /* random */
785                         printf("Random0\n");
786                         height = width = TEXTURE_SIZE;
787                         my_data = (void *)malloc(width * height * 4);
788                         for (i = 0 ; i < width ; i += 2) {
789                                 for (j = 0 ; j < height ; j += 2) {
790                                         r0 = random() & 0xff; 
791                                         g0 = random() & 0xff; 
792                                         b0 = random() & 0xff; 
793                                         a0 = 0xff;
794                                         plot2(my_data, i, j, r0, g0, b0, a0);
795                                 }
796                         }
797                         break;
798
799                 case 1: /* shapes */
800 #endif
801 #ifdef DEBUG
802                         printf("Shapes\n");
803 #endif
804                         height = width = TEXTURE_SIZE;
805                         my_data = (void *)malloc(width * height * 4);
806                         draw_shapes(my_data);
807 #if 0
808                         break;
809
810                 case 2: /* check */
811                         printf("Check\n");
812                         height = width = TEXTURE_SIZE;
813                         my_data = (void *)malloc(width * height * 4);
814                         for (i = 0 ; i < height ; i += 2) {
815                                 for (j = 0 ; j < width ; j += 2) {
816                                         if (((i + j) & 0x3) == 0) {
817                                                 plot2(my_data, i, j, r0, g0, b0, a0);
818                                         } else {
819                                                 plot2(my_data, i, j, r1, g1, b1, a1);
820                                         }
821                                 }
822                         }
823                         break;
824
825                 case 3: /* random stripes */
826                         printf("Stripes 2\n");
827                         height = width = TEXTURE_SIZE;
828                         my_data = (void *)malloc(width * height * 4);
829                         for (i = 0 ; i < height ; i += 2) {
830                                 r0 = random() & 0xff; 
831                                 g0 = random() & 0xff; 
832                                 b0 = random() & 0xff; 
833                                 a0 = 0xff;
834                                 for (j = 0 ; j < width ; j += 2) {
835                                         plot2(my_data, i, j, r0, g0, b0, a0);
836                                 }
837                         }
838                         break;
839         }
840 #endif
841
842         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
843                         width, height, 0,
844                         GL_RGBA, GL_UNSIGNED_BYTE, my_data);
845         sprintf (buf, "random texture: (%dx%d)",
846                         width, height);
847         check_gl_error(buf);
848
849         /* setup parameters for texturing */
850         glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
851         glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
852
853         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
854         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
855         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
856         if (random() & 0x1) {
857                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
858                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
859         } else {
860                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
861                 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
862         }
863
864         if (my_data != NULL) {
865                 free(my_data);
866                 my_data = NULL;
867         }
868
869         /* use full texture */
870         /* acd - was 1.0 */
871         texture->min_tx = 0.0;
872         texture->max_tx = 2.0;
873         texture->min_ty = 0.0;
874         texture->max_ty = 2.0;
875         texture->start_time = time((time_t *)0);
876 }
877
878 static void
879 setup_file_texture (ModeInfo *mi, char *filename, texture *texture)
880 {
881         Display *dpy = mi->dpy;
882         Visual *visual = mi->xgwa.visual;
883         char buf[1024];
884
885         Colormap cmap = mi->xgwa.colormap;
886         XImage *image = xpm_file_to_ximage (dpy, visual, cmap, filename);
887
888 #ifdef DEBUG
889         printf("FileTexture\n");
890 #endif
891
892         /* use this texture */
893         glBindTexture(GL_TEXTURE_2D, texture->id);
894
895         clear_gl_error();
896         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
897                         image->width, image->height, 0,
898                         GL_RGBA, GL_UNSIGNED_BYTE, image->data);
899         sprintf (buf, "texture: %.100s (%dx%d)",
900                         filename, image->width, image->height);
901         check_gl_error(buf);
902
903         /* setup parameters for texturing */
904         glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
905         glPixelStorei(GL_UNPACK_ROW_LENGTH, image->width);
906
907         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
908         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
909         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
910         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
911         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
912
913         /* use full texture */
914         texture->min_tx = 0.0;
915         texture->max_tx = 1.0;
916         texture->min_ty = 0.0;
917         texture->max_ty = 1.0;
918         texture->start_time = time((time_t *)0);
919 }
920
921 static void
922 setup_texture(ModeInfo * mi, texture *texture)
923 {
924         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
925
926         if (!image || !*image || !strcmp(image, "DEFAULT")) {
927                 /* no image specified - use system settings */
928 #ifdef DEBUG
929                 printf("SetupTexture: get_snapshot\n");
930 #endif
931                 getSnapshot(mi, texture);
932         } else {
933                 if (strcmp(image, "GENERATE") == 0) {
934 #ifdef DEBUG
935                         printf("SetupTexture: random_texture\n");
936 #endif
937                         setup_random_texture(mi, texture);
938                 } else {
939                         /* use supplied image file */
940 #ifdef DEBUG
941                         printf("SetupTexture: file_texture\n");
942 #endif
943                         setup_file_texture(mi, image, texture);
944                 }
945         }
946         /* copy start time from texture */
947         gp->start_time = texture->start_time;
948
949         check_gl_error("texture initialization");
950
951         /* acd 
952          * resultant loaded image is upside down BUT
953          * it's a kaledescope and half of the hexagon is backwards anyway...
954          */
955
956         /* TODO: values for lissajous movement */
957         texture->x_period = frandrange(-2.0, 2.0);
958         texture->y_period = frandrange(-2.0, 2.0);
959         texture->r_period = frandrange(-2.0, 2.0);
960         texture->x_phase = frand(M_PI * 2);
961         texture->y_phase = frand(M_PI * 2);
962         texture->r_phase = frand(M_PI * 2);
963 #ifdef DEBUG
964         printf("XPeriod %f XPhase %f\n", texture->x_period, texture->x_phase);
965         printf("YPeriod %f YPhase %f\n", texture->y_period, texture->y_phase);
966         printf("RPeriod %f RPhase %f\n", texture->r_period, texture->r_phase);
967 #endif
968 }
969
970 #define VERTEX0 glVertex3f( 0.0000f,  0.000f, 0.0f);
971 #define VERTEX1 glVertex3f( 0.0000f,  1.000f, 0.0f);
972 #define VERTEX2 glVertex3f( XOFFSET,  0.500f, 0.0f);
973 #define VERTEX3 glVertex3f( XOFFSET, -0.500f, 0.0f);
974 #define VERTEX4 glVertex3f( 0.0000f, -1.000f, 0.0f);
975 #define VERTEX5 glVertex3f(-XOFFSET, -0.500f, 0.0f);
976 #define VERTEX6 glVertex3f(-XOFFSET,  0.500f, 0.0f);
977
978 /*
979 ** Three different functions for calculating texture coordinates
980 ** which modify how the texture triangle moves over the source image.
981 ** Choose one.
982 */
983
984 #if 0
985 /* the classic equilateral triangle rotating around centre */
986 static void
987 calculate_texture_coords(ModeInfo *mi, texture *texture, vector2f t[3]) {
988
989         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
990         GLfloat centre_x = 0.5;
991         GLfloat centre_y = 0.5;
992         GLfloat radius_x = (texture->max_tx - texture->min_tx) / 2;
993         GLfloat radius_y = (texture->max_ty - texture->min_ty) / 2;
994         GLfloat tangle2;
995         t[0].x = centre_x;
996         t[0].y = centre_y;
997
998         /* t[1] */
999         t[1].x = centre_x + .95 * radius_x * cos((gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS));
1000         t[1].y = centre_y + .95 * radius_y * sin((gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS));
1001
1002         /* t[2] is always 60' further around than t2 */
1003         tangle2 = (gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS) + (M_PI * 2 / 6);
1004         t[2].x = centre_x + .95 * radius_x * cos(tangle2);
1005         t[2].y = centre_y + .95 * radius_y * sin(tangle2);
1006 #if 0
1007         printf("texcoords:[%f,%f]->[%f,%f](%f,%f)\n", t[0].x, t[0].y, t[1].x, t[1].y, texture->max_tx, texture->max_ty);
1008 #endif
1009 }
1010 #endif
1011
1012 #if 1
1013 /* new lissajous movement pattern */
1014 static void
1015 calculate_texture_coords(ModeInfo *mi, texture *texture, vector2f t[3]) {
1016
1017         /* equilateral triangle rotating around centre */
1018         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
1019         GLfloat width = texture->max_tx - texture->min_tx;
1020         GLfloat height = texture->max_ty - texture->min_ty;
1021         /* centre */
1022         GLfloat centre_x = texture->min_tx + (width * .5);
1023         GLfloat centre_y = texture->min_ty + (height * .5);
1024         /* m radius and t radius should be = .5 */
1025         /* triangle radius is 30% available space */
1026         GLfloat t_radius_x = width * .3;
1027         GLfloat t_radius_y = height * .3;
1028         /* movement radius is 30% available space */
1029         GLfloat m_radius_x = width * .2;
1030         GLfloat m_radius_y = height * .2;
1031         GLfloat angle2;
1032
1033         /* centre of triangle */
1034         GLfloat angle = (gp->ymouse * 2 * M_PI) + (gp->tangle * RADIANS);       /* to radians */
1035         GLfloat t_centre_x = centre_x + m_radius_x * cos(texture->x_period * angle + texture->x_phase);
1036         GLfloat t_centre_y = centre_y + m_radius_y * sin(texture->y_period * angle + texture->y_phase);
1037
1038 #if 0
1039         printf("WH: %f, %f - tWH: %f, %f\n", width, height, texture->width, texture->height);
1040         printf("size: (%f, %f)\n", width, height);
1041         printf("centre: (%f, %f)\n", centre_x, centre_y);
1042 #endif
1043
1044         angle2 = texture->r_period * angle + texture->r_phase;
1045         t[0].x = t_centre_x + t_radius_x * cos(angle2);
1046         t[0].y = t_centre_y + t_radius_y * sin(angle2);
1047         t[1].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_120);
1048         t[1].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_120);
1049         t[2].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_240);
1050         t[2].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_240);
1051
1052 #if 0
1053         printf("texcoords:[%f,%f]->[%f,%f](%f,%f)\n", t[0].x, t[0].y, t[1].x, t[1].y, texture->max_tx, texture->max_ty);
1054 #endif
1055 }
1056 #endif
1057  
1058 #if 0
1059 /* corners into corners - meant to maximise coverage */
1060 static void
1061 calculate_texture_coords(ModeInfo *mi, texture *texture, vector2f t[3]) {
1062
1063         /* equilateral triangle rotating around centre */
1064         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
1065         GLfloat width = texture->max_tx - texture->min_tx;
1066         GLfloat height = texture->max_ty - texture->min_ty;
1067         /* centre */
1068         GLfloat centre_x = texture->min_tx + (width * .5);
1069         GLfloat centre_y = texture->min_ty + (height * .5);
1070         /* m radius and t radius should be = .5 */
1071         /* triangle radius calculated using maths 8) */
1072 #define TRADIUS (M_SQRT2 - 1.0)
1073 #define MRADIUS (1.0 - (M_SQRT2 / 2.0))
1074         GLfloat t_radius_x = width * TRADIUS * .95;
1075         GLfloat t_radius_y = height * TRADIUS * .95;
1076         /* movement radius also calculated using maths */
1077         GLfloat m_radius_x = width * MRADIUS * .95;
1078         GLfloat m_radius_y = height * MRADIUS * .95;
1079         GLfloat angle, angle2;
1080         GLfloat t_centre_x, t_centre_y;
1081
1082         /* centre of triangle */
1083         angle = gp->tangle * RADIANS;   /* to radians */
1084         t_centre_x = centre_x + m_radius_x * cos(angle);
1085         t_centre_y = centre_y + m_radius_y * sin(angle);
1086 #if 0
1087         printf("angle: %f, %f\n", angle, gp->tangle);
1088         printf("tcentre: %f,%f\n", t_centre_x, t_centre_y);
1089         printf("tradius: %f,%f\n", t_radius_x, t_radius_y);
1090
1091         printf("size: (%f, %f)\n", width, height);
1092         printf("centre: (%f, %f)\n", centre_x, centre_y);
1093         printf("centre: (%f, %f)\n", centre_x, centre_y);
1094         printf("TRADIUS: %f\n", TRADIUS);
1095         printf("MRADIUS: %f\n", MRADIUS);
1096 #endif
1097
1098         /* angle2 is tied to tangle */
1099         angle2 = (180.0 - ((30.0 / 90.0) * gp->tangle)) * RADIANS; 
1100 #if 0
1101         printf("Angle1: %f\tAngle2: %f\n", angle / RADIANS, angle2 / RADIANS);
1102 #endif
1103         t[0].x = t_centre_x + t_radius_x * cos(angle2);
1104         t[0].y = t_centre_y + t_radius_y * sin(angle2);
1105         t[1].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_120);
1106         t[1].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_120);
1107         t[2].x = t_centre_x + t_radius_x * cos(angle2 + ANGLE_240);
1108         t[2].y = t_centre_y + t_radius_y * sin(angle2 + ANGLE_240);
1109
1110 #if 0
1111         printf("texcoords:[%f,%f][%f,%f][%f,%f]\n", t[0].x, t[0].y, t[1].x, t[1].y, t[2].x, t[2].y);
1112 #endif
1113 }
1114 #endif
1115
1116 static int
1117 draw_hexagons(ModeInfo *mi, int translucency, texture *texture)
1118 {
1119     int polys = 0;
1120         int             i;
1121         GLfloat col[4];
1122         vector2f t[3];
1123         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
1124
1125         col[0] = 1.0;
1126         col[1] = 1.0;
1127         col[2] = 1.0;
1128         col[3] = (float)translucency / MAX_FADE;
1129
1130         calculate_texture_coords(mi, texture, t);
1131
1132         glColor4f(1.0, 1.0, 1.0, (float)translucency / MAX_FADE);
1133         glEnable(GL_TEXTURE_2D);
1134         glEnable(GL_BLEND);
1135         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1136         glDepthMask(GL_FALSE);
1137         glBindTexture(GL_TEXTURE_2D, texture->id);
1138
1139         if (gp->list == -1) {
1140                 gp->list = glGenLists(1);
1141         }
1142
1143         /* compile new list */
1144         glNewList(gp->list, GL_COMPILE);
1145         glBegin(GL_TRIANGLES);
1146
1147         /*
1148         ** six triangles to each hexagon
1149         */
1150
1151         glTexCoord2f(t[0].x, t[0].y);
1152         VERTEX0;
1153         glTexCoord2f(t[1].x, t[1].y);
1154         VERTEX1;
1155         glTexCoord2f(t[2].x, t[2].y);
1156         VERTEX6;
1157
1158         glTexCoord2f(t[0].x, t[0].y);
1159         VERTEX0;
1160         glTexCoord2f(t[2].x, t[2].y);
1161         VERTEX6;
1162         glTexCoord2f(t[1].x, t[1].y);
1163         VERTEX5;
1164
1165         glTexCoord2f(t[0].x, t[0].y);
1166         VERTEX0;
1167         glTexCoord2f(t[1].x, t[1].y);
1168         VERTEX5;
1169         glTexCoord2f(t[2].x, t[2].y);
1170         VERTEX4;
1171
1172         glTexCoord2f(t[0].x, t[0].y);
1173         VERTEX0;
1174         glTexCoord2f(t[2].x, t[2].y);
1175         VERTEX4;
1176         glTexCoord2f(t[1].x, t[1].y);
1177         VERTEX3;
1178
1179         glTexCoord2f(t[0].x, t[0].y);
1180         VERTEX0;
1181         glTexCoord2f(t[1].x, t[1].y);
1182         VERTEX3;
1183         glTexCoord2f(t[2].x, t[2].y);
1184         VERTEX2;
1185
1186         glTexCoord2f(t[0].x, t[0].y);
1187         VERTEX0;
1188         glTexCoord2f(t[2].x, t[2].y);
1189         VERTEX2;
1190         glTexCoord2f(t[1].x, t[1].y);
1191         VERTEX1;
1192
1193         glEnd();
1194         glEndList();
1195
1196         /* call the list n times */
1197         for (i = 0 ; i < sizeof(hex) / sizeof(hex[0]) ; i++) {
1198
1199                 glPushMatrix();
1200
1201                 glTranslatef(hex[i].x, hex[i].y, 0.0);
1202                 glCallList(gp->list);
1203         polys += 6;
1204
1205                 glPopMatrix();
1206         }
1207         
1208 #ifdef DISPLAY_TEXTURE
1209         glPushMatrix();
1210         /* acd debug - display (bigger, centred) texture */
1211         glScalef(2.0, 2.0, 2.0);
1212         glTranslatef(-0.5, -0.5, 0.0);
1213         glBegin(GL_QUADS);
1214         glTexCoord2f(0.0, 0.0);
1215         glVertex3f(0.0, 0.0, -0.1);
1216         glTexCoord2f(1.0, 0.0);
1217         glVertex3f(1.0, 0.0, -0.1);
1218         glTexCoord2f(1.0, 1.0);
1219         glVertex3f(1.0, 1.0, -0.1);
1220         glTexCoord2f(0.0, 1.0);
1221         glVertex3f(0.0, 1.0, -0.1);
1222     polys++;
1223         glEnd();
1224         /* acd debug - display texture triangle */
1225         glColor4f(1.0, 0.5, 1.0, 1.0);
1226         glBegin(GL_LINE_LOOP);
1227         glVertex3f(t[0].x, t[0].y, -0.11);
1228         glVertex3f(t[1].x, t[1].y, -0.11);
1229         glVertex3f(t[2].x, t[2].y, -0.11);
1230     polys++;
1231         glEnd();
1232         glPopMatrix();
1233 #endif
1234
1235         glDisable(GL_TEXTURE_2D);
1236         glDepthMask(GL_TRUE);
1237         glDisable(GL_BLEND);
1238     return polys;
1239 }
1240
1241 /*
1242  * main rendering loop
1243  */
1244 static void
1245 draw(ModeInfo * mi)
1246 {
1247         GLfloat x_angle, y_angle, z_angle;
1248         gleidestruct *gp = &gleidescope[MI_SCREEN(mi)];
1249         vectorf v1;
1250         GLfloat pos[4];
1251
1252     mi->polygon_count = 0;
1253
1254         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1255         glLoadIdentity();
1256
1257         gp->tic += 0.005f;
1258
1259         x_angle = gp->cam_x_phase + gp->tic * gp->cam_x_speed;
1260         y_angle = gp->cam_y_phase + gp->tic * gp->cam_y_speed;
1261         z_angle = gp->cam_z_phase + gp->tic * gp->cam_z_speed;
1262
1263         if (move) {
1264                 v1.x = 1 * sin(x_angle);
1265                 v1.y = 1 * sin(y_angle);
1266         } else {
1267                 v1.x = 0;
1268                 v1.y = 0;
1269         }
1270
1271         /* size is changed in pinit() to be distance from plane */
1272         gp->size = MI_SIZE(mi);
1273         if (gp->size > 10) {
1274                 gp->size = 10;
1275         }
1276         if (gp->size <= 0) {
1277                 gp->size = 0;
1278         }
1279         if (gp->size > 0) {
1280                 /* user defined size */
1281                 v1.z = gp->size;
1282         } else if (zoom) {
1283                 /* max distance given by adding the constant and the multiplier */
1284                 v1.z = 5.0 + 3.0 * sin(z_angle);
1285         } else {
1286                 /* default */
1287                 v1.z = 7.0;
1288         }
1289
1290         /* update rotation angle (but not if mouse button down) */
1291         if (rotate && !gp->button_down_p)
1292         {
1293                 float   new_rangle_vel = 0.0;
1294
1295                 /* update camera rotation angle and velocity */
1296                 gp->rangle += gp->rangle_vel;
1297                 new_rangle_vel = gp->rangle_vel + gp->rangle_acc;
1298                 if (new_rangle_vel > -MAX_ANGLE_VEL && new_rangle_vel < MAX_ANGLE_VEL)
1299                 {
1300                         /* new velocity is within limits */
1301                         gp->rangle_vel = new_rangle_vel;
1302                 }
1303
1304                 /* randomly change twisting speed - 3ff = 1024 */
1305                 if ((random() % TWISTING_PROBABILITY) < 1.0) {
1306                         gp->rangle_acc = INITIAL_ANGLE_ACC * frand(1.0);
1307                         if (gp->rangle_vel > 0.0) {
1308                                 gp->rangle_acc = -gp->rangle_acc;
1309                         }
1310                 }
1311         }
1312 #if 0
1313         printf("Rangle: %f : %f : %f\n", gp->rangle, gp->rangle_vel, gp->rangle_acc);
1314         printf("Tangle: %f : %f : %f\n", gp->tangle, gp->tangle_vel, gp->tangle_acc);
1315 #endif
1316
1317 #ifdef WOBBLE
1318         /* this makes the image wobble - requires -move and a larger grid */
1319         gluLookAt(0, 0, v1.z, v1.x, v1.y, 0.0, 0.0, 1.0, 0.0);
1320 #else
1321         /* no wobble - camera always perpendicular to grid */
1322
1323         /* rotating camera rather than entire space - smoother */
1324         gluLookAt(
1325                         v1.x, v1.y, v1.z,
1326                         v1.x, v1.y, 0.0,
1327                         sin((gp->xmouse * M_PI * 2) + gp->rangle * RADIANS),
1328                         cos((gp->xmouse * M_PI * 2) + gp->rangle * RADIANS),
1329                         0.0);
1330 #endif
1331
1332         /* light position same as camera */
1333         pos[0] = v1.x;
1334         pos[1] = v1.y;
1335         pos[2] = v1.z;
1336         pos[3] = 0;
1337
1338         if (gp->fade == 0)
1339         {
1340                 /* not fading */
1341       mi->polygon_count += 
1342         draw_hexagons(mi, MAX_FADE, &gp->textures[gp->visible]);
1343         }
1344         else
1345         {
1346                 /* fading - show both textures with alpha
1347                 NB first is always max alpha */
1348         mi->polygon_count += 
1349           draw_hexagons(mi, MAX_FADE, &gp->textures[1 - gp->visible]);
1350         mi->polygon_count += 
1351                   draw_hexagons(mi, MAX_FADE - gp->fade, &gp->textures[gp->visible]);
1352
1353                 /* fade some more */
1354                 gp->fade++;
1355
1356                 /* have we faded enough? */
1357                 if (gp->fade > MAX_FADE)
1358                 {
1359                         /* stop fading */
1360                         gp->fade = 0;
1361                         gp->visible = 1 - gp->visible;
1362                 }
1363         }
1364
1365         /* increment texture angle based on time, velocity etc */
1366         /* but only if button is not down */
1367         if (!gp->button_down_p)
1368         {
1369                 float           new_tangle_vel = 0.0;
1370
1371                 gp->tangle += gp->tangle_vel;
1372
1373                 /* work out new texture angle velocity */
1374                 new_tangle_vel = gp->tangle_vel + gp->tangle_acc;
1375                 if (new_tangle_vel > -MAX_ANGLE_VEL && new_tangle_vel < MAX_ANGLE_VEL)
1376                 {
1377                         /* new velocity is inside limits */
1378                         gp->tangle_vel = new_tangle_vel;
1379                 }
1380
1381                 /* randomly change twisting speed - 3ff = 1024 */
1382                 if ((random() % TWISTING_PROBABILITY) < 1.0) {
1383                         gp->tangle_acc = INITIAL_ANGLE_ACC * frand(1.0);
1384                         if (gp->tangle_vel > 0.0) {
1385                                 gp->tangle_acc = -gp->tangle_acc;
1386                         }
1387                 }
1388         }
1389
1390         glFlush();
1391 }
1392
1393 /* 
1394  * new window size or exposure 
1395  */
1396 ENTRYPOINT void reshape_gleidescope(ModeInfo *mi, int width, int height)
1397 {
1398         GLfloat         h = (GLfloat) height / (GLfloat) width;
1399
1400         glViewport(0, 0, (GLint) width, (GLint) height);
1401         glMatrixMode(GL_PROJECTION);
1402         glLoadIdentity();
1403         gluPerspective(50.0, 1/h, 0.1, 2000.0);
1404         glMatrixMode (GL_MODELVIEW);
1405
1406         glLineWidth(1);
1407         glPointSize(1);   
1408 }
1409
1410 static void
1411 pinit(ModeInfo * mi)
1412 {
1413         gleidestruct    *gp = &gleidescope[MI_SCREEN(mi)];
1414
1415         /* set start time - star_time = 0 implies non-dynamic texture */
1416         gp->start_time = (time_t)0;
1417
1418         /* set the texture size to default */
1419         /*
1420         gp->max_tx = 1.0;
1421         gp->max_ty = 1.0;
1422         */
1423
1424         /* no fading */
1425         gp->fade = 0;
1426
1427         glShadeModel(GL_SMOOTH);
1428         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1429         glEnable(GL_DEPTH_TEST);
1430         glEnable(GL_CULL_FACE);
1431         glDisable(GL_LIGHTING);
1432
1433         /* space for textures */
1434         glGenTextures(1, &gp->textures[0].id);
1435         glGenTextures(1, &gp->textures[1].id);
1436         gp->visible = 0;
1437
1438         setup_texture(mi, &gp->textures[gp->visible]);
1439
1440         /*
1441         **      want to choose a value for arg randomly if neither -arg nor -no-arg
1442         **      is specified. xscreensaver libraries don't seem to let you do this -
1443         **      if something isn't true then it is false (pesky two-state boolean values).
1444         **      so, i've defined both -arg and -no-arg to arguments and added the 
1445         **      following logic.
1446         **      (btw if both -arg and -no-arg are defined then arg is set to False)
1447         */
1448         if (zoom == False && nozoom == False)
1449         {
1450                 /* no zoom preference - randomise */
1451                 zoom = (((random() & 0x1) == 0x1) ? True : False);
1452         }
1453         else if (nozoom == True)
1454         {
1455                 /* definately no zoom */
1456                 zoom = False;
1457         }
1458
1459         if (move == False && nomove == False)
1460         {
1461                 /* no move preference - randomise */
1462                 move = (((random() & 0x1) == 0x1) ? True : False);
1463         }
1464         else if (nomove == True)
1465         {
1466                 /* definately no move */
1467                 move = False;
1468         }
1469
1470         if (rotate == False && norotate == False)
1471         {
1472                 /* no rotate preference - randomise */
1473                 rotate = (((random() & 0x1) == 0x1) ? True : False);
1474         }
1475         else if (norotate == True)
1476         {
1477                 /* definately no rotate */
1478                 rotate = False;
1479         }
1480
1481         /* define cam variables */
1482         gp->cam_x_speed = MAX_CAM_SPEED * frandrange(-.5, 0.5);
1483         gp->cam_x_phase = random() % 360;
1484         gp->cam_y_speed = MAX_CAM_SPEED * frandrange(-.5, 0.5);
1485         gp->cam_y_phase = random() % 360;
1486         gp->cam_z_speed = MAX_CAM_SPEED * frandrange(-.5, 0.5);
1487         gp->cam_z_phase = random() % 360;
1488
1489         /* initial angular speeds */
1490         gp->rangle_vel = INITIAL_ANGLE_VEL * frandrange(-.5, 0.5);
1491         gp->tangle_vel = INITIAL_ANGLE_VEL * frandrange(-.5, 0.5);
1492         gp->rangle_acc = INITIAL_ANGLE_ACC * frandrange(-.5, 0.5);
1493         gp->tangle_acc = INITIAL_ANGLE_ACC * frandrange(-.5, 0.5);
1494
1495     /* jwz */
1496 #if 0
1497     {
1498       GLfloat speed = 15;
1499       gp->rangle_vel *= speed;
1500       gp->tangle_vel *= speed;
1501       gp->rangle_acc *= speed;
1502       gp->tangle_acc *= speed;
1503     }
1504 #endif
1505
1506         /* distance is 11 - size */
1507         if (gp->size != -1) {
1508                 if (zoom) {
1509                         fprintf(stderr, "-size given. ignoring -zoom.\n");
1510                         zoom = False;
1511                 }
1512                 if (gp->size < 1) {
1513                         gp->size = 1;
1514                 } else if (gp->size >= 10) {
1515                         gp->size = 10;
1516                 }
1517                 gp->size = 11 - gp->size;
1518         }
1519
1520 #ifdef DEBUG
1521 printf("phases [%d, %d, %d]\n", gp->cam_x_phase, gp->cam_y_phase, gp->cam_z_phase);
1522 #endif
1523 }
1524
1525 ENTRYPOINT void
1526 init_gleidescope(ModeInfo * mi)
1527 {
1528         gleidestruct *gp;
1529         int screen = MI_SCREEN(mi);
1530
1531         if (gleidescope == NULL) {
1532                 gleidescope = (gleidestruct *) calloc(MI_NUM_SCREENS(mi), sizeof (gleidestruct));
1533                 if (gleidescope == NULL) {
1534                         return;
1535                 }
1536         }
1537         gp = &gleidescope[screen];
1538         gp->window = MI_WINDOW(mi);
1539     gp->size = -1;
1540     gp->list = -1;
1541
1542         if ((gp->glx_context = init_GL(mi)) != NULL) {
1543
1544                 reshape_gleidescope(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
1545         clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */
1546
1547                 glDrawBuffer(GL_BACK);
1548
1549                 /* do initialisation */
1550                 pinit(mi);
1551
1552         } else {
1553                 MI_CLEARWINDOW(mi);
1554         }
1555 }
1556
1557 ENTRYPOINT void
1558 draw_gleidescope(ModeInfo * mi)
1559 {
1560         gleidestruct    *gp = &gleidescope[MI_SCREEN(mi)];
1561         Display         *display = MI_DISPLAY(mi);
1562         Window          window = MI_WINDOW(mi);
1563
1564
1565         if (!gp->glx_context)
1566                 return;
1567
1568     /* Just keep running before the texture has come in. */
1569     /* if (gp->waiting_for_image_p) return; */
1570
1571         glDrawBuffer(GL_BACK);
1572
1573         glXMakeCurrent(display, window, *(gp->glx_context));
1574         draw(mi);
1575
1576         if (mi->fps_p) {
1577                 do_fps (mi);
1578         }
1579
1580         glFinish();
1581         glXSwapBuffers(display, window);
1582
1583 #ifdef GRAB
1584         if (grab) {
1585                 grab_frame(display, window);
1586         }
1587 #endif
1588
1589         /* need to change texture? */
1590         if ((gp->start_time != 0) && (duration != -1) && gp->fade == 0) {
1591                 if (gp->start_time + duration <= time((time_t *)0)) {
1592 #ifdef DEBUG
1593                         printf("Start Time: %lu - Current Time: %lu\n", (unsigned long)gp->start_time, (unsigned long)time((time_t *)0));
1594                         printf("Changing Texture\n");
1595 #endif
1596                         /* get new snapshot (into back buffer) and start fade count */
1597                         setup_texture(mi, &gp->textures[1 - gp->visible]);
1598                         /* restart fading */
1599                         gp->fade = 1;
1600                 }
1601         }
1602 }
1603
1604 ENTRYPOINT void
1605 release_gleidescope(ModeInfo * mi)
1606 {
1607         if (gleidescope != NULL) {
1608                 int screen;
1609
1610                 for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
1611                         gleidestruct *gp = &gleidescope[screen];
1612
1613                         /* acd -  is this needed? */
1614                         if (gp->glx_context) {
1615                                 /* Display lists MUST be freed while their glXContext is current. */
1616                                 glXMakeCurrent(MI_DISPLAY(mi), gp->window, *(gp->glx_context));
1617
1618                                 /* acd - was code here for freeing things that are no longer in struct */
1619                         }
1620                 }
1621                 (void) free((void *) gleidescope);
1622                 gleidescope = NULL;
1623         }
1624         
1625         FreeAllGL(mi);
1626 }
1627
1628 XSCREENSAVER_MODULE ("Gleidescope", gleidescope)
1629
1630 #endif