http://www.jwz.org/xscreensaver/xscreensaver-5.11.tar.gz
[xscreensaver] / hacks / glx / tunnel_draw.c
1 /* -*- Mode: C; tab-width: 4 -*- */
2 /* atunnels --- OpenGL Advanced Tunnel Demo */
3
4 #if 0
5 static const char sccsid[] = "@(#)tunnel_draw.c 5.13 2004/05/25 xlockmore";
6 #endif
7
8 /* Copyright (c) E. Lassauge, 2002-2004. */
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 Roman Podobedov
24  * Email: romka@ut.ee
25  * WEB: http://romka.demonews.com
26  *
27  * Eric Lassauge  (May-25-2004) <lassauge@users.sourceforge.net>
28  *                                  http://lassauge.free.fr/linux.html
29  *
30  * REVISION HISTORY:
31  * E.Lassauge - 25-May-2004:
32  *      - added more texture
33  *      - random texture init
34  *
35  */
36
37 #ifdef HAVE_CONFIG_H
38 #include <config.h>
39 #endif
40
41 #ifdef USE_GL /* whole file */
42
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <math.h>
46
47 #ifdef STANDALONE
48 # ifdef HAVE_COCOA
49 #  include <OpenGL/gl.h>
50 #  include <OpenGL/glu.h>
51 # else
52 #  include <GL/gl.h>
53 #  include <GL/glu.h>
54 # endif
55 #endif
56
57 #include "tunnel_draw.h"
58
59 #ifdef STANDALONE /* For NRAND() */
60 #include "xlockmoreI.h"          /* in xscreensaver distribution */
61 #else /* STANDALONE */
62 #include "xlock.h"              /* in xlockmore distribution */
63 #endif /* STANDALONE */
64
65 typedef struct 
66 {
67   float x, y, z; /* Point coordinates */
68 } cvPoint;
69
70 typedef struct _tnPath
71 {
72         cvPoint p;
73         struct _tnPath *next;
74 } tnPath;
75
76
77 static const cvPoint initpath[]={
78 {0.000000, 0.000000, 0.000000},
79 {2.000000, 1.000000, 0.000000},
80 {4.000000, 0.000000, 0.000000},
81 {6.000000, 1.000000, 0.000000},
82 {8.000000, 0.000000, 1.000000},
83 {10.000000, 1.000000, 1.000000},
84 {12.000000, 1.500000, 0.000000},
85 {14.000000, 0.000000, 0.000000},
86 {16.000000, 1.000000, 0.000000},
87 {18.000000, 0.000000, 0.000000},
88 {20.000000, 0.000000, 1.000000},
89 {22.000000, 1.000000, 0.000000},
90 {24.000000, 0.000000, 1.000000},
91 {26.000000, 0.000000, 1.000000},
92 {28.000000, 1.000000, 0.000000},
93 {30.000000, 0.000000, 2.000000},
94 {32.000000, 1.000000, 0.000000},
95 {34.000000, 0.000000, 2.000000},
96 {-1.000000, -1.000000, -1.000000}
97 };
98
99
100 struct tunnel_state {
101
102   tnPath *path;
103
104   float cam_t;                                  /* Camera variables */
105   tnPath *cam_pos;
106   float alpha;
107
108   int tFlag;                                    /* Tunnel Drawing Variables */
109   cvPoint prev_points[10];
110   int current_texture;
111
112   float ModeX;                                  /* Modes */
113   int ModeXFlag;
114 };
115
116 /*=================== Vector normalization ==================================*/
117 static void normalize(cvPoint *V)
118 {
119   float d;
120
121   /* Vector length */
122   d = (float)sqrt(V->x*V->x + V->y*V->y + V->z*V->z);
123
124   /* Normalization */
125   V->x /= d; 
126   V->y /= d; 
127   V->z /= d; 
128 }
129 /*=================== C = A x B  (Vector multiply) ==========================*/
130 #if 0
131 static void vect_mult(cvPoint *A, cvPoint *B, cvPoint *C)
132 {
133         /* Vector multiply */
134         C->x = A->y*B->z - A->z*B->y;
135         C->y = A->z*B->x - A->x*B->z;
136         C->z = A->x*B->y - A->y*B->x;
137 }
138 #endif
139
140 /* Catmull-Rom Curve calculations */
141 static void cvCatmullRom(cvPoint *p, float t, cvPoint *outp)
142 {
143         float t2, t3, t1;
144
145         t2 = t*t;
146         t3 = t*t*t;
147         t1 = (1-t)*(1-t);
148
149         outp->x = (-t*t1*p[0].x + (2-5*t2+3*t3)*p[1].x + t*(1+4*t-3*t2)*p[2].x - t2*(1-t)*p[3].x)/2;
150         outp->y = (-t*t1*p[0].y + (2-5*t2+3*t3)*p[1].y + t*(1+4*t-3*t2)*p[2].y - t2*(1-t)*p[3].y)/2;
151         outp->z = (-t*t1*p[0].z + (2-5*t2+3*t3)*p[1].z + t*(1+4*t-3*t2)*p[2].z - t2*(1-t)*p[3].z)/2;
152 }
153
154 /*=================== Point Rotating Around Line ===========================
155 // p    - original point
156 // pp   - pivot point
157 // pl   - pivot line (vector)
158 // a    - angle to rotate in radians
159 // outp - output point
160 //==========================================================================
161 */
162 static void RotateAroundLine(cvPoint *p, cvPoint *pp, cvPoint *pl, float a, cvPoint *outp)
163 {
164         cvPoint p1, p2;
165         float l, m, n, ca, sa;
166
167         p1.x = p->x - pp->x;
168         p1.y = p->y - pp->y;
169         p1.z = p->z - pp->z;
170
171         l = pl->x;
172         m = pl->y;
173         n = pl->z;
174
175         ca = cos(a);
176         sa = sin(a);
177
178         p2.x = p1.x*((l*l)+ca*(1-l*l)) + p1.y*(l*(1-ca)*m+n*sa) + p1.z*(l*(1-ca)*n-m*sa);
179         p2.y = p1.x*(l*(1-ca)*m-n*sa) + p1.y*(m*m+ca*(1-m*m)) + p1.z*(m*(1-ca)*n+l*sa);
180         p2.z = p1.x*(l*(1-ca)*n+m*sa) + p1.y*(m*(1-ca)*n-l*sa) + p1.z*(n*n+ca*(1-n*n));
181
182         outp->x = p2.x + pp->x;
183         outp->y = p2.y + pp->y;
184         outp->z = p2.z + pp->z;
185 }
186
187
188 /*=================== Load camera and tunnel path ==========================*/
189 static void LoadPath(struct tunnel_state *st)
190 {
191         float x, y, z;
192         tnPath *path1=NULL, *path2=NULL;
193
194         cvPoint *f = (cvPoint *)initpath;
195         
196         while (f->x != -1.0)
197         {
198                 x = f->x;
199                 y = f->y;
200                 z = f->z;
201                 f++;
202
203                 if (st->path == NULL)
204                 {
205                         st->path = (tnPath *)malloc(sizeof(tnPath));
206                         path1 = st->path;
207                 }
208                 else
209                 {
210                         path2 = (tnPath *)malloc(sizeof(tnPath));
211                         path1->next = path2;
212                         path1 = path2;
213                 }
214                 
215                 path1->next = NULL;
216                 path1->p.x = x;
217                 path1->p.y = y;
218                 path1->p.z = z;
219         }
220
221         st->cam_pos = st->path;
222         st->cam_t = 0;
223 }
224
225 /*=================== Tunnel Initialization ================================*/
226 struct tunnel_state *
227 InitTunnel(void)
228 {
229     struct tunnel_state *st = (struct tunnel_state *) calloc (1, sizeof(*st));
230         LoadPath(st);
231         st->current_texture = NRAND(MAX_TEXTURE);
232     return st;
233 }
234
235 void DrawTunnel(struct tunnel_state *st, 
236                 int do_texture, int do_light, GLuint *textures)
237 {
238         tnPath *p, *p1, *cmpos;
239         cvPoint op, p4[4], T, ppp, ppp1, op1, op2;
240         float t;
241         int i, j, k, flag;
242         cvPoint points[10];
243         GLfloat light_position[4];
244
245
246         /* Select current tunnel texture */
247         if (do_texture)
248                 glBindTexture(GL_TEXTURE_2D, textures[st->current_texture]);
249         
250         cmpos = st->cam_pos;
251         /* Get current curve */
252         if (st->cam_pos->next->next->next)
253         {
254                 p1 = st->cam_pos;
255                 for (i=0; i<4; i++)
256                 {
257                         p4[i].x = p1->p.x;
258                         p4[i].y = p1->p.y;
259                         p4[i].z = p1->p.z;
260                         p1 = p1->next;
261                 }
262         }
263         else 
264         {
265                 /* End of tunnel */
266                 st->ModeX = 1.0;
267                 st->ModeXFlag = 0;
268                 return;
269         };
270                 
271         /* Get current camera position */
272         cvCatmullRom(p4, st->cam_t, &op);
273
274         /* Next camera position */
275         st->cam_t += 0.02f;
276         if (st->cam_t >= 1)
277         {
278                 st->cam_t = st->cam_t - 1;
279                 cmpos = st->cam_pos->next;
280         }
281                 
282         /* Get curve for next camera position */
283         if (cmpos->next->next->next)
284         {
285                 p1 = cmpos;
286                 for (i=0; i<4; i++)
287                 {
288                         p4[i].x = p1->p.x;
289                         p4[i].y = p1->p.y;
290                         p4[i].z = p1->p.z;
291                         p1 = p1->next;
292                 }
293         }
294         else 
295         {       
296                 /*  End of tunnel */
297                 st->ModeX = 1.0;
298                 st->ModeXFlag = 0;
299                 return;
300         }
301         
302         /*  Get next camera position */
303         cvCatmullRom(p4, st->cam_t, &op1);
304         
305         /*  Rotate camera */
306         glRotatef(st->alpha, 0, 0, -1);
307         st->alpha += 1;
308         /*  Set camera position */
309         gluLookAt(op.x, op.y, op.z, op1.x, op1.y, op1.z, 0, 1, 0);
310
311         /*  Set light position */
312         if (do_light)
313         {
314                 light_position[0] = op.x;
315                 light_position[1] = op.y;
316                 light_position[2] = op.z;
317                 light_position[3] = 1;
318                 glLightfv(GL_LIGHT0, GL_POSITION, light_position);
319         }
320         
321         p = st->cam_pos;
322         flag = 0;
323         t = 0;
324         k = 0;
325         /*  Draw tunnel from current curve and next 2 curves */
326         glBegin(GL_QUADS);
327         while (k < 3)
328         {
329                 if (p->next->next->next)
330                 {
331                         p1 = p;
332                         for (i=0; i<4; i++)
333                         {
334                                 p4[i].x = p1->p.x;
335                                 p4[i].y = p1->p.y;
336                                 p4[i].z = p1->p.z;
337                                 p1 = p1->next;
338                         }
339                 }
340                 else
341                 {
342                         /*  End of tunnel */
343                         st->ModeX = 1.0;
344                         st->ModeXFlag = 0;
345                         return;
346                 }
347                 cvCatmullRom(p4, t, &op);
348
349                 ppp.x = op.x;
350                 ppp.y = op.y;
351                 ppp.z = op.z + 0.25;
352
353                 t += 0.1;
354                 if (t >= 1.0)
355                 {
356                         t = t - 1;
357                         k++;
358                         p = p->next;
359                 }
360         
361                 if (p->next->next->next)
362                 {
363                         p1 = p;
364                         for (i=0; i<4; i++)
365                         {
366                                 p4[i].x = p1->p.x;
367                                 p4[i].y = p1->p.y;
368                                 p4[i].z = p1->p.z;
369                                 p1 = p1->next;
370                         }
371                 } 
372                 else
373                 {
374                         /*  End of tunnel */
375                         st->ModeX = 1.0;
376                         st->ModeXFlag = 0;
377                         return;
378                 }
379                         
380                 cvCatmullRom(p4, t, &op1);
381
382                 ppp1.x = op1.x;
383                 ppp1.y = op1.y;
384                 ppp1.z = op1.z + 0.25;
385
386                 T.x = op1.x - op.x;
387                 T.y = op1.y - op.y;
388                 T.z = op1.z - op.z;
389                         
390                 normalize(&T);
391
392                 for (i=0; i<10; i++)
393                 {
394                         RotateAroundLine(&ppp, &op, &T, ((float)i*36.0*M_PI/180.0), &op2);
395                         points[i].x = op2.x;
396                         points[i].y = op2.y;
397                         points[i].z = op2.z;
398                         if (!flag)
399                         {
400                                 st->prev_points[i].x = op2.x;
401                                 st->prev_points[i].y = op2.y;
402                                 st->prev_points[i].z = op2.z;
403                         }
404                 }
405         
406                 if (!flag)
407                 {
408                         flag = 1;
409                         continue;
410                 }
411                 
412                 /*  Draw 10 polygons for current point */
413                 for (i=0; i<10; i++)
414                 {
415                         j = i+1;
416                         if (j > 9) j = 0;
417                         glNormal3f(0, 0, 1); /*  Normal for lighting */
418                         glTexCoord2f(0, 0); glVertex3f(st->prev_points[i].x, st->prev_points[i].y, st->prev_points[i].z);
419                         glNormal3f(0, 0, 1);
420                         glTexCoord2f(1, 0); glVertex3f(points[i].x, points[i].y, points[i].z);
421                         glNormal3f(0, 0, 1);
422                         glTexCoord2f(1, 1); glVertex3f(points[j].x, points[j].y, points[j].z);
423                         glNormal3f(0, 0, 1);
424                         glTexCoord2f(0, 1); glVertex3f(st->prev_points[j].x, st->prev_points[j].y, st->prev_points[j].z);
425                 }
426                 /*  Save current polygon coordinates for next position */
427                 for (i=0; i<10; i++)
428                 {
429                         st->prev_points[i].x = points[i].x;
430                         st->prev_points[i].y = points[i].y;
431                         st->prev_points[i].z = points[i].z;
432                 }
433         }
434         glEnd();
435         st->cam_pos = cmpos;
436 }
437
438 /* =================== Show splash screen =================================== */
439 void SplashScreen(struct tunnel_state *st, 
440                   int do_wire, int do_texture, int do_light)
441 {
442         if (st->ModeX > 0)
443         {
444                 /*  Reset tunnel and camera position */
445                 if (!st->ModeXFlag)
446                 {
447                         st->cam_pos = st->path;                 
448                         st->cam_t = 0;
449                         st->tFlag = 0;
450                         st->ModeXFlag = 1;
451                         st->current_texture++;
452                         if (st->current_texture >= MAX_TEXTURE) st->current_texture = 0;
453                 }
454                 /*  Now we want to draw splash screen */
455                 glLoadIdentity();
456                 /*  Disable all unused features */
457                 glDisable(GL_DEPTH_TEST);
458                 glDisable(GL_LIGHTING);
459                 glDisable(GL_FOG);
460                 glDisable(GL_CULL_FACE);
461
462                 glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);
463                 glEnable(GL_BLEND);
464                 glDisable(GL_TEXTURE_2D);
465                 glColor4f(1, 1, 1, st->ModeX);
466                 
467                 /*  Draw splash screen (simply quad) */
468                 glBegin(GL_QUADS);
469                 glVertex3f(-10, -10, -1);
470                 glVertex3f(10, -10, -1);
471                 glVertex3f(10, 10, -1);
472                 glVertex3f(-10, 10, -1);
473                 glEnd();
474
475                 st->ModeX -= 0.05;
476                 if (st->ModeX <= 0)     st->ModeX = 0;
477
478                 if (!do_wire)
479                 {
480                         glEnable(GL_CULL_FACE);
481                         glEnable(GL_DEPTH_TEST);
482                 }
483                 if (do_light)
484                 {
485                         glEnable(GL_LIGHTING);
486                         glEnable(GL_FOG);
487                 }
488                 if (do_texture)
489                 {
490                         glEnable(GL_TEXTURE_2D);
491                 }
492                 glDisable(GL_BLEND);
493                 glColor4f(1, 1, 1, 1);
494         }
495 }
496
497 void FreeTunnel(struct tunnel_state *st)
498 {
499   free (st);
500 }
501
502 #endif