e9fd5a8ec1b89f7119beb887e8382c98a1457c6f
[xscreensaver] / hacks / glx / flyingtoasters.c
1 /* flyingtoasters, Copyright (c) 2003, 2004 Jamie Zawinski <jwz@jwz.org>
2  *
3  * Permission to use, copy, modify, distribute, and sell this software and its
4  * documentation for any purpose is hereby granted without fee, provided that
5  * the above copyright notice appear in all copies and that both that
6  * copyright notice and this permission notice appear in supporting
7  * documentation.  No representations are made about the suitability of this
8  * software for any purpose.  It is provided "as is" without express or 
9  * implied warranty.
10  *
11  * Draws 3D flying toasters, and toast.  Inspired by the ancient 
12  * Berkeley Systems / After Dark hack, but now updated to the wide
13  * wonderful workd of OpenGL and 3D!
14  *
15  * Code by jwz; object models by Baconmonkey.
16  *
17  * The original After Dark flying toasters, with the fluffy white wings,
18  * were a trademark of Berkeley Systems.  Berkeley Systems ceased to exist
19  * some time in 1998, having been gobbled up by Sierra Online, who were
20  * subsequently gobbled up by Flipside and/or Vivendi (it's hard to tell
21  * exactly what happened when.)
22  *
23  * I doubt anyone even cares any more, but if they do, hopefully this homage,
24  * with the space-age 3D jet-plane toasters, will be considered different
25  * enough that whoever still owns the trademark to the fluffy-winged 2D
26  * bitmapped toasters won't get all huffy at us.
27  */
28
29 #include <X11/Intrinsic.h>
30
31 extern XtAppContext app;
32
33 #define PROGCLASS       "FlyingToasters"
34 #define HACK_INIT       init_toasters
35 #define HACK_DRAW       draw_toasters
36 #define HACK_RESHAPE    reshape_toasters
37 #define HACK_HANDLE_EVENT toaster_handle_event
38 #define EVENT_MASK      PointerMotionMask
39 #define sws_opts        xlockmore_opts
40
41 #define DEF_SPEED       "1.0"
42 #define DEF_NTOASTERS   "20"
43 #define DEF_NSLICES     "25"
44 #define DEF_TEXTURE     "True"
45
46 #define DEFAULTS        "*delay:        30000       \n" \
47                         "*showFPS:      False       \n" \
48                         "*wireframe:    False       \n" \
49                         "*speed:      " DEF_SPEED " \n" \
50                         "*ntoasters:  " DEF_NTOASTERS "\n" \
51                         "*nslices:    " DEF_NSLICES   "\n" \
52                         "*texture:    " DEF_TEXTURE   "\n" \
53
54 /* #define DEBUG */
55
56 #undef countof
57 #define countof(x) (sizeof((x))/sizeof((*x)))
58
59 #undef BELLRAND
60 #define BELLRAND(n) ((frand((n)) + frand((n)) + frand((n))) / 3)
61
62 #include "xlockmore.h"
63 #include "gltrackball.h"
64 #include "xpm-ximage.h"
65 #include <ctype.h>
66
67 #include "../images/chromesphere.xpm"
68 #include "../images/toast.xpm"
69
70 #ifdef USE_GL /* whole file */
71
72 #include <GL/glu.h>
73
74
75 #include "gllist.h"
76
77 extern struct gllist
78   *toaster, *toaster_base, *toaster_handle, *toaster_handle2, *toaster_jet,
79   *toaster_knob, *toaster_slots, *toaster_wing, *toast, *toast2;
80
81 struct gllist **all_objs[] = {
82   &toaster, &toaster_base, &toaster_handle, &toaster_handle2, &toaster_jet,
83   &toaster_knob, &toaster_slots, &toaster_wing, &toast, &toast2
84 };
85
86 #define BASE_TOASTER    0
87 #define BASE            1
88 #define HANDLE          2
89 #define HANDLE_SLOT     3
90 #define JET             4
91 #define KNOB            5
92 #define SLOTS           6
93 #define JET_WING        7
94 #define TOAST           8
95 #define TOAST_BITTEN    9
96
97 #define GRID_SIZE   60
98 #define GRID_DEPTH 500
99
100
101 static struct { GLfloat x, y; } nice_views[] = {
102   {  0,  120 },
103   {  0, -120 },
104   { 12,   28 },     /* this is a list of viewer rotations that look nice. */
105   { 12,  -28 },     /* every now and then we switch to a new one.         */
106   {-10,  -28 },     /* (but we only use the first two at start-up.)       */
107   { 40,  -60 },
108   {-40,  -60 },
109   { 40,   60 },
110   {-40,   60 },
111   { 30,    0 },
112   {-30,    0 },
113 };
114
115
116 typedef struct {
117   GLfloat x, y, z;
118   GLfloat dx, dy, dz;
119   Bool toaster_p;
120   int toast_type;      /* 0, 1 */
121   GLfloat handle_pos;  /* 0.0 - 1.0 */
122   GLfloat knob_pos;    /* degrees */
123   int loaded;          /* 2 bits */
124 } floater;
125
126 typedef struct {
127   GLXContext *glx_context;
128   trackball_state *user_trackball;
129   Bool button_down_p;
130
131   int last_view, target_view;
132   GLfloat view_x, view_y;
133   int view_steps, view_tick;
134   Bool auto_tracking_p;
135
136   GLuint *dlists;
137   GLuint chrome_texture;
138   GLuint toast_texture;
139
140   int nfloaters;
141   floater *floaters;
142
143 } toaster_configuration;
144
145 static toaster_configuration *bps = NULL;
146
147 static GLfloat speed;
148 static int ntoasters;
149 static int nslices;
150 static int do_texture;
151
152 static XrmOptionDescRec opts[] = {
153   { "-speed",  ".speed",  XrmoptionSepArg, 0 },
154   { "-ntoasters",  ".ntoasters", XrmoptionSepArg, 0 },
155   { "-nslices",    ".nslices",   XrmoptionSepArg, 0 },
156   {"-texture",     ".texture",   XrmoptionNoArg, "True" },
157   {"+texture",     ".texture",   XrmoptionNoArg, "False" },
158 };
159
160 static argtype vars[] = {
161   {&speed,      "speed",      "Speed",   DEF_SPEED,     t_Float},
162   {&ntoasters,  "ntoasters",  "Count",   DEF_NTOASTERS, t_Int},
163   {&nslices,    "nslices",    "Count",   DEF_NSLICES,   t_Int},
164   {&do_texture, "texture",    "Texture", DEF_TEXTURE,   t_Bool},
165 };
166
167 ModeSpecOpt sws_opts = {countof(opts), opts, countof(vars), vars, NULL};
168
169
170 static void
171 reset_floater (ModeInfo *mi, floater *f)
172 {
173 /*  toaster_configuration *bp = &bps[MI_SCREEN(mi)]; */
174
175   GLfloat n = GRID_SIZE/2.0;
176   GLfloat n2 = GRID_DEPTH/2.0;
177   GLfloat delta = GRID_SIZE * speed / 200.0;
178
179   f->dx = 0;
180   f->dy = 0;
181   f->dz = delta;
182
183   f->dz += BELLRAND(delta) - delta/3;
184
185   if (! (random() % 5)) {
186     f->dx += (BELLRAND(delta*2) - delta);
187     f->dy += (BELLRAND(delta*2) - delta);
188   }
189
190   if (! (random() % 40)) f->dz *= 10;    /* occasional speedy one */
191
192   f->x = frand(n) - n/2;
193   f->y = frand(n) - n/2;
194   f->z = -n2 - frand(delta * 4);
195
196   if (f->toaster_p)
197     {
198       f->loaded = 0;
199       f->knob_pos = frand(180) - 90;
200       f->handle_pos = ((random() & 1) ? 0.0 : 1.0);
201
202       if (f->handle_pos > 0.8 && (! (random() % 5)))
203         f->loaded = (random() & 3);  /* let's toast! */
204     }
205   else
206     {
207       if (! (random() % 10))
208         f->toast_type = 1;      /* toast_bitten */
209     }
210 }
211
212
213 static void
214 tick_floater (ModeInfo *mi, floater *f)
215 {
216   toaster_configuration *bp = &bps[MI_SCREEN(mi)];
217
218   GLfloat n1 = GRID_DEPTH/2.0;
219   GLfloat n2 = GRID_SIZE*4;
220
221   if (bp->button_down_p) return;
222
223   f->x += f->dx;
224   f->y += f->dy;
225   f->z += f->dz;
226
227   if (! (random() % 50000))  /* sudden gust of gravity */
228     f->dy -= 2.8;
229
230   if (f->x < -n2 || f->x > n2 ||
231       f->y < -n2 || f->y > n2 ||
232       f->z > n1)
233     reset_floater (mi, f);
234 }
235
236
237 static void
238 auto_track_init (ModeInfo *mi)
239 {
240   toaster_configuration *bp = &bps[MI_SCREEN(mi)];
241   bp->last_view = (random() % 2);
242   bp->target_view = bp->last_view + 2;
243   bp->view_x = nice_views[bp->last_view].x;
244   bp->view_y = nice_views[bp->last_view].y;
245   bp->view_steps = 100;
246   bp->view_tick = 0;
247   bp->auto_tracking_p = True;
248 }
249
250
251 static void
252 auto_track (ModeInfo *mi)
253 {
254   toaster_configuration *bp = &bps[MI_SCREEN(mi)];
255
256   if (bp->button_down_p)
257     return;
258
259   /* if we're not moving, maybe start moving.  Otherwise, do nothing. */
260   if (! bp->auto_tracking_p)
261     {
262       static int tick = 0;
263       if (++tick < 200/speed) return;
264       tick = 0;
265       if (! (random() % 5))
266         bp->auto_tracking_p = True;
267       else
268         return;
269     }
270
271
272   {
273     GLfloat ox = nice_views[bp->last_view].x;
274     GLfloat oy = nice_views[bp->last_view].y;
275     GLfloat tx = nice_views[bp->target_view].x;
276     GLfloat ty = nice_views[bp->target_view].y;
277
278     /* move from A to B with sinusoidal deltas, so that it doesn't jerk
279        to a stop. */
280     GLfloat th = sin ((M_PI / 2) * (double) bp->view_tick / bp->view_steps);
281
282     bp->view_x = (ox + ((tx - ox) * th));
283     bp->view_y = (oy + ((ty - oy) * th));
284     bp->view_tick++;
285
286   if (bp->view_tick >= bp->view_steps)
287     {
288       bp->view_tick = 0;
289       bp->view_steps = (350.0 / speed);
290       bp->last_view = bp->target_view;
291       bp->target_view = (random() % (countof(nice_views) - 2)) + 2;
292       bp->auto_tracking_p = False;
293     }
294   }
295 }
296
297
298 /* Window management, etc
299  */
300 void
301 reshape_toasters (ModeInfo *mi, int width, int height)
302 {
303   GLfloat h = (GLfloat) height / (GLfloat) width;
304
305   glViewport (0, 0, (GLint) width, (GLint) height);
306
307   glMatrixMode(GL_PROJECTION);
308   glLoadIdentity();
309   gluPerspective (40.0, 1/h, 1.0, 250);
310
311   glMatrixMode(GL_MODELVIEW);
312   glLoadIdentity();
313   gluLookAt( 0.0, 2.0, 30.0,
314              0.0, 0.0, 0.0,
315              0.0, 1.0, 0.0);
316
317   glClear(GL_COLOR_BUFFER_BIT);
318 }
319
320
321 Bool
322 toaster_handle_event (ModeInfo *mi, XEvent *event)
323 {
324   toaster_configuration *bp = &bps[MI_SCREEN(mi)];
325
326   if (event->xany.type == ButtonPress &&
327       event->xbutton.button & Button1)
328     {
329       bp->button_down_p = True;
330       gltrackball_start (bp->user_trackball,
331                          event->xbutton.x, event->xbutton.y,
332                          MI_WIDTH (mi), MI_HEIGHT (mi));
333       return True;
334     }
335   else if (event->xany.type == ButtonRelease &&
336            event->xbutton.button & Button1)
337     {
338       bp->button_down_p = False;
339       return True;
340     }
341   else if (event->xany.type == MotionNotify &&
342            bp->button_down_p)
343     {
344       gltrackball_track (bp->user_trackball,
345                          event->xmotion.x, event->xmotion.y,
346                          MI_WIDTH (mi), MI_HEIGHT (mi));
347       return True;
348     }
349
350   return False;
351 }
352
353
354 static void
355 load_textures (ModeInfo *mi)
356 {
357   toaster_configuration *bp = &bps[MI_SCREEN(mi)];
358   XImage *xi;
359
360   xi = xpm_to_ximage (mi->dpy, mi->xgwa.visual, mi->xgwa.colormap,
361                       chromesphere_xpm);
362   clear_gl_error();
363
364   glGenTextures (1, &bp->chrome_texture);
365   glBindTexture (GL_TEXTURE_2D, bp->chrome_texture);
366   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
367   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
368   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
369   glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA,
370                 xi->width, xi->height, 0,
371                 GL_RGBA,
372                 /* GL_UNSIGNED_BYTE, */
373                 GL_UNSIGNED_INT_8_8_8_8_REV,
374                 xi->data);
375   check_gl_error("texture");
376
377   xi = xpm_to_ximage (mi->dpy, mi->xgwa.visual, mi->xgwa.colormap,
378                       toast_xpm);
379
380   glGenTextures (1, &bp->toast_texture);
381   glBindTexture (GL_TEXTURE_2D, bp->toast_texture);
382   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
383   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
384   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
385   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
386   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
387   glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA,
388                 xi->width, xi->height, 0,
389                 GL_RGBA,
390                 /* GL_UNSIGNED_BYTE, */
391                 GL_UNSIGNED_INT_8_8_8_8_REV,
392                 xi->data);
393   check_gl_error("texture");
394
395   glEnable(GL_TEXTURE_GEN_S);
396   glEnable(GL_TEXTURE_GEN_T);
397   glEnable(GL_TEXTURE_2D);
398 }
399
400
401 void 
402 init_toasters (ModeInfo *mi)
403 {
404   toaster_configuration *bp;
405   int wire = MI_IS_WIREFRAME(mi);
406   int i;
407
408   if (!bps) {
409     bps = (toaster_configuration *)
410       calloc (MI_NUM_SCREENS(mi), sizeof (toaster_configuration));
411     if (!bps) {
412       fprintf(stderr, "%s: out of memory\n", progname);
413       exit(1);
414     }
415
416     bp = &bps[MI_SCREEN(mi)];
417   }
418
419   bp = &bps[MI_SCREEN(mi)];
420
421   bp->glx_context = init_GL(mi);
422
423   reshape_toasters (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
424
425   glShadeModel(GL_SMOOTH);
426
427   glEnable(GL_DEPTH_TEST);
428   glEnable(GL_NORMALIZE);
429   glEnable(GL_CULL_FACE);
430
431   if (!wire)
432     {
433       GLfloat pos[4] = {0.4, 0.2, 0.4, 0.0};
434 /*      GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};*/
435       GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0};
436       GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
437       GLfloat spc[4] = {1.0, 1.0, 1.0, 1.0};
438
439       glEnable(GL_LIGHTING);
440       glEnable(GL_LIGHT0);
441       glEnable(GL_DEPTH_TEST);
442       glEnable(GL_CULL_FACE);
443
444       glLightfv(GL_LIGHT0, GL_POSITION, pos);
445       glLightfv(GL_LIGHT0, GL_AMBIENT,  amb);
446       glLightfv(GL_LIGHT0, GL_DIFFUSE,  dif);
447       glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
448     }
449
450   if (!wire && do_texture)
451     load_textures (mi);
452
453   bp->user_trackball = gltrackball_init ();
454   auto_track_init (mi);
455
456   bp->dlists = (GLuint *) calloc (countof(all_objs)+1, sizeof(GLuint));
457   for (i = 0; i < countof(all_objs); i++)
458     bp->dlists[i] = glGenLists (1);
459
460   for (i = 0; i < countof(all_objs); i++)
461     {
462       struct gllist *gll = *all_objs[i];
463       if (wire)
464         gll->primitive = GL_LINE_LOOP;
465
466       glNewList (bp->dlists[i], GL_COMPILE);
467
468       glMatrixMode(GL_MODELVIEW);
469       glPushMatrix();
470       glMatrixMode(GL_TEXTURE);
471       glPushMatrix();
472       glMatrixMode(GL_MODELVIEW);
473
474       glRotatef (-90, 1, 0, 0);
475       glRotatef (180, 0, 0, 1);
476       glScalef (6, 6, 6);
477
478       glBindTexture (GL_TEXTURE_2D, 0);
479
480       if (i == BASE_TOASTER)
481         {
482           GLfloat color[4] = {1.00, 1.00, 1.00, 1.00};
483           GLfloat spec[4]  = {1.00, 1.00, 1.00, 1.0};
484           GLfloat shiny    = 20.0;
485           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
486           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
487           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
488           if (do_texture)
489             glBindTexture (GL_TEXTURE_2D, bp->chrome_texture);
490           glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
491           glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
492         }
493       else if (i == TOAST || i == TOAST_BITTEN)
494         {
495           GLfloat color[4] = {0.80, 0.80, 0.00, 1.0};
496           GLfloat spec[4]  = {0.00, 0.00, 0.00, 1.0};
497           GLfloat shiny    = 0.0;
498           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
499           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
500           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
501           if (do_texture)
502             glBindTexture (GL_TEXTURE_2D, bp->toast_texture);
503           glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
504           glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
505
506           glMatrixMode(GL_TEXTURE);
507           glTranslatef(0.5, 0.5, 0);
508           glMatrixMode(GL_MODELVIEW);
509         }
510       else if (i == SLOTS || i == HANDLE_SLOT)
511         {
512           GLfloat color[4] = {0.30, 0.30, 0.40, 1.0};
513           GLfloat spec[4]  = {0.40, 0.40, 0.70, 1.0};
514           GLfloat shiny    = 128.0;
515           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
516           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
517           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
518         }
519       else if (i == HANDLE)
520         {
521           GLfloat color[4] = {0.80, 0.10, 0.10, 1.0};
522           GLfloat spec[4]  = {1.00, 1.00, 1.00, 1.0};
523           GLfloat shiny    = 20.0;
524           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
525           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
526           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
527         }
528       else if (i == KNOB)
529         {
530           GLfloat color[4] = {0.80, 0.10, 0.10, 1.0};
531           GLfloat spec[4]  = {0.00, 0.00, 0.00, 1.0};
532           GLfloat shiny    = 0.0;
533           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
534           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
535           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
536         }
537       else if (i == JET || i == JET_WING)
538         {
539           GLfloat color[4] = {0.70, 0.70, 0.70, 1.0};
540           GLfloat spec[4]  = {1.00, 1.00, 1.00, 1.0};
541           GLfloat shiny    = 20.0;
542           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
543           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
544           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
545         }
546       else if (i == BASE)
547         {
548           GLfloat color[4] = {0.50, 0.50, 0.50, 1.0};
549           GLfloat spec[4]  = {1.00, 1.00, 1.00, 1.0};
550           GLfloat shiny    = 20.0;
551           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
552           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
553           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
554         }
555       else
556         {
557           GLfloat color[4] = {1.00, 1.00, 1.00, 1.00};
558           GLfloat spec[4]  = {1.00, 1.00, 1.00, 1.0};
559           GLfloat shiny    = 128.0;
560           glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
561           glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR,            spec);
562           glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS,           shiny);
563         }
564
565       renderList (gll);
566
567       glMatrixMode(GL_TEXTURE);
568       glPopMatrix();
569       glMatrixMode(GL_MODELVIEW);
570       glPopMatrix();
571
572       glEndList ();
573     }
574
575   bp->nfloaters = ntoasters + nslices;
576   bp->floaters = (floater *) calloc (bp->nfloaters, sizeof (floater));
577
578   for (i = 0; i < bp->nfloaters; i++)
579     {
580       floater *f = &bp->floaters[i];
581       /* arrange the list so that half the toasters are in front of bread,
582          and half are behind. */
583       f->toaster_p = ((i < ntoasters / 2) ||
584                       (i >= (nslices + (ntoasters / 2))));
585       reset_floater (mi, f);
586
587       /* Position the first generation randomly, but make sure they aren't
588          on screen yet (until we rotate the view into position.)
589        */
590       {
591         GLfloat min = -GRID_DEPTH/2;
592         GLfloat max =  GRID_DEPTH/3.5;
593         f->z = frand (max - min) + min;
594       }
595     }
596 }
597
598
599 static void
600 draw_origin (ModeInfo *mi)
601 {
602 # ifdef DEBUG
603 /*  toaster_configuration *bp = &bps[MI_SCREEN(mi)];*/
604
605   if (!MI_IS_WIREFRAME(mi)) glDisable(GL_LIGHTING);
606   if (!MI_IS_WIREFRAME(mi) && do_texture) glDisable(GL_TEXTURE_2D);
607
608   glPushMatrix();
609   glScalef (5, 5, 5);
610   glBegin(GL_LINES);
611   glVertex3f(-1, 0, 0); glVertex3f(1, 0, 0);
612   glVertex3f(0, -1, 0); glVertex3f(0, 1, 0);
613   glVertex3f(0, 0, -1); glVertex3f(0, 0, 1);
614   glEnd();
615   glPopMatrix();
616
617   if (!MI_IS_WIREFRAME(mi)) glEnable(GL_LIGHTING);
618   if (!MI_IS_WIREFRAME(mi) && do_texture) glEnable(GL_TEXTURE_2D);
619 # endif /* DEBUG */
620 }
621
622
623 static void
624 draw_grid (ModeInfo *mi)
625 {
626 # ifdef DEBUG
627 /*  toaster_configuration *bp = &bps[MI_SCREEN(mi)];*/
628
629   if (!MI_IS_WIREFRAME(mi)) glDisable(GL_LIGHTING);
630   if (!MI_IS_WIREFRAME(mi) && do_texture) glDisable(GL_TEXTURE_2D);
631   glPushMatrix();
632   glBegin(GL_LINE_LOOP);
633   glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2, 0);
634   glVertex3f(-GRID_SIZE/2,  GRID_SIZE/2, 0);
635   glVertex3f( GRID_SIZE/2,  GRID_SIZE/2, 0);
636   glVertex3f( GRID_SIZE/2, -GRID_SIZE/2, 0);
637   glEnd();
638   glBegin(GL_LINE_LOOP);
639   glVertex3f(-GRID_SIZE/2, GRID_SIZE/2, -GRID_DEPTH/2);
640   glVertex3f(-GRID_SIZE/2, GRID_SIZE/2,  GRID_DEPTH/2);
641   glVertex3f( GRID_SIZE/2, GRID_SIZE/2,  GRID_DEPTH/2);
642   glVertex3f( GRID_SIZE/2, GRID_SIZE/2, -GRID_DEPTH/2);
643   glEnd();
644   glBegin(GL_LINE_LOOP);
645   glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
646   glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
647   glVertex3f( GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
648   glVertex3f( GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
649   glEnd();
650   glBegin(GL_LINES);
651   glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
652   glVertex3f(-GRID_SIZE/2,  GRID_SIZE/2, -GRID_DEPTH/2);
653   glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
654   glVertex3f(-GRID_SIZE/2,  GRID_SIZE/2,  GRID_DEPTH/2);
655   glVertex3f( GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
656   glVertex3f( GRID_SIZE/2,  GRID_SIZE/2, -GRID_DEPTH/2);
657   glVertex3f( GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
658   glVertex3f( GRID_SIZE/2,  GRID_SIZE/2,  GRID_DEPTH/2);
659   glEnd();
660   glPopMatrix();
661
662   if (!MI_IS_WIREFRAME(mi)) glEnable(GL_LIGHTING);
663   if (!MI_IS_WIREFRAME(mi) && do_texture) glEnable(GL_TEXTURE_2D);
664 # endif /* DEBUG */
665 }
666
667
668 static void
669 draw_floater (ModeInfo *mi, floater *f)
670 {
671   toaster_configuration *bp = &bps[MI_SCREEN(mi)];
672   GLfloat n;
673
674   glFrontFace(GL_CCW);
675
676   glPushMatrix();
677   glTranslatef (f->x, f->y, f->z);
678   if (f->toaster_p)
679     {
680       glPushMatrix();
681       glRotatef (180, 0, 1, 0);
682       glCallList (bp->dlists[BASE_TOASTER]);
683       mi->polygon_count += (*all_objs[BASE_TOASTER])->points / 3;
684       glPopMatrix();
685
686       glPushMatrix();
687       glTranslatef(0, 1.01, 0);
688       n = 0.91; glScalef(n,n,n);
689       glCallList (bp->dlists[SLOTS]);
690       mi->polygon_count += (*all_objs[SLOTS])->points / 3;
691       glPopMatrix();
692
693       glPushMatrix();
694       glRotatef (180, 0, 1, 0);
695       glTranslatef(0, -0.4, -2.38);
696       n = 0.33; glScalef(n,n,n);
697       glCallList (bp->dlists[HANDLE_SLOT]);
698       mi->polygon_count += (*all_objs[HANDLE_SLOT])->points / 3;
699       glPopMatrix();
700
701       glPushMatrix();
702       glTranslatef(0, -1.1, 3);
703       n = 0.3; glScalef (n,n,n);
704       glTranslatef(0, f->handle_pos * 4.8, 0);
705       glCallList (bp->dlists[HANDLE]);
706       mi->polygon_count += (*all_objs[HANDLE])->points / 3;
707       glPopMatrix();
708
709       glPushMatrix();
710       glRotatef (180, 0, 1, 0);
711       glTranslatef(0, -1.1, -3);     /* where the handle is */
712       glTranslatef (1, -0.4, 0);     /* down and to the left */
713       n = 0.08; glScalef (n,n,n);
714       glRotatef (f->knob_pos, 0, 0, 1);
715       glCallList (bp->dlists[KNOB]);
716       mi->polygon_count += (*all_objs[KNOB])->points / 3;
717       glPopMatrix();
718
719       glPushMatrix();
720       glRotatef (180, 0, 1, 0);
721       glTranslatef (0, -2.3, 0);
722       glCallList (bp->dlists[BASE]);
723       mi->polygon_count += (*all_objs[BASE])->points / 3;
724       glPopMatrix();
725
726       glPushMatrix();
727       glTranslatef(-4.8, 0, 0);
728       glCallList (bp->dlists[JET_WING]);
729       mi->polygon_count += (*all_objs[JET_WING])->points / 3;
730       glScalef (0.5, 0.5, 0.5);
731       glTranslatef (-2, -1, 0);
732       glCallList (bp->dlists[JET]);
733       mi->polygon_count += (*all_objs[JET])->points / 3;
734       glPopMatrix();
735
736       glPushMatrix();
737       glTranslatef(4.8, 0, 0);
738       glScalef(-1, 1, 1);
739       glFrontFace(GL_CW);
740       glCallList (bp->dlists[JET_WING]);
741       mi->polygon_count += (*all_objs[JET_WING])->points / 3;
742       glScalef (0.5, 0.5, 0.5);
743       glTranslatef (-2, -1, 0);
744       glCallList (bp->dlists[JET]);
745       mi->polygon_count += (*all_objs[JET])->points / 3;
746       glFrontFace(GL_CCW);
747       glPopMatrix();
748
749       if (f->loaded)
750         {
751           glPushMatrix();
752           glTranslatef(0, 1.01, 0);
753           n = 0.91; glScalef(n,n,n);
754           glRotatef (90, 0, 0, 1);
755           glRotatef (90, 0, 1, 0);
756           glTranslatef(0, 0, -0.95);
757           glTranslatef(0, 0.72, 0);
758           if (f->loaded & 1)
759             {
760               glCallList (bp->dlists[TOAST]);
761               mi->polygon_count += (*all_objs[TOAST])->points / 3;
762             }
763           glTranslatef(0, -1.46, 0);
764           if (f->loaded & 2)
765             {
766               glCallList (bp->dlists[TOAST]);
767               mi->polygon_count += (*all_objs[TOAST])->points / 3;
768             }
769           glPopMatrix();
770         }
771     }
772   else
773     {
774       glScalef (0.7, 0.7, 0.7);
775       if (f->toast_type == 0)
776         {
777           glCallList (bp->dlists[TOAST]);
778           mi->polygon_count += (*all_objs[TOAST])->points / 3;
779         }
780       else
781         {
782           glCallList (bp->dlists[TOAST_BITTEN]);
783           mi->polygon_count += (*all_objs[TOAST_BITTEN])->points / 3;
784         }
785     }
786
787   glPopMatrix();
788 }
789
790
791
792 void
793 draw_toasters (ModeInfo *mi)
794 {
795   toaster_configuration *bp = &bps[MI_SCREEN(mi)];
796   Display *dpy = MI_DISPLAY(mi);
797   Window window = MI_WINDOW(mi);
798   int i;
799
800   if (!bp->glx_context)
801     return;
802
803   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
804
805   glPushMatrix ();
806   glRotatef(bp->view_x, 1, 0, 0);
807   glRotatef(bp->view_y, 0, 1, 0);
808   gltrackball_rotate (bp->user_trackball);
809
810
811 #if 0
812   {
813     floater F;
814     F.toaster_p = 0;
815     F.toast_type = 1;
816     F.handle_pos = 0;
817     F.knob_pos = -90;
818     F.loaded = 3;
819     F.x = F.y = F.z = 0;
820     F.dx = F.dy = F.dz = 0;
821
822     glScalef(2,2,2);
823     if (!MI_IS_WIREFRAME(mi)) glDisable(GL_LIGHTING);
824     if (!MI_IS_WIREFRAME(mi) && do_texture) glDisable(GL_TEXTURE_2D);
825     glBegin(GL_LINES);
826     glVertex3f(-10, 0, 0); glVertex3f(10, 0, 0);
827     glVertex3f(0, -10, 0); glVertex3f(0, 10, 0);
828     glVertex3f(0, 0, -10); glVertex3f(0, 0, 10);
829     glEnd();
830     if (!MI_IS_WIREFRAME(mi)) glEnable(GL_LIGHTING);
831     if (!MI_IS_WIREFRAME(mi) && do_texture) glEnable(GL_TEXTURE_2D);
832
833     draw_floater (mi, &F);
834     glPopMatrix ();
835     if (mi->fps_p) do_fps (mi);
836     glFinish();
837     glXSwapBuffers(dpy, window);
838     return;
839   }
840 #endif
841
842   glScalef (0.5, 0.5, 0.5);
843   draw_origin (mi);
844   glTranslatef (0, 0, -GRID_DEPTH/2.5);
845   draw_grid (mi);
846
847   mi->polygon_count = 0;
848   for (i = 0; i < bp->nfloaters; i++)
849     {
850       floater *f = &bp->floaters[i];
851       draw_floater (mi, f);
852       tick_floater (mi, f);
853     }
854   auto_track (mi);
855
856   glPopMatrix ();
857
858   if (mi->fps_p) do_fps (mi);
859   glFinish();
860
861   glXSwapBuffers(dpy, window);
862 }
863
864 #endif /* USE_GL */