deb6774c497e4962b40730644793fbc7c7e51863
[xscreensaver] / hacks / glx / cubicgrid.c
1 /*-
2  * Permission to use, copy, modify, and distribute this software and its
3  * documentation for any purpose and without fee is hereby granted,
4  * provided that the above copyright notice appear in all copies and that
5  * both that copyright notice and this permission notice appear in
6  * supporting documentation.
7  *
8  * This file is provided AS IS with no warranties of any kind.  The author
9  * shall have no liability with respect to the infringement of copyrights,
10  * trade secrets or any patents by this file or any part thereof.  In no
11  * event will the author be liable for any lost revenue or profits or
12  * other special, indirect and consequential damages.
13  *
14  * Cubic Grid - a 3D lattice. The observer is located in the centre of 
15  * a spinning finite lattice. As it rotates, various view-throughs appear and 
16  * evolve. A simple idea with interesting results.
17  * 
18  * Vasek Potocek (Dec-28-2007)
19  * vasek.potocek@post.cz
20  */
21
22 #define DEFAULTS   "*delay:         20000         \n" \
23                    "*showFPS:       False         \n" \
24                    "*wireframe:     False         \n"
25
26 # define refresh_cubicgrid 0
27 #include "xlockmore.h"
28
29 #ifdef USE_GL
30
31 #define DEF_SPEED   "1.0"
32 #define DEF_DIV     "30"
33 #define DEF_ZOOM    "20"
34 #define DEF_BIGDOTS "True"
35
36 #undef countof
37 #define countof(x) (sizeof((x))/sizeof((*x)))
38
39 #include "rotator.h"
40 #include "gltrackball.h"
41
42 /*************************************************************************/
43
44 static int ticks;
45 static float size;
46 static float speed;
47 static Bool bigdots;
48
49 static argtype vars[] = {
50   { &speed,   "speed",   "Speed",   DEF_SPEED,   t_Float },
51   { &size,    "zoom",    "Zoom",    DEF_ZOOM,    t_Float },
52   { &ticks,   "ticks",   "Ticks",   DEF_DIV,     t_Int },
53   { &bigdots, "bigdots", "BigDots", DEF_BIGDOTS, t_Bool },
54 };
55
56 static XrmOptionDescRec opts[] = {
57   { "-speed",   ".speed",   XrmoptionSepArg, 0 },
58   { "-zoom",    ".zoom",    XrmoptionSepArg, 0 },
59   { "-ticks",   ".ticks",   XrmoptionSepArg, 0 },
60   { "-bigdots", ".bigdots", XrmoptionNoArg,  "True" },
61   { "+bigdots", ".bigdots", XrmoptionNoArg,  "False" },
62 };
63
64 ENTRYPOINT ModeSpecOpt cubicgrid_opts = {countof(opts), opts, countof(vars), vars, NULL};
65
66 #ifdef USE_MODULES
67 ModStruct   cubicgrid_description =
68 { "cubicgrid", "init_cubicgrid", "draw_cubicgrid", "release_cubicgrid",
69   "draw_cubicgrid", "change_cubicgrid", NULL, &cubicgrid_opts,
70   25000, 1, 1, 1, 1.0, 4, "",
71   "Shows a rotating 3D lattice from inside", 0, NULL
72 };
73 #endif
74
75 typedef struct {
76   GLXContext    *glx_context;
77   GLfloat       ratio;
78   GLint         list;
79
80   rotator *rot;
81   trackball_state *trackball;
82   Bool button_down_p;
83   int npoints;
84 } cubicgrid_conf;
85
86 static cubicgrid_conf *cubicgrid = NULL;
87
88 static const GLfloat zpos = -18.0;
89
90 /*************************************************************************/
91
92 ENTRYPOINT Bool
93 cubicgrid_handle_event (ModeInfo *mi, XEvent *event)
94 {
95   cubicgrid_conf *cp = &cubicgrid[MI_SCREEN(mi)];
96
97   if (event->xany.type == ButtonPress &&
98       event->xbutton.button == Button1)
99     {
100       cp->button_down_p = True;
101       gltrackball_start (cp->trackball,
102                          event->xbutton.x, event->xbutton.y,
103                          MI_WIDTH (mi), MI_HEIGHT (mi));
104       return True;
105     }
106   else if (event->xany.type == ButtonRelease &&
107            event->xbutton.button == Button1)
108     {
109       cp->button_down_p = False;
110       return True;
111     }
112   else if (event->xany.type == ButtonPress &&
113            (event->xbutton.button == Button4 ||
114             event->xbutton.button == Button5 ||
115             event->xbutton.button == Button6 ||
116             event->xbutton.button == Button7))
117     {
118       gltrackball_mousewheel (cp->trackball, event->xbutton.button, 2,
119                               !!event->xbutton.state);
120       return True;
121     }
122   else if (event->xany.type == MotionNotify &&
123            cp->button_down_p)
124     {
125       gltrackball_track (cp->trackball,
126                          event->xmotion.x, event->xmotion.y,
127                          MI_WIDTH (mi), MI_HEIGHT (mi));
128       return True;
129     }
130
131   return False;
132 }
133
134
135 static Bool draw_main(cubicgrid_conf *cp) 
136 {
137   double x, y, z;
138
139   glClear(GL_COLOR_BUFFER_BIT);
140   glLoadIdentity();
141   glTranslatef(0, 0, zpos);
142
143   glScalef(size/ticks, size/ticks, size/ticks);
144   gltrackball_rotate (cp->trackball);
145   get_rotation (cp->rot, &x, &y, &z, !cp->button_down_p);
146   glRotatef (x * 360, 1.0, 0.0, 0.0);
147   glRotatef (y * 360, 0.0, 1.0, 0.0);
148   glRotatef (z * 360, 0.0, 0.0, 1.0);
149
150   glTranslatef(-ticks/2.0, -ticks/2.0, -ticks/2.0);
151   glCallList(cp->list);
152   return True;
153 }
154
155 static void init_gl(ModeInfo *mi) 
156 {
157   cubicgrid_conf *cp = &cubicgrid[MI_SCREEN(mi)];
158   int x, y, z;
159   float tf = ticks;
160
161   glDrawBuffer(GL_BACK);
162   if(bigdots) {
163     glPointSize(2.0);
164   }
165   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
166   glShadeModel(GL_FLAT);
167
168   cp->list = glGenLists(1);
169   glNewList(cp->list, GL_COMPILE);
170   if(MI_IS_MONO(mi)) {
171     glColor3f(1.0, 1.0, 1.0);
172     glBegin(GL_POINTS);
173     for(x = 0; x < ticks; x++) {
174       for(y = 0; y < ticks; y++) {
175         for(z = 0; z < ticks; z++) {
176           glVertex3f(x, y, z);
177           cp->npoints++;
178         }
179       }
180     }
181     glEnd();
182   }
183   else
184   {
185     glBegin(GL_POINTS);
186     for(x = 0; x < ticks; x++) {
187       for(y = 0; y < ticks; y++) {
188         for(z = 0; z < ticks; z++) {
189           glColor3f(x/tf, y/tf, z/tf);
190           glVertex3f(x, y, z);
191           cp->npoints++;
192         }
193       }
194     }
195     glEnd();
196   }
197   glEndList();
198 }
199
200 /*************************************************************************/
201
202 ENTRYPOINT void reshape_cubicgrid(ModeInfo *mi, int width, int height) 
203 {
204   cubicgrid_conf *cp = &cubicgrid[MI_SCREEN(mi)];
205   if(!height) height = 1;
206   cp->ratio = (GLfloat)width/(GLfloat)height;
207   glViewport(0, 0, (GLint) width, (GLint) height);
208   glMatrixMode(GL_PROJECTION);
209   glLoadIdentity();
210   gluPerspective(30.0, cp->ratio, 1.0, 100.0);
211   glMatrixMode(GL_MODELVIEW);
212   glClear(GL_COLOR_BUFFER_BIT);
213 }
214
215 ENTRYPOINT void release_cubicgrid(ModeInfo *mi) 
216 {
217   if (cubicgrid != NULL) {
218     int screen;
219     for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
220       cubicgrid_conf *cp = &cubicgrid[screen];
221       if (cp->glx_context) {
222         cp->glx_context = NULL;
223       }
224     }
225     free((void *)cubicgrid);
226     cubicgrid = NULL;
227   }
228   FreeAllGL(mi);
229 }
230
231 ENTRYPOINT void init_cubicgrid(ModeInfo *mi) 
232 {
233   cubicgrid_conf *cp;
234   if(!cubicgrid) {
235     cubicgrid = (cubicgrid_conf *)calloc(MI_NUM_SCREENS(mi), sizeof(cubicgrid_conf));
236     if(!cubicgrid) return;
237   }
238   cp = &cubicgrid[MI_SCREEN(mi)];
239
240   if ((cp->glx_context = init_GL(mi)) != NULL) {
241     init_gl(mi);
242     reshape_cubicgrid(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
243   } else {
244     MI_CLEARWINDOW(mi);
245   }
246
247   {
248     double spin_speed = 0.045 * speed;
249     double spin_accel = 0.005 * speed;
250
251     cp->rot = make_rotator (spin_speed, spin_speed, spin_speed,
252                             spin_accel, 0, True);
253     cp->trackball = gltrackball_init ();
254   }
255 }
256
257 ENTRYPOINT void draw_cubicgrid(ModeInfo * mi) 
258 {
259   Display *display = MI_DISPLAY(mi);
260   Window window = MI_WINDOW(mi);
261   cubicgrid_conf *cp;
262   if (!cubicgrid) return;
263   cp = &cubicgrid[MI_SCREEN(mi)];
264   MI_IS_DRAWN(mi) = True;
265   if (!cp->glx_context) return;
266   glXMakeCurrent(display, window, *(cp->glx_context));
267   if (!draw_main(cp)) {
268     release_cubicgrid(mi);
269     return;
270   }
271   mi->polygon_count = cp->npoints;
272   if (MI_IS_FPS(mi)) do_fps (mi);
273   glFlush();
274   glXSwapBuffers(display, window);
275 }
276
277 #ifndef STANDALONE
278 ENTRYPOINT void change_cubicgrid(ModeInfo * mi) 
279 {
280   cubicgrid_conf *cp = &cubicgrid[MI_SCREEN(mi)];
281   if (!cp->glx_context) return;
282   glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(cp->glx_context));
283   init_gl(mi);
284 }
285 #endif /* !STANDALONE */
286
287
288 XSCREENSAVER_MODULE ("CubicGrid", cubicgrid)
289
290 #endif