d37998954977d62cd442aab77f5209bf329ea5c8
[xscreensaver] / hacks / glx / atlantis.c
1 /* atlantis --- Shows moving 3D sea animals */
2
3 #if !defined( lint ) && !defined( SABER )
4 static const char sccsid[] = "@(#)atlantis.c    1.3 98/06/18 xlockmore";
5
6 #endif
7
8 /* Copyright (c) E. Lassauge, 1998. */
9
10 /*
11  * Permission to use, copy, modify, and distribute this software and its
12  * documentation for any purpose and without fee is hereby granted,
13  * provided that the above copyright notice appear in all copies and that
14  * both that copyright notice and this permission notice appear in
15  * supporting documentation.
16  *
17  * This file is provided AS IS with no warranties of any kind.  The author
18  * shall have no liability with respect to the infringement of copyrights,
19  * trade secrets or any patents by this file or any part thereof.  In no
20  * event will the author be liable for any lost revenue or profits or
21  * other special, indirect and consequential damages.
22  *
23  * The original code for this mode was written by Mark J. Kilgard
24  * as a demo for openGL programming.
25  * 
26  * Porting it to xlock  was possible by comparing the original Mesa's morph3d 
27  * demo with it's ported version to xlock, so thanks for Marcelo F. Vianna 
28  * (look at morph3d.c) for his indirect help.
29  *
30  * Thanks goes also to Brian Paul for making it possible and inexpensive
31  * to use OpenGL at home.
32  *
33  * My e-mail address is lassauge@sagem.fr
34  *
35  * Eric Lassauge  (May-13-1998)
36  *
37  * REVISION HISTORY:
38  * 
39  * Jamie Zawinski, 2-Apr-01:  - The fishies were inside out!  The back faces
40  *                              were being drawn, not the front faces.
41  *                            - Added a texture to simulate light from the
42  *                              surface, like in the SGI version.
43  *
44  * David A. Bagley - 98/06/17 : Add whalespeed option. Global options to
45  *                              initialize local variables are now:
46  *                              XLock.atlantis.cycles: 100      ! SharkSpeed
47  *                              XLock.atlantis.batchcount: 4    ! SharkNum
48  *                              XLock.atlantis.whalespeed: 250  ! WhaleSpeed
49  *                              XLock.atlantis.size: 6000       ! SharkSize
50  *                              Add random direction for whales/dolphins
51  * 
52  * E.Lassauge - 98/06/16: Use the following global options to initialize
53  *                        local variables :
54  *                              XLock.atlantis.delay: 100       ! SharkSpeed
55  *                              XLock.atlantis.batchcount: 4    ! SharkNum
56  *                              XLock.atlantis.cycles: 250      ! WhaleSpeed
57  *                              XLock.atlantis.size: 6000       ! SharkSize
58  *                        Add support for -/+ wireframe (t'was so easy to do!)
59  *
60  * TODO : 
61  *        - add a sort of background image or random bg color
62  *        - better handling of sizes and speeds
63  *        - test standalone and module modes
64  *        - purify it (!)
65  */
66
67 /* Copyright (c) Mark J. Kilgard, 1994. */
68
69 /**
70  * (c) Copyright 1993, 1994, Silicon Graphics, Inc.
71  * ALL RIGHTS RESERVED
72  * Permission to use, copy, modify, and distribute this software for
73  * any purpose and without fee is hereby granted, provided that the above
74  * copyright notice appear in all copies and that both the copyright notice
75  * and this permission notice appear in supporting documentation, and that
76  * the name of Silicon Graphics, Inc. not be used in advertising
77  * or publicity pertaining to distribution of the software without specific,
78  * written prior permission.
79  *
80  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
81  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
82  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
83  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
84  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
85  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
86  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
87  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
88  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
89  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
90  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
91  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
92  *
93  * US Government Users Restricted Rights
94  * Use, duplication, or disclosure by the Government is subject to
95  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
96  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
97  * clause at DFARS 252.227-7013 and/or in similar or successor
98  * clauses in the FAR or the DOD or NASA FAR Supplement.
99  * Unpublished-- rights reserved under the copyright laws of the
100  * United States.  Contractor/manufacturer is Silicon Graphics,
101  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
102  *
103  * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
104  */
105
106 #define DEF_TEXTURE "True"
107 #define DEF_GRADIENT "False"
108 #define DEF_WHALESPEED  "250"
109
110 #ifdef STANDALONE
111 # define PROGCLASS      "Atlantis"
112 # define HACK_INIT      init_atlantis
113 # define HACK_DRAW      draw_atlantis
114 # define HACK_RESHAPE   reshape_atlantis
115 # define atlantis_opts  xlockmore_opts
116 # define DEFAULTS       "*delay:       25000 \n" \
117                          "*count:          4 \n" \
118                          "*showFPS:    False \n" \
119                          "*cycles:       100 \n" \
120                          "*size:        6000 \n" \
121                          "*wireframe:  False \n" \
122                          "*texture:    " DEF_TEXTURE    " \n" \
123                          "*gradient:   " DEF_GRADIENT   " \n" \
124                          "*whalespeed: " DEF_WHALESPEED " \n"
125 # include "xlockmore.h"         /* from the xscreensaver distribution */
126 #else  /* !STANDALONE */
127 # include "xlock.h"             /* from the xlockmore distribution */
128 #include "vis.h"
129 #endif /* !STANDALONE */
130
131 #ifdef USE_GL
132
133 #include "atlantis.h"
134 #include <GL/glu.h>
135
136
137 static int  whalespeed;
138 static int do_texture;
139 static int do_gradient;
140 static XrmOptionDescRec opts[] =
141 {
142      {"-whalespeed", ".atlantis.whalespeed", XrmoptionSepArg, (caddr_t) NULL},
143      {"-texture",    ".atlantis.texture",    XrmoptionNoArg, (caddr_t)"true"},
144      {"+texture",    ".atlantis.texture",    XrmoptionNoArg, (caddr_t)"false"},
145      {"-gradient",   ".atlantis.gradient",   XrmoptionNoArg, (caddr_t)"true"},
146      {"+gradient",   ".atlantis.gradient",   XrmoptionNoArg, (caddr_t)"false"},
147 };
148
149 static argtype vars[] =
150 {
151  {(caddr_t *) & whalespeed, "whalespeed", "WhaleSpeed", DEF_WHALESPEED, t_Int},
152  {(caddr_t *) &do_texture,  "texture",    "Texture",    DEF_TEXTURE,   t_Bool},
153  {(caddr_t *) &do_gradient, "gradient",   "Gradient",   DEF_GRADIENT,  t_Bool},
154 };
155
156 static OptionStruct desc[] =
157 {
158         {"-whalespeed num", "speed of whales and the dolphin"},
159         {"-texture num",    "whether to introduce water-like distortion"}
160 };
161
162 ModeSpecOpt atlantis_opts =
163 {sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
164
165 #ifdef USE_MODULES
166 ModStruct   atlantis_description =
167 {"atlantis", "init_atlantis", "draw_atlantis", "release_atlantis",
168  "refresh_atlantis", "change_atlantis", NULL, &atlantis_opts,
169  1000, NUM_SHARKS, SHARKSPEED, SHARKSIZE, 64, 1.0, "",
170  "Shows moving sharks/whales/dolphin", 0, NULL};
171
172 #endif
173
174 static atlantisstruct *atlantis = NULL;
175
176 #include "xpm-ximage.h"
177
178 #include "../images/sea-texture.xpm"
179
180
181 static void
182 parse_image_data(ModeInfo *mi)
183 {
184   atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
185   ap->texture = xpm_to_ximage (mi->dpy,
186                                mi->xgwa.visual,
187                                mi->xgwa.colormap,
188                                sea_texture);
189 }
190
191 static void
192 InitFishs(atlantisstruct * ap)
193 {
194         int         i;
195
196         for (i = 0; i < ap->num_sharks; i++) {
197                 ap->sharks[i].x = 70000.0 + NRAND(ap->sharksize);
198                 ap->sharks[i].y = NRAND(ap->sharksize);
199                 ap->sharks[i].z = NRAND(ap->sharksize);
200                 ap->sharks[i].psi = NRAND(360) - 180.0;
201                 ap->sharks[i].v = 1.0;
202         }
203
204         /* Random whae direction */
205         ap->whaledir = LRAND() & 1;
206
207         ap->dolph.x = 30000.0;
208         ap->dolph.y = 0.0;
209         ap->dolph.z = (float) (ap->sharksize);
210         ap->dolph.psi = (ap->whaledir) ? 90.0 : -90.0;
211         ap->dolph.theta = 0.0;
212         ap->dolph.v = 6.0;
213
214         ap->momWhale.x = 70000.0;
215         ap->momWhale.y = 0.0;
216         ap->momWhale.z = 0.0;
217         ap->momWhale.psi = (ap->whaledir) ? 90.0 : -90.0;
218         ap->momWhale.theta = 0.0;
219         ap->momWhale.v = 3.0;
220
221         ap->babyWhale.x = 60000.0;
222         ap->babyWhale.y = -2000.0;
223         ap->babyWhale.z = -2000.0;
224         ap->babyWhale.psi = (ap->whaledir) ? 90.0 : -90.0;
225         ap->babyWhale.theta = 0.0;
226         ap->babyWhale.v = 3.0;
227 }
228
229 static void
230 Init(ModeInfo *mi)
231 {
232         atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
233
234         static float ambient[] =
235         {0.1, 0.1, 0.1, 1.0};
236         static float diffuse[] =
237         {1.0, 1.0, 1.0, 1.0};
238         static float position[] =
239         {0.0, 1.0, 0.0, 0.0};
240         static float mat_shininess[] =
241         {90.0};
242         static float mat_specular[] =
243         {0.8, 0.8, 0.8, 1.0};
244         static float mat_diffuse[] =
245         {0.46, 0.66, 0.795, 1.0};
246         static float mat_ambient[] =
247         {0.0, 0.1, 0.2, 1.0};
248         static float lmodel_ambient[] =
249         {0.4, 0.4, 0.4, 1.0};
250         static float lmodel_localviewer[] =
251         {0.0};
252
253         glFrontFace(GL_CCW);
254
255         if (ap->wire)
256           {
257             glDisable(GL_DEPTH_TEST);
258             glDisable(GL_CULL_FACE);
259             glDisable(GL_LIGHTING);
260             glDisable(GL_NORMALIZE);
261           }
262         else
263           {
264             glDepthFunc(GL_LEQUAL);
265             glEnable(GL_DEPTH_TEST);
266             glEnable(GL_CULL_FACE);
267             glEnable(GL_NORMALIZE);
268             glShadeModel(GL_SMOOTH);
269
270             glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
271             glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
272             glLightfv(GL_LIGHT0, GL_POSITION, position);
273             glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
274             glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_localviewer);
275             glEnable(GL_LIGHTING);
276             glEnable(GL_LIGHT0);
277
278             glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
279             glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
280             glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
281             glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
282           }
283
284         if (ap->wire || !do_texture)
285           {
286             glDisable(GL_TEXTURE_2D);
287           }
288         else
289           {
290             GLfloat s_plane[] = { 1, 0, 0, 0 };
291             GLfloat t_plane[] = { 0, 0, 1, 0 };
292             GLfloat scale = 0.0005;
293
294             if (!ap->texture)
295               parse_image_data (mi);
296
297             clear_gl_error();
298             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
299                          ap->texture->width, ap->texture->height, 0,
300                          GL_RGBA, GL_UNSIGNED_BYTE,
301                          ap->texture->data);
302             check_gl_error("texture");
303
304             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
305             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
306             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
307             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
308
309             glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
310
311             glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
312             glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
313             glTexGenfv(GL_S, GL_EYE_PLANE, s_plane);
314             glTexGenfv(GL_T, GL_EYE_PLANE, t_plane);
315
316             glEnable(GL_TEXTURE_GEN_S);
317             glEnable(GL_TEXTURE_GEN_T);
318             glEnable(GL_TEXTURE_2D);
319
320             glMatrixMode(GL_TEXTURE);
321             glLoadIdentity();
322             glScalef(scale, scale, 1);
323             glMatrixMode(GL_MODELVIEW);
324           }
325
326         InitFishs(ap);
327
328         glClearColor(0.0, 0.39, 0.7, 0.0);
329 }
330
331 void
332 reshape_atlantis(ModeInfo * mi, int width, int height)
333 {
334         atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
335
336         glViewport(0, 0, ap->WinW = (GLint) width, ap->WinH = (GLint) height);
337
338         glMatrixMode(GL_PROJECTION);
339         glLoadIdentity();
340         gluPerspective(400.0, (GLdouble) width / (GLdouble) height, 1.0, 2000000.0);
341         glMatrixMode(GL_MODELVIEW);
342 }
343
344
345 /* jwz -- this doesn't really work very well.
346
347    All I want to do is give the tank a gradient-filled background, instead
348    of just solid blue.  The following was my guess as to how to do this,
349    but it kills my frame rate.  I guess there's a more efficient way to do
350    this, but I don't see it...
351
352    I mean, all I want to do is dump some non-projected bytes into the color
353    buffer, then zero out the depth buffer.  That *can't* be expensive, can
354    it?
355  */
356 static void
357 clear_tank (atlantisstruct * ap)
358 {
359   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
360
361   if (do_gradient && !ap->wire)
362     {
363       static GLint gradient_list = -1;
364       static GLint gradient_tex = -1;
365
366       if (gradient_list == -1)
367         {
368           unsigned char *pixels = 0;
369           int start = 64;
370           int end = start + 128;
371           int size = 4 * (end - start);
372           int i;
373
374           pixels = (unsigned char *) malloc (size);
375           i = 0;
376           while (i < size)
377             {
378               pixels[i] = 0; i++;
379               pixels[i] = (start + (i>>2)) * 0.56; i++;
380               pixels[i] = (start + (i>>2)); i++;
381               pixels[i] = 255; i++;
382             }
383
384           clear_gl_error();
385
386           glGenTextures(1, &gradient_tex);
387           glBindTexture(GL_TEXTURE_1D, gradient_tex);
388
389           glTexImage1D(GL_TEXTURE_1D, 0, 4,
390                        (end - start), 0,
391                        GL_RGBA, GL_UNSIGNED_BYTE, pixels);
392           check_gl_error ("gradient texture");
393           glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
394           glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
395
396
397           gradient_list = glGenLists(1);
398           glNewList(gradient_list, GL_COMPILE);
399
400           glDepthMask (False);
401           glDisable(GL_DEPTH_TEST);
402           glDisable(GL_LIGHTING);
403           glDisable(GL_TEXTURE_2D);
404           glEnable(GL_TEXTURE_1D);
405           glBindTexture(GL_TEXTURE_1D, gradient_tex);
406           glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); 
407           glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP);
408
409           glMatrixMode(GL_PROJECTION);
410           glPushMatrix();
411           glLoadIdentity();
412           glRotatef(90, 0, 0, 1);
413           glTranslatef(-1, -1, 0);
414           glScalef(2, 2, 1);
415
416           glBegin(GL_QUADS);
417           glTexCoord1i(1); glVertex3i(1, 0, 0);
418           glTexCoord1i(0); glVertex3i(0, 0, 0);
419           glTexCoord1i(0); glVertex3i(0, 1, 0);
420           glTexCoord1i(1); glVertex3i(1, 1, 0);
421           glEnd();
422
423           glPopMatrix();
424
425           glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
426           glDisable(GL_TEXTURE_1D);
427
428           glDepthMask (True);
429           glEnable(GL_DEPTH_TEST);
430           glEnable(GL_CULL_FACE);
431           glEnable(GL_LIGHTING);
432           if (do_texture)
433             glEnable(GL_TEXTURE_2D);
434
435           glEndList();
436           check_gl_error ("gradient list");
437         }
438
439       glCallList(gradient_list);
440     }
441 }
442
443
444 static void
445 Animate(atlantisstruct * ap)
446 {
447         int         i;
448
449         for (i = 0; i < ap->num_sharks; i++) {
450                 SharkPilot(&(ap->sharks[i]), ap->sharkspeed);
451                 SharkMiss(ap, i);
452         }
453         WhalePilot(&(ap->dolph), ap->whalespeed, ap->whaledir);
454         ap->dolph.phi++;
455         WhalePilot(&(ap->momWhale), ap->whalespeed, ap->whaledir);
456         ap->momWhale.phi++;
457         WhalePilot(&(ap->babyWhale), ap->whalespeed, ap->whaledir);
458         ap->babyWhale.phi++;
459 }
460
461 static void
462 AllDisplay(atlantisstruct * ap)
463 {
464         int         i;
465
466         clear_tank(ap);
467
468         for (i = 0; i < ap->num_sharks; i++) {
469                 glPushMatrix();
470                 FishTransform(&(ap->sharks[i]));
471                 DrawShark(&(ap->sharks[i]), ap->wire);
472                 glPopMatrix();
473         }
474
475         glPushMatrix();
476         FishTransform(&(ap->dolph));
477         DrawDolphin(&(ap->dolph), ap->wire);
478         glPopMatrix();
479
480         glPushMatrix();
481         FishTransform(&(ap->momWhale));
482         DrawWhale(&(ap->momWhale), ap->wire);
483         glPopMatrix();
484
485         glPushMatrix();
486         FishTransform(&(ap->babyWhale));
487         glScalef(0.45, 0.45, 0.3);
488         DrawWhale(&(ap->babyWhale), ap->wire);
489         glPopMatrix();
490 }
491
492 /*
493  *-----------------------------------------------------------------------------
494  *-----------------------------------------------------------------------------
495  *    Xlock hooks.
496  *-----------------------------------------------------------------------------
497  *-----------------------------------------------------------------------------
498  */
499
500 /*
501  *-----------------------------------------------------------------------------
502  *    Initialize atlantis.  Called each time the window changes.
503  *-----------------------------------------------------------------------------
504  */
505
506 void
507 init_atlantis(ModeInfo * mi)
508 {
509         int         screen = MI_SCREEN(mi);
510         atlantisstruct *ap;
511         Display    *display = MI_DISPLAY(mi);
512         Window      window = MI_WINDOW(mi);
513
514         if (atlantis == NULL) {
515                 if ((atlantis = (atlantisstruct *) calloc(MI_NUM_SCREENS(mi),
516                                            sizeof (atlantisstruct))) == NULL)
517                         return;
518         }
519         ap = &atlantis[screen];
520         ap->num_sharks = MI_COUNT(mi);
521         if (ap->sharks == NULL) {
522                 if ((ap->sharks = (fishRec *) calloc(ap->num_sharks,
523                                                 sizeof (fishRec))) == NULL) {
524                         /* free everything up to now */
525                         (void) free((void *) atlantis);
526                         atlantis = NULL;
527                         return;
528                 }
529         }
530         ap->sharkspeed = MI_CYCLES(mi);         /* has influence on the "width"
531                                                    of the movement */
532         ap->sharksize = MI_SIZE(mi);    /* has influence on the "distance"
533                                            of the sharks */
534         ap->whalespeed = whalespeed;
535         ap->wire = MI_IS_WIREFRAME(mi);
536
537         if (MI_IS_DEBUG(mi)) {
538                 (void) fprintf(stderr,
539                                "%s:\n\tnum_sharks=%d\n\tsharkspeed=%.1f\n\tsharksize=%d\n\twhalespeed=%.1f\n\twireframe=%s\n",
540                                MI_NAME(mi),
541                                ap->num_sharks,
542                                ap->sharkspeed,
543                                ap->sharksize,
544                                ap->whalespeed,
545                                ap->wire ? "yes" : "no"
546                         );
547         }
548         if ((ap->glx_context = init_GL(mi)) != NULL) {
549
550                 reshape_atlantis(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
551                 glDrawBuffer(GL_BACK);
552                 Init(mi);
553                 AllDisplay(ap);
554                 glXSwapBuffers(display, window);
555
556         } else {
557                 MI_CLEARWINDOW(mi);
558         }
559 }
560
561 /*
562  *-----------------------------------------------------------------------------
563  *    Called by the mainline code periodically to update the display.
564  *-----------------------------------------------------------------------------
565  */
566 void
567 draw_atlantis(ModeInfo * mi)
568 {
569         atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
570
571         Display    *display = MI_DISPLAY(mi);
572         Window      window = MI_WINDOW(mi);
573
574         MI_IS_DRAWN(mi) = True;
575
576         if (!ap->glx_context)
577                 return;
578
579         glXMakeCurrent(display, window, *(ap->glx_context));
580
581         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
582
583         AllDisplay(ap);
584         Animate(ap);
585
586         if (mi->fps_p) do_fps (mi);
587         glXSwapBuffers(display, window);
588 }
589
590
591 /*
592  *-----------------------------------------------------------------------------
593  *    The display is being taken away from us.  Free up malloc'ed 
594  *      memory and X resources that we've alloc'ed.  Only called
595  *      once, we must zap everything for every screen.
596  *-----------------------------------------------------------------------------
597  */
598
599 void
600 release_atlantis(ModeInfo * mi)
601 {
602         int         screen;
603
604         if (atlantis != NULL) {
605                 for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
606                         atlantisstruct *ap = &atlantis[screen];
607
608                         if (ap->sharks)
609                                 (void) free((void *) ap->sharks);
610                 }
611                 (void) free((void *) atlantis);
612                 atlantis = NULL;
613         }
614         FreeAllGL(mi);
615 }
616
617 void
618 refresh_atlantis(ModeInfo * mi)
619 {
620 }
621
622 void
623 change_atlantis(ModeInfo * mi)
624 {
625         atlantisstruct *ap = &atlantis[MI_SCREEN(mi)];
626
627         if (!ap->glx_context)
628                 return;
629
630         glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(ap->glx_context));
631         Init(mi);
632 }
633
634 #endif /* USE_GL */