32f8e6946d39e0c43921994986b54108ee7d2f6f
[xscreensaver] / hacks / glx / extrusion.c
1 /* -*- Mode: C; tab-width: 4 -*- */
2 /* extrusion --- extrusion module for xscreensaver */
3 /*-
4  * Permission to use, copy, modify, and distribute this software and its
5  * documentation for any purpose and without fee is hereby granted,
6  * provided that the above copyright notice appear in all copies and that
7  * both that copyright notice and this permission notice appear in
8  * supporting documentation.
9  *
10  * This file is provided AS IS with no warranties of any kind.  The author
11  * shall have no liability with respect to the infringement of copyrights,
12  * trade secrets or any patents by this file or any part thereof.  In no
13  * event will the author be liable for any lost revenue or profits or
14  * other special, indirect and consequential damages.
15
16  * Revision History:
17  * Tue Oct 19 22:24:47 PDT 1999    Initial creation by David Konerding
18  *                                 <dek@cgl.ucsf.edu>
19  *                                                                 
20  * Notes:
21  * This screensaver requires the GLE ("OpenGL Tubing and Extrusion Library")
22  * which can be obtained from http://www.linas.org/gle/index.html
23   */
24
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
28
29 #ifdef STANDALONE
30 # define PROGCLASS                                              "Screensaver"
31 # define HACK_INIT                                              init_screensaver
32 # define HACK_DRAW                                              draw_screensaver
33 # define HACK_RESHAPE                                   reshape_screensaver
34 # define HACK_HANDLE_EVENT                              screensaver_handle_event
35 # define EVENT_MASK                                             PointerMotionMask
36 # define screensaver_opts                               xlockmore_opts
37 #define DEFAULTS                        "*delay:                        10000   \n" \
38                                                                                 "*showFPS:              False   \n" \
39                                                                                 "*light:                        True    \n" \
40                                         "*wire:                         False   \n" \
41                                         "*texture:                      False   \n" \
42                                                                                 "*image:                        BUILTIN \n" \
43                                         "*name:             RANDOM  \n" \
44                                         "*example:          0       \n"
45
46 # include "xlockmore.h"                         /* from the xscreensaver distribution */
47 #else /* !STANDALONE */
48 # include "xlock.h"                                     /* from the xlockmore distribution */
49 #endif /* !STANDALONE */
50
51 #ifdef USE_GL /* whole file */
52
53 #ifdef HAVE_XMU
54 # ifndef VMS
55 #  include <X11/Xmu/Drawing.h>
56 #else  /* VMS */
57 #  include <Xmu/Drawing.h>
58 # endif /* VMS */
59 #endif
60
61 #include <stdlib.h>
62 #include <string.h>
63 #include <stdio.h>
64 #include <stdlib.h>
65 #include <GL/gl.h>
66 #include <GL/glu.h>
67 #ifdef HAVE_GLE3
68 #include <GL/gle.h>
69 #else
70 #include <GL/tube.h>
71 #endif
72
73 #undef countof
74 #define countof(x) (sizeof((x))/sizeof((*x)))
75
76 #include "xpm-ximage.h"
77 #include "rotator.h"
78
79 #define checkImageWidth 64
80 #define checkImageHeight 64
81
82
83 extern void InitStuff_helix2(void);
84 extern void DrawStuff_helix2(void);
85 extern void InitStuff_helix3(void);
86 extern void DrawStuff_helix3(void);
87 extern void InitStuff_helix4(void);
88 extern void DrawStuff_helix4(void);
89 extern void InitStuff_joinoffset(void);
90 extern void DrawStuff_joinoffset(void);
91 extern void InitStuff_screw(void);
92 extern void DrawStuff_screw(void);
93 extern void InitStuff_taper(void);
94 extern void DrawStuff_taper(void);
95 extern void InitStuff_twistoid(void);
96 extern void DrawStuff_twistoid(void);
97
98
99
100 #define WIDTH 640
101 #define HEIGHT 480
102
103 #define DEF_LIGHT               "True"
104 #define DEF_WIRE                "False"
105 #define DEF_TEXTURE             "False"
106 #define DEF_TEXTURE_QUALITY   "False"
107 #define DEF_MIPMAP      "False"
108 #define DEF_NAME        "RANDOM"
109 #define DEF_IMAGE       "BUILTIN"
110
111 static int do_light;
112 static int do_wire;
113 static int do_texture;
114 static int do_texture_quality;
115 static int do_mipmap;
116 static char *which_name;
117 static char *which_image;
118
119 static XrmOptionDescRec opts[] = {
120   {"-light",   ".extrusion.light",     XrmoptionNoArg, "true" },
121   {"+light",   ".extrusion.light",     XrmoptionNoArg, "false" },
122   {"-wire",    ".extrusion.wire",      XrmoptionNoArg, "true" },
123   {"+wire",    ".extrusion.wire",      XrmoptionNoArg, "false" },
124   {"-texture", ".extrusion.texture",   XrmoptionNoArg, "true" },
125   {"+texture", ".extrusion.texture",   XrmoptionNoArg, "false" },
126   {"-texture", ".extrusion.texture",   XrmoptionNoArg, "true" },
127   {"+texture_quality", ".extrusion.texture",   XrmoptionNoArg, "false" },
128   {"-texture_quality", ".extrusion.texture",   XrmoptionNoArg, "true" },
129   {"+mipmap", ".extrusion.mipmap",   XrmoptionNoArg, "false" },
130   {"-mipmap", ".extrusion.mipmap",   XrmoptionNoArg, "true" },
131   {"-name",   ".extrusion.name",  XrmoptionSepArg, 0 },
132   {"-image",   ".extrusion.image",  XrmoptionSepArg, 0 },
133 };
134
135
136 static argtype vars[] = {
137   {&do_light,    "light",   "Light",   DEF_LIGHT,   t_Bool},
138   {&do_wire,    "wire",   "Wire",   DEF_WIRE,   t_Bool},
139   {&do_texture,    "texture",   "Texture",   DEF_TEXTURE,   t_Bool},
140   {&do_texture_quality,    "texture_quality",   "Texture_Quality",   DEF_TEXTURE_QUALITY,   t_Bool},
141   {&do_mipmap,    "mipmap",   "Mipmap",   DEF_MIPMAP,   t_Bool},
142   {&which_name, "name",   "Name",   DEF_NAME,   t_String},
143   {&which_image, "image",   "Image",   DEF_IMAGE,   t_String},
144 };
145
146
147 static OptionStruct desc[] =
148 {
149   {"-name num", "example 'name' to draw (helix2, helix3, helix4, joinoffset, screw, taper, twistoid)"},
150   {"-/+ light", "whether to do enable lighting (slower)"},
151   {"-/+ wire", "whether to do use wireframe instead of filled (faster)"},
152   {"-/+ texture", "whether to apply a texture (slower)"},
153   {"-image <filename>", "texture image to load"},
154   {"-/+ texture_quality", "whether to use texture smoothing (slower)"},
155   {"-/+ mipmap", "whether to use texture mipmap (slower)"},
156 };
157
158 ModeSpecOpt screensaver_opts = {countof(opts), opts, countof(vars), vars, desc};
159
160 #ifdef USE_MODULES
161 ModStruct   screensaver_description =
162 {"screensaver", "init_screensaver", "draw_screensaver", "release_screensaver",
163  "draw_screensaver", "init_screensaver", NULL, &screensaver_opts,
164  1000, 1, 2, 1, 4, 1.0, "",
165  "OpenGL screensaver", 0, NULL};
166 #endif
167
168
169 /* structure for holding the screensaver data */
170 typedef struct {
171   int screen_width, screen_height;
172   GLXContext *glx_context;
173   rotator *rot;
174   Bool button_down_p;
175   int mouse_x, mouse_y;
176   Window window;
177   XColor fg, bg;
178 } screensaverstruct;
179 static screensaverstruct *Screensaver = NULL;
180
181
182
183
184 /* convenient access to the screen width */
185 static int global_width=640, global_height=480;
186
187 /* set up a light */
188 static GLfloat lightOnePosition[] = {40.0, 40, 100.0, 0.0};
189 static GLfloat lightOneColor[] = {0.99, 0.99, 0.99, 1.0}; 
190
191 static GLfloat lightTwoPosition[] = {-40.0, 40, 100.0, 0.0};
192 static GLfloat lightTwoColor[] = {0.99, 0.99, 0.99, 1.0}; 
193
194 float rot_x=0, rot_y=0, rot_z=0;
195 float lastx=0, lasty=0;
196
197 static float max_lastx=300, max_lasty=400;
198 static float min_lastx=-400, min_lasty=-400;
199
200 static int screensaver_number;
201
202 struct functions {
203   void (*InitStuff)(void);
204   void (*DrawStuff)(void);
205   char *name;
206 };
207
208 /* currently joinoffset and twistoid look funny-
209    like we're looking at them from the back or something
210 */
211
212 static struct functions funcs_ptr[] = {
213   {InitStuff_helix2, DrawStuff_helix2, "helix2"},
214   {InitStuff_helix3, DrawStuff_helix3, "helix3"},
215   {InitStuff_helix4, DrawStuff_helix4, "helix4"},
216   {InitStuff_joinoffset, DrawStuff_joinoffset, "joinoffset"},
217   {InitStuff_screw, DrawStuff_screw, "screw"},
218   {InitStuff_taper, DrawStuff_taper, "taper"},
219   {InitStuff_twistoid, DrawStuff_twistoid, "twistoid"},
220 };
221
222 static int num_screensavers = countof(funcs_ptr);
223
224
225 /* BEGINNING OF FUNCTIONS */
226
227
228 GLubyte *
229 Generate_Image(int *width, int *height, int *format)
230 {
231   GLubyte *result;
232   int i, j, c;
233   int counter=0;
234
235   *width = checkImageWidth;
236   *height = checkImageHeight;
237   result = (GLubyte *)malloc(4 * (*width) * (*height));
238
239   counter = 0;
240   for (i = 0; i < checkImageWidth; i++) {
241     for (j = 0; j < checkImageHeight; j++) {
242       c = (((((i&0x8)==0))^(((j&0x8))==0)))*255;
243       result[counter++] = (GLubyte) c;
244       result[counter++] = (GLubyte) c;
245       result[counter++] = (GLubyte) c;
246       result[counter++] = (GLubyte) 255;
247     }
248   }
249
250   *format = GL_RGBA;
251   return result;
252 }
253
254
255 /* Create a texture in OpenGL.  First an image is loaded 
256    and stored in a raster buffer, then it's  */
257 void Create_Texture(ModeInfo *mi, const char *filename)
258 {
259   int height, width;
260   GLubyte *image;
261   int format;
262
263   if ( !strncmp(filename, "BUILTIN", 7))
264     image = Generate_Image(&width, &height, &format);
265   else
266     {
267       XImage *ximage = xpm_file_to_ximage (MI_DISPLAY (mi), MI_VISUAL (mi),
268                                            MI_COLORMAP (mi), filename);
269       image  = (GLubyte *) ximage->data;
270       width  = ximage->width;
271       height = ximage->height;
272       format = GL_RGBA;
273     }
274
275   /* GL_MODULATE or GL_DECAL depending on what you want */
276   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
277   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
278   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
279   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
280   /* perhaps we can edge a bit more speed at the expense of quality */
281   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
282
283   if (do_texture_quality) {
284         /* with texture_quality, the min and mag filters look *much* nice but are *much* slower */
285         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
286         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
287   }
288   else {
289         /* default is to do it quick and dirty */
290         /* if you have mipmaps turned on, but not texture quality, nothing will happen! */
291         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
292         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
293   }
294
295   /* mipmaps make the image look much nicer */
296   if (do_mipmap)
297     {
298       int status;
299       clear_gl_error();
300       status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3, width, height, format,
301                                  GL_UNSIGNED_BYTE, image);
302       if (status)
303         {
304           const char *s = (char *) gluErrorString (status);
305           fprintf (stderr, "%s: error mipmapping %dx%d texture: %s\n",
306                    progname, width, height,
307                    (s ? s : "(unknown)"));
308           exit (1);
309         }
310       check_gl_error("mipmapping");
311     }
312   else
313     {
314       clear_gl_error();
315       glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0,
316                    format, GL_UNSIGNED_BYTE, image);
317       check_gl_error("texture");
318     }
319 }
320
321
322 static void
323 init_rotation (ModeInfo *mi)
324 {
325   screensaverstruct *gp = &Screensaver[MI_SCREEN(mi)];
326   double spin_speed = 1.0;
327   gp->rot = make_rotator (spin_speed, spin_speed, spin_speed, 1.0, 0.0, True);
328
329   lastx = (random() % (int) (max_lastx - min_lastx)) + min_lastx;
330   lasty = (random() % (int) (max_lasty - min_lasty)) + min_lasty;
331 }
332
333
334 /* draw the screensaver once */
335 void draw_screensaver(ModeInfo * mi)
336 {
337   screensaverstruct *gp = &Screensaver[MI_SCREEN(mi)];
338   Display    *display = MI_DISPLAY(mi);
339   Window      window = MI_WINDOW(mi);
340
341   if (!gp->glx_context)
342         return;
343
344   glXMakeCurrent(display, window, *(gp->glx_context));
345
346   funcs_ptr[screensaver_number].DrawStuff();
347           
348   /* track the mouse only if a button is down. */
349   if (gp->button_down_p)
350     {
351       lastx = gp->mouse_x;
352       lasty = gp->mouse_y;
353     }
354   else
355     {
356       float scale = (max_lastx - min_lastx);
357       double x, y, z;
358       get_rotation (gp->rot, &x, &y, &z, True);
359       rot_x = x * 360;
360       rot_y = y * 360;
361       rot_z = z * 360;
362       lastx = x * scale + min_lastx;
363       lasty = y * scale + min_lasty;
364     }
365
366   if (mi->fps_p) do_fps (mi);
367   glXSwapBuffers(display, window);
368 }
369
370
371 /* set up lighting conditions */
372 static void SetupLight(void)
373 {
374   glLightfv (GL_LIGHT0, GL_POSITION, lightOnePosition);
375   glLightfv (GL_LIGHT0, GL_DIFFUSE, lightOneColor);
376   glLightfv (GL_LIGHT1, GL_POSITION, lightTwoPosition);
377   glLightfv (GL_LIGHT1, GL_DIFFUSE, lightTwoColor);
378
379   glEnable (GL_LIGHT0);
380   glEnable (GL_LIGHT1);
381   glEnable (GL_LIGHTING);
382
383   glColorMaterial (GL_FRONT, GL_DIFFUSE);
384   glColorMaterial (GL_BACK, GL_DIFFUSE);
385   glEnable (GL_COLOR_MATERIAL);
386 }
387
388 /* reset the projection matrix */
389 static void resetProjection(void) {
390   glMatrixMode(GL_PROJECTION);
391   glLoadIdentity();
392   glFrustum (-9, 9, -9, 9, 50, 150.0);
393   glMatrixMode(GL_MODELVIEW);
394   glLoadIdentity();
395 }
396
397 /* Standard reshape function */
398 void
399 reshape_screensaver(ModeInfo *mi, int width, int height)
400 {
401   global_width=width;
402   global_height=height;
403   glViewport( 0, 0, global_width, global_height );
404   resetProjection();
405 }
406
407
408 /* decide which screensaver example to run */
409 static void chooseScreensaverExample(ModeInfo *mi)
410 {
411   int i;
412   /* call the extrusion init routine */
413
414   if (!strncmp(which_name, "RANDOM", strlen(which_name))) {
415     screensaver_number = random() % num_screensavers;
416   }
417   else {
418         screensaver_number=-1;
419         for (i=0; i < num_screensavers; i++) {
420           if (!strncmp(which_name, funcs_ptr[i].name, strlen(which_name))) {
421                 screensaver_number = i;
422           }
423         }         
424   }
425         
426   if (screensaver_number < 0 || screensaver_number >= num_screensavers) {
427         fprintf(stderr, "%s: invalid screensaver example number!\n", progname);
428         fprintf(stderr, "%s: known screensavers:\n", progname);
429         for (i=0; i < num_screensavers; i++)
430           fprintf(stderr,"\t%s\n", funcs_ptr[i].name);
431         exit(1);
432   }
433   init_rotation(mi);
434   funcs_ptr[screensaver_number].InitStuff();
435 }
436
437 /* main OpenGL initialization routine */
438 static void
439 initializeGL(ModeInfo *mi, GLsizei width, GLsizei height) 
440 {
441   int style;
442   int mode;
443
444   reshape_screensaver(mi, width, height);
445   glViewport( 0, 0, width, height ); 
446
447   glEnable(GL_DEPTH_TEST);
448   glClearColor(0,0,0,0);
449 /*    glCullFace(GL_BACK); */
450 /*    glEnable(GL_CULL_FACE); */
451   glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, True);
452   glShadeModel(GL_SMOOTH);
453
454   if (do_light)
455         SetupLight();
456   if (do_wire) {
457         glPolygonMode(GL_FRONT,GL_LINE);
458         glPolygonMode(GL_BACK,GL_LINE);
459   }
460   if (do_texture) {
461         Create_Texture(mi, which_image);
462         glEnable(GL_TEXTURE_2D);
463
464         /* configure the pipeline */
465         style = TUBE_JN_CAP;
466         style |= TUBE_CONTOUR_CLOSED;
467         style |= TUBE_NORM_FACET;
468         style |= TUBE_JN_ANGLE;
469         gleSetJoinStyle (style);
470
471         if (do_texture) {
472           mode = GLE_TEXTURE_ENABLE | GLE_TEXTURE_VERTEX_MODEL_FLAT;
473           glMatrixMode (GL_TEXTURE); glLoadIdentity ();
474           glScalef (0.25, 0.1, 1); glMatrixMode (GL_MODELVIEW);
475           gleTextureMode (mode);
476         }
477   }
478
479 }
480
481 Bool
482 screensaver_handle_event (ModeInfo *mi, XEvent *event)
483 {
484   screensaverstruct *gp = &Screensaver[MI_SCREEN(mi)];
485
486   if (event->xany.type == ButtonPress &&
487       event->xbutton.button & Button1)
488     {
489       gp->button_down_p = True;
490       gp->mouse_x = event->xbutton.x;
491       gp->mouse_y = event->xbutton.y;
492       return True;
493     }
494   else if (event->xany.type == ButtonRelease &&
495            event->xbutton.button & Button1)
496     {
497       gp->button_down_p = False;
498       return True;
499     }
500   else if (event->xany.type == MotionNotify)
501     {
502       gp->mouse_x = event->xmotion.x;
503       gp->mouse_y = event->xmotion.y;
504       return True;
505     }
506
507   return False;
508 }
509
510
511
512 /* xscreensaver initialization routine */
513 void init_screensaver(ModeInfo * mi)
514 {
515   int screen = MI_SCREEN(mi);
516   screensaverstruct *gp;
517
518   if (Screensaver == NULL) {
519         if ((Screensaver = (screensaverstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (screensaverstruct))) == NULL)
520           return;
521   }
522   gp = &Screensaver[screen];
523
524   gp->window = MI_WINDOW(mi);
525   if ((gp->glx_context = init_GL(mi)) != NULL) {
526         reshape_screensaver(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
527         initializeGL(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
528         chooseScreensaverExample(mi);
529   } else {
530         MI_CLEARWINDOW(mi);
531   }
532
533 }
534
535 /* all sorts of nice cleanup code should go here! */
536 void release_screensaver(ModeInfo * mi)
537 {
538   int screen;
539   if (Screensaver != NULL) {
540         for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
541           /*      screensaverstruct *gp = &Screensaver[screen];*/
542         }
543         (void) free((void *) Screensaver);
544         Screensaver = NULL;
545   }
546   FreeAllGL(mi);
547 }
548 #endif
549