From http://www.jwz.org/xscreensaver/xscreensaver-5.30.tar.gz
[xscreensaver] / hacks / nerverot.c
1 /* nerverot, nervous rotation of random thingies, v1.4
2  * by Dan Bornstein, danfuzz@milk.com
3  * Copyright (c) 2000-2001 Dan Bornstein. All rights reserved.
4  *
5  * Permission to use, copy, modify, distribute, and sell this software and its
6  * documentation for any purpose is hereby granted without fee, provided that
7  * the above copyright notice appear in all copies and that both that
8  * copyright notice and this permission notice appear in supporting
9  * documentation.  No representations are made about the suitability of this
10  * software for any purpose.  It is provided "as is" without express or 
11  * implied warranty.
12  *
13  * The goal of this screensaver is to be interesting and compelling to
14  * watch, yet induce a state of nervous edginess in the viewer.
15  *
16  * See the included man page for more details.
17  */
18
19 #include <math.h>
20 #include "screenhack.h"
21
22 #define FLOAT double
23
24 /* random float in the range (-1..1) */
25 #define RAND_FLOAT_PM1 \
26         (((FLOAT) ((random() >> 8) & 0xffff)) / ((FLOAT) 0x10000) * 2 - 1)
27
28 /* random float in the range (0..1) */
29 #define RAND_FLOAT_01 \
30         (((FLOAT) ((random() >> 8) & 0xffff)) / ((FLOAT) 0x10000))
31
32
33 /* structure of the model */
34
35 /* each point-like thingy to draw is represented as a blot */
36 typedef struct blot_s
37 {
38     FLOAT x;           /* 3d x position (-1..1) */
39     FLOAT y;           /* 3d y position (-1..1) */
40     FLOAT z;           /* 3d z position (-1..1) */
41     FLOAT xoff[3][3];  /* display x offset per drawn point (-1..1) */
42     FLOAT yoff[3][3];  /* display x offset per drawn point (-1..1) */
43 } Blot;
44
45 /* each drawn line is represented as a LineSegment */
46 typedef struct linesegment_s
47 {
48     GC gc;
49     int x1;
50     int y1;
51     int x2;
52     int y2;
53 } LineSegment;
54
55 /* each blot draws as a simple 2d shape with each coordinate as an int
56  * in the range (-1..1); this is the base shape */
57 static const XPoint blotShape[] = { { 0, 0}, { 1, 0}, { 1, 1}, 
58                                     { 0, 1}, {-1, 1}, {-1, 0}, 
59                                     {-1,-1}, { 0,-1}, { 1,-1} };
60 static int blotShapeCount = sizeof (blotShape) / sizeof (XPoint);
61
62
63
64
65
66 struct state {
67   Display *dpy;
68   Window window;
69
70    int requestedBlotCount;      /* number of blots */
71    int delay;           /* delay (usec) between iterations */
72    int maxIters;                /* max iterations per model */
73    FLOAT nervousness;   /* variability of xoff/yoff per iteration (0..1) */
74    FLOAT maxNerveRadius;        /* max nervousness radius (0..1) */
75    FLOAT eventChance;   /* chance per iteration that an event will happen */
76    FLOAT iterAmt;               /* fraction (0..1) towards rotation target or scale target to move each * iteration */
77    FLOAT minScale;              /* min and max scale for drawing, as fraction of baseScale */
78    FLOAT maxScale;
79    int minRadius;               /* min and max radius of blot drawing */
80    int maxRadius;
81    int colorCount;              /* the number of colors to use */
82
83    int lineWidth;               /* width of lines */
84
85    Bool doubleBuffer;   /* whether or not to do double-buffering */
86
87
88    int baseScale;               /* base scale factor for drawing, calculated as max(screenWidth,screenHeight) */
89
90
91    int windowWidth;             /* width and height of the window */
92    int windowHeight;
93
94    int centerX;         /* center position of the window */
95    int centerY;
96
97    Drawable drawable; /* the thing to directly draw on */
98    GC *gcs;           /* array of gcs, one per color used */
99
100    Blot *blots; /* array of the blots in the model */
101    int blotCount;
102
103    int segCount;                /* two arrays of line segments; one for the ones to erase, and one for the ones to draw */
104
105    LineSegment *segsToDraw;
106    LineSegment *segsToErase;
107
108
109    FLOAT xRot;          /* current rotation values per axis, scale factor, and light position */
110
111    FLOAT yRot;
112    FLOAT zRot;
113    FLOAT curScale;
114    FLOAT lightX;
115    FLOAT lightY;
116    FLOAT lightZ;
117
118    FLOAT xRotTarget;    /* target rotation values per axis, scale factor, and light position */
119
120    FLOAT yRotTarget;
121    FLOAT zRotTarget;
122    FLOAT scaleTarget;
123    FLOAT lightXTarget;
124    FLOAT lightYTarget;
125    FLOAT lightZTarget;
126
127    int centerXOff;      /* current absolute offsets from the center */
128    int centerYOff;
129
130    int itersTillNext;   /* iterations until the model changes */
131 };
132
133
134 /*
135  * generic blot setup and manipulation
136  */
137
138 /* initialize a blot with the given coordinates and random display offsets */
139 static void initBlot (Blot *b, FLOAT x, FLOAT y, FLOAT z)
140 {
141     int i, j;
142
143     b->x = x;
144     b->y = y;
145     b->z = z;
146
147     for (i = 0; i < 3; i++)
148     {
149         for (j = 0; j < 3; j++)
150         {
151             b->xoff[i][j] = RAND_FLOAT_PM1;
152             b->yoff[i][j] = RAND_FLOAT_PM1;
153         }
154     }
155 }
156
157 /* scale the blots to have a max distance of 1 from the center */
158 static void scaleBlotsToRadius1 (struct state *st)
159 {
160     FLOAT max = 0.0;
161     int n;
162
163     for (n = 0; n < st->blotCount; n++)
164     {
165         FLOAT distSquare = 
166             st->blots[n].x * st->blots[n].x +
167             st->blots[n].y * st->blots[n].y +
168             st->blots[n].z * st->blots[n].z;
169         if (distSquare > max)
170         {
171             max = distSquare;
172         }
173     }
174
175     if (max == 0.0)
176     {
177         return;
178     }
179
180     max = sqrt (max);
181
182     for (n = 0; n < st->blotCount; n++)
183     {
184         st->blots[n].x /= max;
185         st->blots[n].y /= max;
186         st->blots[n].z /= max;
187     }
188 }
189
190 /* randomly reorder the blots */
191 static void randomlyReorderBlots (struct state *st)
192 {
193     int n;
194
195     for (n = 0; n < st->blotCount; n++)
196     {
197         int m = RAND_FLOAT_01 * (st->blotCount - n) + n;
198         Blot tmpBlot = st->blots[n];
199         st->blots[n] = st->blots[m];
200         st->blots[m] = tmpBlot;
201     }
202 }
203
204 /* randomly rotate the blots around the origin */
205 static void randomlyRotateBlots (struct state *st)
206 {
207     int n;
208
209     /* random amounts to rotate about each axis */
210     FLOAT xRot = RAND_FLOAT_PM1 * M_PI;
211     FLOAT yRot = RAND_FLOAT_PM1 * M_PI;
212     FLOAT zRot = RAND_FLOAT_PM1 * M_PI;
213
214     /* rotation factors */
215     FLOAT sinX = sin (xRot);
216     FLOAT cosX = cos (xRot);
217     FLOAT sinY = sin (yRot);
218     FLOAT cosY = cos (yRot);
219     FLOAT sinZ = sin (zRot);
220     FLOAT cosZ = cos (zRot);
221
222     for (n = 0; n < st->blotCount; n++)
223     {
224         FLOAT x1 = st->blots[n].x;
225         FLOAT y1 = st->blots[n].y;
226         FLOAT z1 = st->blots[n].z;
227         FLOAT x2, y2, z2;
228
229         /* rotate on z axis */
230         x2 = x1 * cosZ - y1 * sinZ;
231         y2 = x1 * sinZ + y1 * cosZ;
232         z2 = z1;
233
234         /* rotate on x axis */
235         y1 = y2 * cosX - z2 * sinX;
236         z1 = y2 * sinX + z2 * cosX;
237         x1 = x2;
238
239         /* rotate on y axis */
240         z2 = z1 * cosY - x1 * sinY;
241         x2 = z1 * sinY + x1 * cosY;
242         y2 = y1;
243
244         st->blots[n].x = x2;
245         st->blots[n].y = y2;
246         st->blots[n].z = z2;
247     }
248 }
249
250
251
252 /*
253  * blot configurations
254  */
255
256 /* set up the initial array of blots to be a at the edge of a sphere */
257 static void setupBlotsSphere (struct state *st)
258 {
259     int n;
260
261     st->blotCount = st->requestedBlotCount;
262     st->blots = calloc (sizeof (Blot), st->blotCount);
263
264     for (n = 0; n < st->blotCount; n++)
265     {
266         /* pick a spot, but reject if its radius is < 0.2 or > 1 to
267          * avoid scaling problems */
268         FLOAT x, y, z, radius;
269
270         for (;;)
271         {
272             x = RAND_FLOAT_PM1;
273             y = RAND_FLOAT_PM1;
274             z = RAND_FLOAT_PM1;
275
276             radius = sqrt (x * x + y * y + z * z);
277             if ((radius >= 0.2) && (radius <= 1.0))
278             {
279                 break;
280             }
281         }
282
283         x /= radius;
284         y /= radius;
285         z /= radius;
286
287         initBlot (&st->blots[n], x, y, z);
288     }
289 }
290
291 /* set up the initial array of blots to be a simple cube */
292 static void setupBlotsCube (struct state *st)
293 {
294     int i, j, k, n;
295
296     /* derive blotsPerEdge from blotCount, but then do the reverse
297      * since roundoff may have changed blotCount */
298     int blotsPerEdge = ((st->requestedBlotCount - 8) / 12) + 2;
299     FLOAT distBetween;
300
301     if (blotsPerEdge < 2)
302     {
303         blotsPerEdge = 2;
304     }
305
306     distBetween = 2.0 / (blotsPerEdge - 1.0);
307
308     st->blotCount = 8 + (blotsPerEdge - 2) * 12;
309     st->blots = calloc (sizeof (Blot), st->blotCount);
310     n = 0;
311
312     /* define the corners */
313     for (i = -1; i < 2; i += 2)
314     {
315         for (j = -1; j < 2; j += 2)
316         {
317             for (k = -1; k < 2; k += 2)
318             {
319                 initBlot (&st->blots[n], i, j, k);
320                 n++;
321             } 
322         }
323     }
324
325     /* define the edges */
326     for (i = 1; i < (blotsPerEdge - 1); i++)
327     {
328         FLOAT varEdge = distBetween * i - 1;
329         initBlot (&st->blots[n++], varEdge, -1, -1);
330         initBlot (&st->blots[n++], varEdge,  1, -1);
331         initBlot (&st->blots[n++], varEdge, -1,  1);
332         initBlot (&st->blots[n++], varEdge,  1,  1);
333         initBlot (&st->blots[n++], -1, varEdge, -1);
334         initBlot (&st->blots[n++],  1, varEdge, -1);
335         initBlot (&st->blots[n++], -1, varEdge,  1);
336         initBlot (&st->blots[n++],  1, varEdge,  1);
337         initBlot (&st->blots[n++], -1, -1, varEdge);
338         initBlot (&st->blots[n++],  1, -1, varEdge);
339         initBlot (&st->blots[n++], -1,  1, varEdge);
340         initBlot (&st->blots[n++],  1,  1, varEdge);
341     }
342
343     scaleBlotsToRadius1 (st);
344     randomlyReorderBlots (st);
345     randomlyRotateBlots (st);
346 }
347
348 /* set up the initial array of blots to be a cylinder */
349 static void setupBlotsCylinder (struct state *st)
350 {
351     int i, j, n;
352     FLOAT distBetween;
353
354     /* derive blotsPerEdge and blotsPerRing from blotCount, but then do the
355      * reverse since roundoff may have changed blotCount */
356     FLOAT reqRoot = sqrt ((FLOAT) st->requestedBlotCount);
357     int blotsPerRing = ceil (RAND_FLOAT_PM1 * reqRoot) / 2 + reqRoot;
358     int blotsPerEdge = st->requestedBlotCount / blotsPerRing;
359
360     if (blotsPerRing < 2)
361     {
362         blotsPerRing = 2;
363     }
364
365     if (blotsPerEdge < 2)
366     {
367         blotsPerEdge = 2;
368     }
369
370     distBetween = 2.0 / (blotsPerEdge - 1);
371
372     st->blotCount = blotsPerEdge * blotsPerRing;
373     st->blots = calloc (sizeof (Blot), st->blotCount);
374     n = 0;
375
376     /* define the edges */
377     for (i = 0; i < blotsPerRing; i++)
378     {
379         FLOAT x = sin (2 * M_PI / blotsPerRing * i);
380         FLOAT y = cos (2 * M_PI / blotsPerRing * i);
381         for (j = 0; j < blotsPerEdge; j++)
382         {
383             initBlot (&st->blots[n], x, y, j * distBetween - 1);
384             n++;
385         }
386     }
387
388     scaleBlotsToRadius1 (st);
389     randomlyReorderBlots (st);
390     randomlyRotateBlots (st);
391 }
392
393 /* set up the initial array of blots to be a squiggle */
394 static void setupBlotsSquiggle (struct state *st)
395 {
396     FLOAT x, y, z, xv, yv, zv, len;
397     int minCoor, maxCoor;
398     int n;
399
400     st->blotCount = st->requestedBlotCount;
401     st->blots = calloc (sizeof (Blot), st->blotCount);
402
403     maxCoor = (int) (RAND_FLOAT_01 * 5) + 1;
404     minCoor = -maxCoor;
405
406     x = RAND_FLOAT_PM1;
407     y = RAND_FLOAT_PM1;
408     z = RAND_FLOAT_PM1;
409
410     xv = RAND_FLOAT_PM1;
411     yv = RAND_FLOAT_PM1;
412     zv = RAND_FLOAT_PM1;
413     len = sqrt (xv * xv + yv * yv + zv * zv);
414     xv /= len;
415     yv /= len;
416     zv /= len;
417     
418     for (n = 0; n < st->blotCount; n++)
419     {
420         FLOAT newx, newy, newz;
421         initBlot (&st->blots[n], x, y, z);
422
423         for (;;)
424         {
425             xv += RAND_FLOAT_PM1 * 0.1;
426             yv += RAND_FLOAT_PM1 * 0.1;
427             zv += RAND_FLOAT_PM1 * 0.1;
428             len = sqrt (xv * xv + yv * yv + zv * zv);
429             xv /= len;
430             yv /= len;
431             zv /= len;
432
433             newx = x + xv * 0.1;
434             newy = y + yv * 0.1;
435             newz = z + zv * 0.1;
436
437             if (   (newx >= minCoor) && (newx <= maxCoor)
438                 && (newy >= minCoor) && (newy <= maxCoor)
439                 && (newz >= minCoor) && (newz <= maxCoor))
440             {
441                 break;
442             }
443         }
444
445         x = newx;
446         y = newy;
447         z = newz;
448     }
449
450     scaleBlotsToRadius1 (st);
451     randomlyReorderBlots (st);
452 }
453
454 /* set up the initial array of blots to be near the corners of a
455  * cube, distributed slightly */
456 static void setupBlotsCubeCorners (struct state *st)
457 {
458     int n;
459
460     st->blotCount = st->requestedBlotCount;
461     st->blots = calloc (sizeof (Blot), st->blotCount);
462
463     for (n = 0; n < st->blotCount; n++)
464     {
465         FLOAT x = rint (RAND_FLOAT_01) * 2 - 1;
466         FLOAT y = rint (RAND_FLOAT_01) * 2 - 1;
467         FLOAT z = rint (RAND_FLOAT_01) * 2 - 1;
468
469         x += RAND_FLOAT_PM1 * 0.3;
470         y += RAND_FLOAT_PM1 * 0.3;
471         z += RAND_FLOAT_PM1 * 0.3;
472
473         initBlot (&st->blots[n], x, y, z);
474     }
475
476     scaleBlotsToRadius1 (st);
477     randomlyRotateBlots (st);
478 }
479
480 /* set up the initial array of blots to be randomly distributed
481  * on the surface of a tetrahedron */
482 static void setupBlotsTetrahedron (struct state *st)
483 {
484     /* table of corners of the tetrahedron */
485     static const FLOAT cor[4][3] = { {  0.0,   1.0,  0.0 },
486                                      { -0.75, -0.5, -0.433013 },
487                                      {  0.0,  -0.5,  0.866025 },
488                                      {  0.75, -0.5, -0.433013 } };
489
490     int n, c;
491
492     /* derive blotsPerSurface from blotCount, but then do the reverse
493      * since roundoff may have changed blotCount */
494     int blotsPerSurface = st->requestedBlotCount / 4;
495
496     st->blotCount = blotsPerSurface * 4;
497     st->blots = calloc (sizeof (Blot), st->blotCount);
498
499     for (n = 0; n < st->blotCount; n += 4)
500     {
501         /* pick a random point on a unit right triangle */
502         FLOAT rawx = RAND_FLOAT_01;
503         FLOAT rawy = RAND_FLOAT_01;
504
505         if ((rawx + rawy) > 1)
506         {
507             /* swap coords into place */
508             FLOAT t = 1.0 - rawx;
509             rawx = 1.0 - rawy;
510             rawy = t;
511         }
512
513         /* translate the point to be on each of the surfaces */
514         for (c = 0; c < 4; c++)
515         {
516             FLOAT x, y, z;
517             
518             int c1 = (c + 1) % 4;
519             int c2 = (c + 2) % 4;
520             
521             x = (cor[c1][0] - cor[c][0]) * rawx + 
522                 (cor[c2][0] - cor[c][0]) * rawy + 
523                 cor[c][0];
524
525             y = (cor[c1][1] - cor[c][1]) * rawx + 
526                 (cor[c2][1] - cor[c][1]) * rawy + 
527                 cor[c][1];
528
529             z = (cor[c1][2] - cor[c][2]) * rawx + 
530                 (cor[c2][2] - cor[c][2]) * rawy + 
531                 cor[c][2];
532
533             initBlot (&st->blots[n + c], x, y, z);
534         }
535     }
536
537     randomlyRotateBlots (st);
538 }
539
540 /* set up the initial array of blots to be an almost-evenly-distributed
541  * square sheet */
542 static void setupBlotsSheet (struct state *st)
543 {
544     int x, y;
545
546     int blotsPerDimension = floor (sqrt (st->requestedBlotCount));
547     FLOAT spaceBetween;
548
549     if (blotsPerDimension < 2)
550     {
551         blotsPerDimension = 2;
552     }
553
554     spaceBetween = 2.0 / (blotsPerDimension - 1);
555
556     st->blotCount = blotsPerDimension * blotsPerDimension;
557     st->blots = calloc (sizeof (Blot), st->blotCount);
558
559     for (x = 0; x < blotsPerDimension; x++)
560     {
561         for (y = 0; y < blotsPerDimension; y++)
562         {
563             FLOAT x1 = x * spaceBetween - 1.0;
564             FLOAT y1 = y * spaceBetween - 1.0;
565             FLOAT z1 = 0.0;
566
567             x1 += RAND_FLOAT_PM1 * spaceBetween / 3;
568             y1 += RAND_FLOAT_PM1 * spaceBetween / 3;
569             z1 += RAND_FLOAT_PM1 * spaceBetween / 2;
570
571             initBlot (&st->blots[x + y * blotsPerDimension], x1, y1, z1);
572         }
573     }
574
575     scaleBlotsToRadius1 (st);
576     randomlyReorderBlots (st);
577     randomlyRotateBlots (st);
578 }
579
580 /* set up the initial array of blots to be a swirlycone */
581 static void setupBlotsSwirlyCone (struct state *st)
582 {
583     FLOAT radSpace = 1.0 / (st->requestedBlotCount - 1);
584     FLOAT zSpace = radSpace * 2;
585     FLOAT rotAmt = RAND_FLOAT_PM1 * M_PI / 10;
586
587     int n;
588     FLOAT rot = 0.0;
589
590     st->blotCount = st->requestedBlotCount;
591     st->blots = calloc (sizeof (Blot), st->blotCount);
592
593     for (n = 0; n < st->blotCount; n++)
594     {
595         FLOAT radius = n * radSpace;
596         FLOAT x = cos (rot) * radius;
597         FLOAT y = sin (rot) * radius;
598         FLOAT z = n * zSpace - 1.0;
599
600         rot += rotAmt;
601         initBlot (&st->blots[n], x, y, z);
602     }
603
604     scaleBlotsToRadius1 (st);
605     randomlyReorderBlots (st);
606     randomlyRotateBlots (st);
607 }
608
609 /* forward declaration for recursive use immediately below */
610 static void setupBlots (struct state *st);
611
612 /* set up the blots to be two of the other choices, placed next to
613  * each other */
614 static void setupBlotsDuo (struct state *st)
615 {
616     int origRequest = st->requestedBlotCount;
617     FLOAT tx, ty, tz, radius;
618     Blot *blots1, *blots2;
619     int count1, count2;
620     int n;
621
622     if (st->requestedBlotCount < 15)
623     {
624         /* special case bottom-out */
625         setupBlotsSphere (st);
626         return;
627     }
628
629     tx = RAND_FLOAT_PM1;
630     ty = RAND_FLOAT_PM1;
631     tz = RAND_FLOAT_PM1;
632     radius = sqrt (tx * tx + ty * ty + tz * tz);
633     tx /= radius;
634     ty /= radius;
635     tz /= radius;
636
637     /* recursive call to setup set 1 */
638     st->requestedBlotCount = origRequest / 2;
639     setupBlots (st);
640
641     if (st->blotCount >= origRequest)
642     {
643         /* return immediately if this satisfies the original count request */
644         st->requestedBlotCount = origRequest;
645         return;
646     }
647
648     blots1 = st->blots;
649     count1 = st->blotCount;
650     st->blots = NULL;
651     st->blotCount = 0;
652     
653     /* translate to new position */
654     for (n = 0; n < count1; n++)
655     {
656         blots1[n].x += tx;
657         blots1[n].y += ty;
658         blots1[n].z += tz;
659     }
660
661     /* recursive call to setup set 2 */
662     st->requestedBlotCount = origRequest - count1;
663     setupBlots (st);
664     blots2 = st->blots;
665     count2 = st->blotCount;
666
667     /* translate to new position */
668     for (n = 0; n < count2; n++)
669     {
670         blots2[n].x -= tx;
671         blots2[n].y -= ty;
672         blots2[n].z -= tz;
673     }
674
675     /* combine the two arrays */
676     st->blotCount = count1 + count2;
677     st->blots = calloc (sizeof (Blot), st->blotCount);
678     memcpy (&st->blots[0],      blots1, sizeof (Blot) * count1);
679     memcpy (&st->blots[count1], blots2, sizeof (Blot) * count2);
680     free (blots1);
681     free (blots2);
682
683     scaleBlotsToRadius1 (st);
684     randomlyReorderBlots (st);
685
686     /* restore the original requested count, for future iterations */
687     st->requestedBlotCount = origRequest;
688 }
689
690
691
692 /*
693  * main blot setup
694  */
695
696 /* free the blots, in preparation for a new shape */
697 static void freeBlots (struct state *st)
698 {
699     if (st->blots != NULL)
700     {
701         free (st->blots);
702         st->blots = NULL;
703     }
704
705     if (st->segsToErase != NULL)
706     {
707         free (st->segsToErase);
708         st->segsToErase = NULL;
709     }
710
711     if (st->segsToDraw != NULL)
712     {
713         free (st->segsToDraw);
714         st->segsToDraw = NULL;
715     }
716 }
717
718 /* set up the initial arrays of blots */
719 static void setupBlots (struct state *st)
720 {
721     int which = RAND_FLOAT_01 * 11;
722
723     freeBlots (st);
724
725     switch (which)
726     {
727         case 0:
728             setupBlotsCube (st);
729             break;
730         case 1:
731             setupBlotsSphere (st);
732             break;
733         case 2:
734             setupBlotsCylinder (st);
735             break;
736         case 3:
737             setupBlotsSquiggle (st);
738             break;
739         case 4:
740             setupBlotsCubeCorners (st);
741             break;
742         case 5:
743             setupBlotsTetrahedron (st);
744             break;
745         case 6:
746             setupBlotsSheet (st);
747             break;
748         case 7:
749             setupBlotsSwirlyCone (st);
750             break;
751         case 8:
752         case 9:
753         case 10:
754             setupBlotsDuo (st);
755             break;
756     }
757 }
758
759 /* set up the segments arrays */
760 static void setupSegs (struct state *st)
761 {
762     /* there are blotShapeCount - 1 line segments per blot */
763     st->segCount = st->blotCount * (blotShapeCount - 1);
764     st->segsToErase = calloc (sizeof (LineSegment), st->segCount);
765     st->segsToDraw = calloc (sizeof (LineSegment), st->segCount);
766 }
767
768
769
770 /*
771  * color setup stuff
772  */
773
774 /* set up the colormap */
775 static void setupColormap (struct state *st, XWindowAttributes *xgwa)
776 {
777     int n;
778     XGCValues gcv;
779     XColor *colors = (XColor *) calloc (sizeof (XColor), st->colorCount + 1);
780
781     unsigned short r, g, b;
782     int h1, h2;
783     double s1, s2, v1, v2;
784
785     r = RAND_FLOAT_01 * 0x10000;
786     g = RAND_FLOAT_01 * 0x10000;
787     b = RAND_FLOAT_01 * 0x10000;
788     rgb_to_hsv (r, g, b, &h1, &s1, &v1);
789     v1 = 1.0;
790     s1 = 1.0;
791
792     r = RAND_FLOAT_01 * 0x10000;
793     g = RAND_FLOAT_01 * 0x10000;
794     b = RAND_FLOAT_01 * 0x10000;
795     rgb_to_hsv (r, g, b, &h2, &s2, &v2);
796     s2 = 0.7;
797     v2 = 0.7;
798     
799     colors[0].pixel = get_pixel_resource (st->dpy, xgwa->colormap,
800                                           "background", "Background");
801     
802     make_color_ramp (xgwa->screen, xgwa->visual, xgwa->colormap,
803                      h1, s1, v1, h2, s2, v2,
804                      colors + 1, &st->colorCount, False, True, False);
805
806     if (st->colorCount < 1)
807     {
808         fprintf (stderr, "%s: couldn't allocate any colors\n", progname);
809         exit (-1);
810     }
811     
812     st->gcs = (GC *) calloc (sizeof (GC), st->colorCount + 1);
813
814     for (n = 0; n <= st->colorCount; n++) 
815     {
816         gcv.foreground = colors[n].pixel;
817         gcv.line_width = st->lineWidth;
818         st->gcs[n] = XCreateGC (st->dpy, st->window, GCForeground | GCLineWidth, &gcv);
819     }
820
821     free (colors);
822 }
823
824
825
826 /*
827  * overall setup stuff
828  */
829
830 /* set up the system */
831 static void setup (struct state *st)
832 {
833     XWindowAttributes xgwa;
834
835     XGetWindowAttributes (st->dpy, st->window, &xgwa);
836
837     st->windowWidth = xgwa.width;
838     st->windowHeight = xgwa.height;
839     st->centerX = st->windowWidth / 2;
840     st->centerY = st->windowHeight / 2;
841     st->baseScale = (xgwa.height < xgwa.width) ? xgwa.height : xgwa.width;
842
843     if (st->doubleBuffer)
844     {
845         st->drawable = XCreatePixmap (st->dpy, st->window, xgwa.width, xgwa.height,
846                                   xgwa.depth);
847     }
848     else
849     {
850         st->drawable = st->window;
851     }
852
853     setupColormap (st, &xgwa);
854     setupBlots (st);
855     setupSegs (st);
856
857     /* set up the initial rotation, scale, and light values as random, but
858      * with the targets equal to where it is */
859     st->xRot = st->xRotTarget = RAND_FLOAT_01 * M_PI;
860     st->yRot = st->yRotTarget = RAND_FLOAT_01 * M_PI;
861     st->zRot = st->zRotTarget = RAND_FLOAT_01 * M_PI;
862     st->curScale = st->scaleTarget = RAND_FLOAT_01 * (st->maxScale - st->minScale) + st->minScale;
863     st->lightX = st->lightXTarget = RAND_FLOAT_PM1;
864     st->lightY = st->lightYTarget = RAND_FLOAT_PM1;
865     st->lightZ = st->lightZTarget = RAND_FLOAT_PM1;
866
867     st->itersTillNext = RAND_FLOAT_01 * st->maxIters;
868 }
869
870
871
872 /*
873  * the simulation
874  */
875
876 /* "render" the blots into segsToDraw, with the current rotation factors */
877 static void renderSegs (struct state *st)
878 {
879     int n;
880     int m = 0;
881
882     /* rotation factors */
883     FLOAT sinX = sin (st->xRot);
884     FLOAT cosX = cos (st->xRot);
885     FLOAT sinY = sin (st->yRot);
886     FLOAT cosY = cos (st->yRot);
887     FLOAT sinZ = sin (st->zRot);
888     FLOAT cosZ = cos (st->zRot);
889
890     for (n = 0; n < st->blotCount; n++)
891     {
892         Blot *b = &st->blots[n];
893         int i, j;
894         int baseX, baseY;
895         FLOAT radius;
896         int x[3][3];
897         int y[3][3];
898         int color;
899
900         FLOAT x1 = st->blots[n].x;
901         FLOAT y1 = st->blots[n].y;
902         FLOAT z1 = st->blots[n].z;
903         FLOAT x2, y2, z2;
904
905         /* rotate on z axis */
906         x2 = x1 * cosZ - y1 * sinZ;
907         y2 = x1 * sinZ + y1 * cosZ;
908         z2 = z1;
909
910         /* rotate on x axis */
911         y1 = y2 * cosX - z2 * sinX;
912         z1 = y2 * sinX + z2 * cosX;
913         x1 = x2;
914
915         /* rotate on y axis */
916         z2 = z1 * cosY - x1 * sinY;
917         x2 = z1 * sinY + x1 * cosY;
918         y2 = y1;
919
920         /* the color to draw is based on the distance from the light of
921          * the post-rotation blot */
922         x1 = x2 - st->lightX;
923         y1 = y2 - st->lightY;
924         z1 = z2 - st->lightZ;
925         color = 1 + (x1 * x1 + y1 * y1 + z1 * z1) / 4 * st->colorCount;
926         if (color > st->colorCount)
927         {
928             color = st->colorCount;
929         }
930
931         /* set up the base screen coordinates for drawing */
932         baseX = x2 / 2 * st->baseScale * st->curScale + st->centerX + st->centerXOff;
933         baseY = y2 / 2 * st->baseScale * st->curScale + st->centerY + st->centerYOff;
934         
935         radius = (z2 + 1) / 2 * (st->maxRadius - st->minRadius) + st->minRadius;
936
937         for (i = 0; i < 3; i++)
938         {
939             for (j = 0; j < 3; j++)
940             {
941                 x[i][j] = baseX + 
942                     ((i - 1) + (b->xoff[i][j] * st->maxNerveRadius)) * radius;
943                 y[i][j] = baseY + 
944                     ((j - 1) + (b->yoff[i][j] * st->maxNerveRadius)) * radius;
945             }
946         }
947
948         for (i = 1; i < blotShapeCount; i++)
949         {
950             st->segsToDraw[m].gc = st->gcs[color];
951             st->segsToDraw[m].x1 = x[blotShape[i-1].x + 1][blotShape[i-1].y + 1];
952             st->segsToDraw[m].y1 = y[blotShape[i-1].x + 1][blotShape[i-1].y + 1];
953             st->segsToDraw[m].x2 = x[blotShape[i].x   + 1][blotShape[i].y   + 1];
954             st->segsToDraw[m].y2 = y[blotShape[i].x   + 1][blotShape[i].y   + 1];
955             m++;
956         }
957     }
958 }
959
960 /* update blots, adjusting the offsets and rotation factors. */
961 static void updateWithFeeling (struct state *st)
962 {
963     int n, i, j;
964
965     /* pick a new model if the time is right */
966     st->itersTillNext--;
967     if (st->itersTillNext < 0)
968     {
969         st->itersTillNext = RAND_FLOAT_01 * st->maxIters;
970         setupBlots (st);
971         setupSegs (st);
972         renderSegs (st);
973     }
974
975     /* update the rotation factors by moving them a bit toward the targets */
976     st->xRot = st->xRot + (st->xRotTarget - st->xRot) * st->iterAmt; 
977     st->yRot = st->yRot + (st->yRotTarget - st->yRot) * st->iterAmt;
978     st->zRot = st->zRot + (st->zRotTarget - st->zRot) * st->iterAmt;
979
980     /* similarly the scale factor */
981     st->curScale = st->curScale + (st->scaleTarget - st->curScale) * st->iterAmt;
982
983     /* and similarly the light position */
984     st->lightX = st->lightX + (st->lightXTarget - st->lightX) * st->iterAmt; 
985     st->lightY = st->lightY + (st->lightYTarget - st->lightY) * st->iterAmt; 
986     st->lightZ = st->lightZ + (st->lightZTarget - st->lightZ) * st->iterAmt; 
987
988     /* for each blot... */
989     for (n = 0; n < st->blotCount; n++)
990     {
991         /* add a bit of random jitter to xoff/yoff */
992         for (i = 0; i < 3; i++)
993         {
994             for (j = 0; j < 3; j++)
995             {
996                 FLOAT newOff;
997
998                 newOff = st->blots[n].xoff[i][j] + RAND_FLOAT_PM1 * st->nervousness;
999                 if (newOff < -1) newOff = -(newOff + 1) - 1;
1000                 else if (newOff > 1) newOff = -(newOff - 1) + 1;
1001                 st->blots[n].xoff[i][j] = newOff;
1002
1003                 newOff = st->blots[n].yoff[i][j] + RAND_FLOAT_PM1 * st->nervousness;
1004                 if (newOff < -1) newOff = -(newOff + 1) - 1;
1005                 else if (newOff > 1) newOff = -(newOff - 1) + 1;
1006                 st->blots[n].yoff[i][j] = newOff;
1007             }
1008         }
1009     }
1010
1011     /* depending on random chance, update one or more factors */
1012     if (RAND_FLOAT_01 <= st->eventChance)
1013     {
1014         int which = RAND_FLOAT_01 * 14;
1015         switch (which)
1016         {
1017             case 0:
1018             {
1019                 st->xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1020                 break;
1021             }
1022             case 1:
1023             {
1024                 st->yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1025                 break;
1026             }
1027             case 2:
1028             {
1029                 st->zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1030                 break;
1031             }
1032             case 3:
1033             {
1034                 st->xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1035                 st->yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1036                 break;
1037             }
1038             case 4:
1039             {
1040                 st->xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1041                 st->zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1042                 break;
1043             }
1044             case 5:
1045             {
1046                 st->yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1047                 st->zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1048                 break;
1049             }
1050             case 6:
1051             {
1052                 st->xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1053                 st->yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1054                 st->zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
1055                 break;
1056             }
1057             case 7:
1058             {
1059                 st->centerXOff = RAND_FLOAT_PM1 * st->maxRadius;
1060                 break;
1061             }
1062             case 8:
1063             {
1064                 st->centerYOff = RAND_FLOAT_PM1 * st->maxRadius;
1065                 break;
1066             }
1067             case 9:
1068             {
1069                 st->centerXOff = RAND_FLOAT_PM1 * st->maxRadius;
1070                 st->centerYOff = RAND_FLOAT_PM1 * st->maxRadius;
1071                 break;
1072             }
1073             case 10:
1074             {
1075                 st->scaleTarget = 
1076                     RAND_FLOAT_01 * (st->maxScale - st->minScale) + st->minScale;
1077                 break;
1078             }
1079             case 11:
1080             {
1081                 st->curScale = 
1082                     RAND_FLOAT_01 * (st->maxScale - st->minScale) + st->minScale;
1083                 break;
1084             }
1085             case 12:
1086             {
1087                 st->lightX = RAND_FLOAT_PM1;
1088                 st->lightY = RAND_FLOAT_PM1;
1089                 st->lightZ = RAND_FLOAT_PM1;
1090                 break;
1091             }
1092             case 13:
1093             {
1094                 st->lightXTarget = RAND_FLOAT_PM1;
1095                 st->lightYTarget = RAND_FLOAT_PM1;
1096                 st->lightZTarget = RAND_FLOAT_PM1;
1097                 break;
1098             }
1099         }
1100     }
1101 }
1102
1103 /* erase segsToErase and draw segsToDraw */
1104 static void eraseAndDraw (struct state *st)
1105 {
1106     int n;
1107
1108     if (st->doubleBuffer)
1109       XFillRectangle (st->dpy, st->drawable, st->gcs[0], 0, 0, 
1110                       st->windowWidth, st->windowHeight);
1111     else
1112       XClearWindow (st->dpy, st->drawable);
1113
1114     for (n = 0; n < st->segCount; n++)
1115     {
1116         LineSegment *seg = &st->segsToErase[n];
1117 #ifdef HAVE_COCOA       /* Don't second-guess Quartz's double-buffering */
1118         XDrawLine (st->dpy, st->drawable, st->gcs[0], 
1119                    seg->x1, seg->y1, seg->x2, seg->y2);
1120 #endif
1121         seg = &st->segsToDraw[n];
1122         XDrawLine (st->dpy, st->drawable, seg->gc,
1123                    seg->x1, seg->y1, seg->x2, seg->y2);
1124     }
1125
1126     if (st->doubleBuffer)
1127     {
1128         XCopyArea (st->dpy, st->drawable, st->window, st->gcs[0], 0, 0, 
1129                    st->windowWidth, st->windowHeight, 0, 0);
1130     }
1131 }
1132
1133 /* do one iteration */
1134 static unsigned long
1135 nerverot_draw (Display *dpy, Window win, void *closure)
1136 {
1137   struct state *st = (struct state *) closure;
1138     /* switch segsToErase and segsToDraw */
1139     LineSegment *temp = st->segsToDraw;
1140     st->segsToDraw = st->segsToErase;
1141     st->segsToErase = temp;
1142
1143     /* update the model */
1144     updateWithFeeling (st);
1145
1146     /* render new segments */
1147     renderSegs (st);
1148
1149     /* erase old segments and draw new ones */
1150     eraseAndDraw (st);
1151
1152     return st->delay;
1153 }
1154
1155 /* initialize the user-specifiable params */
1156 static void initParams (struct state *st)
1157 {
1158     int problems = 0;
1159
1160     st->delay = get_integer_resource (st->dpy, "delay", "Delay");
1161     if (st->delay < 0)
1162     {
1163         fprintf (stderr, "error: delay must be at least 0\n");
1164         problems = 1;
1165     }
1166     
1167     st->maxIters = get_integer_resource (st->dpy, "maxIters", "Integer");
1168     if (st->maxIters < 0)
1169     {
1170         fprintf (stderr, "error: maxIters must be at least 0\n");
1171         problems = 1;
1172     }
1173     
1174     st->doubleBuffer = get_boolean_resource (st->dpy, "doubleBuffer", "Boolean");
1175
1176 # ifdef HAVE_COCOA      /* Don't second-guess Quartz's double-buffering */
1177     st->doubleBuffer = False;
1178 # endif
1179
1180     st->requestedBlotCount = get_integer_resource (st->dpy, "count", "Count");
1181     if (st->requestedBlotCount <= 0)
1182     {
1183         fprintf (stderr, "error: count must be at least 0\n");
1184         problems = 1;
1185     }
1186
1187     st->colorCount = get_integer_resource (st->dpy, "colors", "Colors");
1188     if (st->colorCount <= 0)
1189     {
1190         fprintf (stderr, "error: colors must be at least 1\n");
1191         problems = 1;
1192     }
1193
1194     st->lineWidth = get_integer_resource (st->dpy, "lineWidth", "LineWidth");
1195     if (st->lineWidth < 0)
1196     {
1197         fprintf (stderr, "error: line width must be at least 0\n");
1198         problems = 1;
1199     }
1200
1201     st->nervousness = get_float_resource (st->dpy, "nervousness", "Float");
1202     if ((st->nervousness < 0) || (st->nervousness > 1))
1203     {
1204         fprintf (stderr, "error: nervousness must be in the range 0..1\n");
1205         problems = 1;
1206     }
1207
1208     st->maxNerveRadius = get_float_resource (st->dpy, "maxNerveRadius", "Float");
1209     if ((st->maxNerveRadius < 0) || (st->maxNerveRadius > 1))
1210     {
1211         fprintf (stderr, "error: maxNerveRadius must be in the range 0..1\n");
1212         problems = 1;
1213     }
1214
1215     st->eventChance = get_float_resource (st->dpy, "eventChance", "Float");
1216     if ((st->eventChance < 0) || (st->eventChance > 1))
1217     {
1218         fprintf (stderr, "error: eventChance must be in the range 0..1\n");
1219         problems = 1;
1220     }
1221
1222     st->iterAmt = get_float_resource (st->dpy, "iterAmt", "Float");
1223     if ((st->iterAmt < 0) || (st->iterAmt > 1))
1224     {
1225         fprintf (stderr, "error: iterAmt must be in the range 0..1\n");
1226         problems = 1;
1227     }
1228
1229     st->minScale = get_float_resource (st->dpy, "minScale", "Float");
1230     if ((st->minScale < 0) || (st->minScale > 10))
1231     {
1232         fprintf (stderr, "error: minScale must be in the range 0..10\n");
1233         problems = 1;
1234     }
1235
1236     st->maxScale = get_float_resource (st->dpy, "maxScale", "Float");
1237     if ((st->maxScale < 0) || (st->maxScale > 10))
1238     {
1239         fprintf (stderr, "error: maxScale must be in the range 0..10\n");
1240         problems = 1;
1241     }
1242
1243     if (st->maxScale < st->minScale)
1244     {
1245         fprintf (stderr, "error: maxScale must be >= minScale\n");
1246         problems = 1;
1247     }   
1248
1249     st->minRadius = get_integer_resource (st->dpy, "minRadius", "Integer");
1250     if ((st->minRadius < 1) || (st->minRadius > 100))
1251     {
1252         fprintf (stderr, "error: minRadius must be in the range 1..100\n");
1253         problems = 1;
1254     }
1255
1256     st->maxRadius = get_integer_resource (st->dpy, "maxRadius", "Integer");
1257     if ((st->maxRadius < 1) || (st->maxRadius > 100))
1258     {
1259         fprintf (stderr, "error: maxRadius must be in the range 1..100\n");
1260         problems = 1;
1261     }
1262
1263     if (st->maxRadius < st->minRadius)
1264     {
1265         fprintf (stderr, "error: maxRadius must be >= minRadius\n");
1266         problems = 1;
1267     }   
1268
1269     if (problems)
1270     {
1271         exit (1);
1272     }
1273 }
1274
1275 static void *
1276 nerverot_init (Display *dpy, Window window)
1277 {
1278   struct state *st = (struct state *) calloc (1, sizeof(*st));
1279   st->dpy = dpy;
1280   st->window = window;
1281
1282     initParams (st);
1283     setup (st);
1284
1285     /* make a valid set to erase at first */
1286     renderSegs (st);
1287     return st;
1288 }
1289
1290 static void
1291 nerverot_reshape (Display *dpy, Window window, void *closure, 
1292                  unsigned int w, unsigned int h)
1293 {
1294 }
1295
1296 static Bool
1297 nerverot_event (Display *dpy, Window window, void *closure, XEvent *event)
1298 {
1299   return False;
1300 }
1301
1302 static void
1303 nerverot_free (Display *dpy, Window window, void *closure)
1304 {
1305   struct state *st = (struct state *) closure;
1306   freeBlots (st);
1307   free (st);
1308 }
1309
1310
1311 static const char *nerverot_defaults [] = {
1312     ".background:       black",
1313     ".foreground:       white",
1314     "*count:            250",
1315     "*colors:           4",
1316     "*delay:            10000",
1317     "*maxIters:         1200",
1318     "*doubleBuffer:     false",
1319     "*eventChance:      0.2",
1320     "*iterAmt:          0.01",
1321     "*lineWidth:        0",
1322     "*minScale:         0.6",
1323     "*maxScale:         1.75",
1324     "*minRadius:        3",
1325     "*maxRadius:        25",
1326     "*maxNerveRadius:   0.7",
1327     "*nervousness:      0.3",
1328 #ifdef USE_IPHONE
1329     "*ignoreRotation:   True",
1330 #endif
1331     0
1332 };
1333
1334 static XrmOptionDescRec nerverot_options [] = {
1335   { "-count",            ".count",          XrmoptionSepArg, 0 },
1336   { "-colors",           ".colors",         XrmoptionSepArg, 0 },
1337   { "-delay",            ".delay",          XrmoptionSepArg, 0 },
1338   { "-max-iters",        ".maxIters",       XrmoptionSepArg, 0 },
1339   { "-db",               ".doubleBuffer",   XrmoptionNoArg,  "true" },
1340   { "-no-db",            ".doubleBuffer",   XrmoptionNoArg,  "false" },
1341   { "-event-chance",     ".eventChance",    XrmoptionSepArg, 0 },
1342   { "-iter-amt",         ".iterAmt",        XrmoptionSepArg, 0 },
1343   { "-line-width",       ".lineWidth",      XrmoptionSepArg, 0 },
1344   { "-min-scale",        ".minScale",       XrmoptionSepArg, 0 },
1345   { "-max-scale",        ".maxScale",       XrmoptionSepArg, 0 },
1346   { "-min-radius",       ".minRadius",      XrmoptionSepArg, 0 },
1347   { "-max-radius",       ".maxRadius",      XrmoptionSepArg, 0 },
1348   { "-max-nerve-radius", ".maxNerveRadius", XrmoptionSepArg, 0 },
1349   { "-nervousness",      ".nervousness",    XrmoptionSepArg, 0 },
1350   { 0, 0, 0, 0 }
1351 };
1352
1353
1354 XSCREENSAVER_MODULE ("NerveRot", nerverot)