http://www.jwz.org/xscreensaver/xscreensaver-5.10.tar.gz
[xscreensaver] / hacks / drift.c
1 /* -*- Mode: C; tab-width: 4 -*- */
2 /* drift --- drifting recursive fractal cosmic flames */
3
4 #if 0
5 static const char sccsid[] = "@(#)drift.c       5.00 2000/11/01 xlockmore";
6 #endif
7
8 /*-
9  * Copyright (c) 1991 by Patrick J. Naughton.
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  * Revision History:
24  * 01-Nov-2000: Allocation checks
25  * 10-May-1997: Jamie Zawinski <jwz@jwz.org> compatible with xscreensaver
26  * 01-Jan-1997: Moved new flame to drift.  Compile time options now run time.
27  * 01-Jun-1995: Updated by Scott Draves.
28  * 27-Jun-1991: vary number of functions used.
29  * 24-Jun-1991: fixed portability problem with integer mod (%).
30  * 06-Jun-1991: Written, received from Scott Draves <spot@cs.cmu.edu>
31  */
32
33 #ifdef STANDALONE
34 # define MODE_drift
35 # define DEFAULTS "*delay: 10000 \n" \
36                                   "*count: 30 \n" \
37                                   "*ncolors: 200 \n" \
38                                   "*fpsSolid: true \n" \
39
40 # define SMOOTH_COLORS
41 # define reshape_drift 0
42 # define drift_handle_event 0
43 # include "xlockmore.h"         /* in xscreensaver distribution */
44 # include "erase.h"
45 #else /* STANDALONE */
46 # define ENTRYPOINT /**/
47 # include "xlock.h"             /* in xlockmore distribution */
48 #endif /* STANDALONE */
49
50 #ifdef MODE_drift
51
52 #define DEF_GROW "False"        /* Grow fractals instead of animating one at a time,
53                                    would then be like flame */
54 #define DEF_LISS "False"        /* if this is defined then instead of a point
55                                    bouncing around in a high dimensional sphere, we
56                                    use lissojous figures.  Only makes sense if
57                                    grow is false. */
58
59 static Bool grow;
60 static Bool liss;
61
62 static XrmOptionDescRec opts[] =
63 {
64         {"-grow", ".drift.grow", XrmoptionNoArg, "on"},
65         {"+grow", ".drift.grow", XrmoptionNoArg, "off"},
66         {"-liss", ".drift.trail", XrmoptionNoArg, "on"},
67         {"+liss", ".drift.trail", XrmoptionNoArg, "off"}
68 };
69 static argtype vars[] =
70 {
71         {&grow, "grow", "Grow", DEF_GROW, t_Bool},
72         {&liss, "trail", "Trail", DEF_LISS, t_Bool}
73 };
74 static OptionStruct desc[] =
75 {
76         {"-/+grow", "turn on/off growing fractals, else they are animated"},
77         {"-/+liss", "turn on/off using lissojous figures to get points"}
78 };
79
80 ENTRYPOINT ModeSpecOpt drift_opts =
81 {sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
82
83 #ifdef USE_MODULES
84 ModStruct   drift_description =
85 {"drift", "init_drift", "draw_drift", "release_drift",
86  "refresh_drift", "init_drift", (char *) NULL, &drift_opts,
87  10000, 30, 1, 1, 64, 1.0, "",
88  "Shows cosmic drifting flame fractals", 0, NULL};
89
90 #endif
91
92 #define MAXBATCH1       200     /* mono */
93 #define MAXBATCH2       20      /* color */
94 #define FUSE            10      /* discard this many initial iterations */
95 #define NMAJORVARS      7
96 #define MAXLEV 10
97
98 typedef struct {
99         /* shape of current flame */
100         int         nxforms;
101         double      f[2][3][MAXLEV];    /* a bunch of non-homogeneous xforms */
102         int         variation[10];      /* for each xform */
103
104         /* Animation */
105         double      df[2][3][MAXLEV];
106
107         /* high-level control */
108         int         mode;       /* 0->slow/single 1->fast/many */
109         int         nfractals;  /* draw this many fractals */
110         int         major_variation;
111         int         fractal_len;        /* pts/fractal */
112         int         color;
113         int         rainbow;    /* more than one color per fractal
114                                    1-> computed by adding dimension to fractal */
115
116         int         width, height;      /* of window */
117         int         timer;
118
119         /* draw info about current flame */
120         int         fuse;       /* iterate this many before drawing */
121         int         total_points;       /* draw this many pts before fractal ends */
122         int         npoints;    /* how many we've computed but not drawn */
123         XPoint      pts[MAXBATCH1];     /* here they are */
124         unsigned long pixcol;
125         /* when drawing in color, we have a buffer per color */
126         int        *ncpoints;
127         XPoint     *cpts;
128
129         double      x, y, c;
130         int         liss_time;
131         Bool        grow, liss;
132
133         short       lasthalf;
134         long        saved_random_bits;
135         int         nbits;
136
137 #ifdef STANDALONE
138   int erase_countdown;
139   eraser_state *eraser;
140 #endif
141 } driftstruct;
142
143 static driftstruct *drifts = (driftstruct *) NULL;
144
145 static short
146 halfrandom(driftstruct * dp, int mv)
147 {
148         unsigned long r;
149
150         if (dp->lasthalf) {
151                 r = dp->lasthalf;
152                 dp->lasthalf = 0;
153         } else {
154                 r = LRAND();
155                 dp->lasthalf = (short) (r >> 16);
156         }
157         r = r % mv;
158         return r;
159 }
160
161 static int
162 frandom(driftstruct * dp, int n)
163 {
164         int         result;
165
166         if (3 > dp->nbits) {
167                 dp->saved_random_bits = LRAND();
168                 dp->nbits = 31;
169         }
170         switch (n) {
171                 case 2:
172                         result = (int) (dp->saved_random_bits & 1);
173                         dp->saved_random_bits >>= 1;
174                         dp->nbits -= 1;
175                         return result;
176
177                 case 3:
178                         result = (int) (dp->saved_random_bits & 3);
179                         dp->saved_random_bits >>= 2;
180                         dp->nbits -= 2;
181                         if (3 == result)
182                                 return frandom(dp, 3);
183                         return result;
184
185                 case 4:
186                         result = (int) (dp->saved_random_bits & 3);
187                         dp->saved_random_bits >>= 2;
188                         dp->nbits -= 2;
189                         return result;
190
191                 case 5:
192                         result = (int) (dp->saved_random_bits & 7);
193                         dp->saved_random_bits >>= 3;
194                         dp->nbits -= 3;
195                         if (4 < result)
196                                 return frandom(dp, 5);
197                         return result;
198                 default:
199                         (void) fprintf(stderr, "bad arg to frandom\n");
200         }
201         return 0;
202 }
203
204 #define DISTRIB_A (halfrandom(dp, 7000) + 9000)
205 #define DISTRIB_B ((frandom(dp, 3) + 1) * (frandom(dp, 3) + 1) * 120000)
206 #define LEN(x) (sizeof(x)/sizeof((x)[0]))
207
208 static void
209 initmode(ModeInfo * mi, int mode)
210 {
211         driftstruct *dp = &drifts[MI_SCREEN(mi)];
212
213 #define VARIATION_LEN 14
214
215         dp->mode = mode;
216
217         dp->major_variation = halfrandom(dp, VARIATION_LEN);
218         /*  0, 0, 1, 1, 2, 2, 3, 4, 4, 5, 5, 6, 6, 6 */
219         dp->major_variation = ((dp->major_variation >= VARIATION_LEN >> 1) &&
220                                (dp->major_variation < VARIATION_LEN - 1)) ?
221                 (dp->major_variation + 1) >> 1 : dp->major_variation >> 1;
222
223         if (dp->grow) {
224                 dp->rainbow = 0;
225                 if (mode) {
226                         if (!dp->color || halfrandom(dp, 8)) {
227                                 dp->nfractals = halfrandom(dp, 30) + 5;
228                                 dp->fractal_len = DISTRIB_A;
229                         } else {
230                                 dp->nfractals = halfrandom(dp, 5) + 5;
231                                 dp->fractal_len = DISTRIB_B;
232                         }
233                 } else {
234                         dp->rainbow = dp->color;
235                         dp->nfractals = 1;
236                         dp->fractal_len = DISTRIB_B;
237                 }
238         } else {
239                 dp->nfractals = 1;
240                 dp->rainbow = dp->color;
241                 dp->fractal_len = 2000000;
242         }
243         dp->fractal_len = (dp->fractal_len * MI_COUNT(mi)) / 20;
244
245 #ifndef STANDALONE
246         MI_CLEARWINDOW(mi);
247 #endif
248 }
249
250 static void
251 pick_df_coefs(ModeInfo * mi)
252 {
253         driftstruct *dp = &drifts[MI_SCREEN(mi)];
254         int         i, j, k;
255         double      r;
256
257         for (i = 0; i < dp->nxforms; i++) {
258
259                 r = 1e-6;
260                 for (j = 0; j < 2; j++)
261                         for (k = 0; k < 3; k++) {
262                                 dp->df[j][k][i] = ((double) halfrandom(dp, 1000) / 500.0 - 1.0);
263                                 r += dp->df[j][k][i] * dp->df[j][k][i];
264                         }
265                 r = (3 + halfrandom(dp, 5)) * 0.01 / sqrt(r);
266                 for (j = 0; j < 2; j++)
267                         for (k = 0; k < 3; k++)
268                                 dp->df[j][k][i] *= r;
269         }
270 }
271
272 static void
273 free_drift(driftstruct *dp)
274 {
275         if (dp->ncpoints != NULL) {
276                 (void) free((void *) dp->ncpoints);
277                 dp->ncpoints = (int *) NULL;
278         }
279         if (dp->cpts != NULL) {
280                 (void) free((void *) dp->cpts);
281                 dp->cpts = (XPoint *) NULL;
282         }
283 }
284
285 static void
286 initfractal(ModeInfo * mi)
287 {
288         driftstruct *dp = &drifts[MI_SCREEN(mi)];
289         int         i, j, k;
290
291 #define XFORM_LEN 9
292
293         dp->fuse = FUSE;
294         dp->total_points = 0;
295
296         if (!dp->ncpoints) {
297                 if ((dp->ncpoints = (int *) malloc(sizeof (int) * MI_NCOLORS(mi))) ==
298                         NULL) {
299                         free_drift(dp);
300                         return;
301                 }
302         }
303         if (!dp->cpts) {
304                 if ((dp->cpts = (XPoint *) malloc(MAXBATCH2 * sizeof (XPoint) *
305                          MI_NCOLORS(mi))) == NULL) {
306                         free_drift(dp);
307                         return;
308                 }
309         }
310
311         if (dp->rainbow)
312                 for (i = 0; i < MI_NPIXELS(mi); i++)
313                         dp->ncpoints[i] = 0;
314         else
315                 dp->npoints = 0;
316         dp->nxforms = halfrandom(dp, XFORM_LEN);
317         /* 2, 2, 2, 3, 3, 3, 4, 4, 5 */
318         dp->nxforms = (dp->nxforms >= XFORM_LEN - 1) + dp->nxforms / 3 + 2;
319
320         dp->c = dp->x = dp->y = 0.0;
321         if (dp->liss && !halfrandom(dp, 10)) {
322                 dp->liss_time = 0;
323         }
324         if (!dp->grow)
325                 pick_df_coefs(mi);
326         for (i = 0; i < dp->nxforms; i++) {
327                 if (NMAJORVARS == dp->major_variation)
328                         dp->variation[i] = halfrandom(dp, NMAJORVARS);
329                 else
330                         dp->variation[i] = dp->major_variation;
331                 for (j = 0; j < 2; j++)
332                         for (k = 0; k < 3; k++) {
333                                 if (dp->liss)
334                                         dp->f[j][k][i] = sin(dp->liss_time * dp->df[j][k][i]);
335                                 else
336                                         dp->f[j][k][i] = ((double) halfrandom(dp, 1000) / 500.0 - 1.0);
337                         }
338         }
339         if (dp->color)
340                 dp->pixcol = MI_PIXEL(mi, halfrandom(dp, MI_NPIXELS(mi)));
341         else
342                 dp->pixcol = MI_WHITE_PIXEL(mi);
343
344 }
345
346
347 ENTRYPOINT void
348 init_drift(ModeInfo * mi)
349 {
350         driftstruct *dp;
351
352         if (drifts == NULL) {
353                 if ((drifts = (driftstruct *) calloc(MI_NUM_SCREENS(mi),
354                                               sizeof (driftstruct))) == NULL)
355                         return;
356         }
357         dp = &drifts[MI_SCREEN(mi)];
358
359         dp->width = MI_WIDTH(mi);
360         dp->height = MI_HEIGHT(mi);
361         dp->color = MI_NPIXELS(mi) > 2;
362
363         if (MI_IS_FULLRANDOM(mi)) {
364                 if (NRAND(3) == 0)
365                         dp->grow = True;
366                 else {
367                         dp->grow = False;
368                         dp->liss = (Bool) (LRAND() & 1);
369                 }
370         } else {
371                 dp->grow = grow;
372                 if (dp->grow)
373                         dp->liss = False;
374                 else
375                         dp->liss = liss;
376         }
377         initmode(mi, 1);
378         initfractal(mi);
379 }
380
381 static void
382 iter(driftstruct * dp)
383 {
384         int         i = frandom(dp, dp->nxforms);
385         double      nx, ny, nc;
386
387
388         if (i)
389                 nc = (dp->c + 1.0) / 2.0;
390         else
391                 nc = dp->c / 2.0;
392
393         nx = dp->f[0][0][i] * dp->x + dp->f[0][1][i] * dp->y + dp->f[0][2][i];
394         ny = dp->f[1][0][i] * dp->x + dp->f[1][1][i] * dp->y + dp->f[1][2][i];
395
396
397         switch (dp->variation[i]) {
398                 case 1:
399                         /* sinusoidal */
400                         nx = sin(nx);
401                         ny = sin(ny);
402                         break;
403                 case 2:
404                         {
405                                 /* complex */
406                                 double      r2 = nx * nx + ny * ny + 1e-6;
407
408                                 nx = nx / r2;
409                                 ny = ny / r2;
410                                 break;
411                         }
412                 case 3:
413                         /* bent */
414                         if (nx < 0.0)
415                                 nx = nx * 2.0;
416                         if (ny < 0.0)
417                                 ny = ny / 2.0;
418                         break;
419                 case 4:
420                         {
421                                 /* swirl */
422
423                                 double      r = (nx * nx + ny * ny);    /* times k here is fun */
424                                 double      c1 = sin(r);
425                                 double      c2 = cos(r);
426                                 double      t = nx;
427
428                                 if (nx > 1e4 || nx < -1e4 || ny > 1e4 || ny < -1e4)
429                                         ny = 1e4;
430                                 else
431                                         ny = c2 * t + c1 * ny;
432                                 nx = c1 * nx - c2 * ny;
433                                 break;
434                         }
435                 case 5:
436                         {
437                                 /* horseshoe */
438                                 double      r, c1, c2, t;
439
440                                 /* Avoid atan2: DOMAIN error message */
441                                 if (nx == 0.0 && ny == 0.0)
442                                         r = 0.0;
443                                 else
444                                         r = atan2(nx, ny);      /* times k here is fun */
445                                 c1 = sin(r);
446                                 c2 = cos(r);
447                                 t = nx;
448
449                                 nx = c1 * nx - c2 * ny;
450                                 ny = c2 * t + c1 * ny;
451                                 break;
452                         }
453                 case 6:
454                         {
455                                 /* drape */
456                                 double      t;
457
458                                 /* Avoid atan2: DOMAIN error message */
459                                 if (nx == 0.0 && ny == 0.0)
460                                         t = 0.0;
461                                 else
462                                         t = atan2(nx, ny) / M_PI;
463
464                                 if (nx > 1e4 || nx < -1e4 || ny > 1e4 || ny < -1e4)
465                                         ny = 1e4;
466                                 else
467                                         ny = sqrt(nx * nx + ny * ny) - 1.0;
468                                 nx = t;
469                                 break;
470                         }
471         }
472
473 #if 0
474         /* here are some others */
475         {
476                 /* broken */
477                 if (nx > 1.0)
478                         nx = nx - 1.0;
479                 if (nx < -1.0)
480                         nx = nx + 1.0;
481                 if (ny > 1.0)
482                         ny = ny - 1.0;
483                 if (ny < -1.0)
484                         ny = ny + 1.0;
485                 break;
486         }
487         {
488                 /* complex sine */
489                 double      u = nx, v = ny;
490                 double      ev = exp(v);
491                 double      emv = exp(-v);
492
493                 nx = (ev + emv) * sin(u) / 2.0;
494                 ny = (ev - emv) * cos(u) / 2.0;
495         }
496         {
497
498                 /* polynomial */
499                 if (nx < 0)
500                         nx = -nx * nx;
501                 else
502                         nx = nx * nx;
503
504                 if (ny < 0)
505                         ny = -ny * ny;
506                 else
507                         ny = ny * ny;
508         }
509         {
510                 /* spherical */
511                 double      r = 0.5 + sqrt(nx * nx + ny * ny + 1e-6);
512
513                 nx = nx / r;
514                 ny = ny / r;
515         }
516         {
517                 nx = atan(nx) / M_PI_2
518                         ny = atan(ny) / M_PI_2
519         }
520 #endif
521
522         /* how to check nan too?  some machines don't have finite().
523            don't need to check ny, it'll propogate */
524         if (nx > 1e4 || nx < -1e4) {
525                 nx = halfrandom(dp, 1000) / 500.0 - 1.0;
526                 ny = halfrandom(dp, 1000) / 500.0 - 1.0;
527                 dp->fuse = FUSE;
528         }
529         dp->x = nx;
530         dp->y = ny;
531         dp->c = nc;
532
533 }
534
535 static void
536 draw(ModeInfo * mi, driftstruct * dp, Drawable d)
537 {
538         Display    *display = MI_DISPLAY(mi);
539         GC          gc = MI_GC(mi);
540         double      x = dp->x;
541         double      y = dp->y;
542         int         fixed_x, fixed_y, npix, c, n;
543
544         if (dp->fuse) {
545                 dp->fuse--;
546                 return;
547         }
548         if (!(x > -1.0 && x < 1.0 && y > -1.0 && y < 1.0))
549                 return;
550
551         fixed_x = (int) ((dp->width / 2) * (x + 1.0));
552         fixed_y = (int) ((dp->height / 2) * (y + 1.0));
553
554         if (!dp->rainbow) {
555
556                 dp->pts[dp->npoints].x = fixed_x;
557                 dp->pts[dp->npoints].y = fixed_y;
558                 dp->npoints++;
559                 if (dp->npoints == MAXBATCH1) {
560                         XSetForeground(display, gc, dp->pixcol);
561                         XDrawPoints(display, d, gc, dp->pts, dp->npoints, CoordModeOrigin);
562                         dp->npoints = 0;
563                 }
564         } else {
565
566                 npix = MI_NPIXELS(mi);
567                 c = (int) (dp->c * npix);
568
569                 if (c < 0)
570                         c = 0;
571                 if (c >= npix)
572                         c = npix - 1;
573                 n = dp->ncpoints[c];
574                 dp->cpts[c * MAXBATCH2 + n].x = fixed_x;
575                 dp->cpts[c * MAXBATCH2 + n].y = fixed_y;
576                 if (++dp->ncpoints[c] == MAXBATCH2) {
577                         XSetForeground(display, gc, MI_PIXEL(mi, c));
578                         XDrawPoints(display, d, gc, &(dp->cpts[c * MAXBATCH2]),
579                                     dp->ncpoints[c], CoordModeOrigin);
580                         dp->ncpoints[c] = 0;
581                 }
582         }
583 }
584
585 static void
586 draw_flush(ModeInfo * mi, driftstruct * dp, Drawable d)
587 {
588         Display    *display = MI_DISPLAY(mi);
589         GC          gc = MI_GC(mi);
590
591         if (dp->rainbow) {
592                 int         npix = MI_NPIXELS(mi);
593                 int         i;
594
595                 for (i = 0; i < npix; i++) {
596                         if (dp->ncpoints[i]) {
597                                 XSetForeground(display, gc, MI_PIXEL(mi, i));
598                                 XDrawPoints(display, d, gc, &(dp->cpts[i * MAXBATCH2]),
599                                             dp->ncpoints[i], CoordModeOrigin);
600                                 dp->ncpoints[i] = 0;
601                         }
602                 }
603         } else {
604                 if (dp->npoints)
605                         XSetForeground(display, gc, dp->pixcol);
606                 XDrawPoints(display, d, gc, dp->pts,
607                             dp->npoints, CoordModeOrigin);
608                 dp->npoints = 0;
609         }
610 }
611
612
613 ENTRYPOINT void
614 draw_drift(ModeInfo * mi)
615 {
616         Window      window = MI_WINDOW(mi);
617         driftstruct *dp;
618
619         if (drifts == NULL)
620                 return;
621         dp = &drifts[MI_SCREEN(mi)];
622         if (dp->ncpoints == NULL)
623                 return;
624
625     if (dp->erase_countdown) {
626       if (!--dp->erase_countdown) {
627         dp->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), dp->eraser);
628       }
629       return;
630     }
631     if (dp->eraser) {
632       dp->eraser = erase_window (MI_DISPLAY(mi), MI_WINDOW(mi), dp->eraser);
633       return;
634     }
635
636         MI_IS_DRAWN(mi) = True;
637         dp->timer = 3000;
638         while (dp->timer) {
639                 iter(dp);
640                 draw(mi, dp, window);
641                 if (dp->total_points++ > dp->fractal_len) {
642                         draw_flush(mi, dp, window);
643                         if (0 == --dp->nfractals) {
644 #ifdef STANDALONE
645               dp->erase_countdown = 4 * 1000000 / MI_PAUSE(mi);
646 #endif /* STANDALONE */
647                                 initmode(mi, frandom(dp, 2));
648                         }
649                         initfractal(mi);
650                 }
651                 dp->timer--;
652         }
653         if (!dp->grow) {
654                 int         i, j, k;
655
656                 draw_flush(mi, dp, window);
657                 if (dp->liss)
658                         dp->liss_time++;
659                 for (i = 0; i < dp->nxforms; i++)
660                         for (j = 0; j < 2; j++)
661                                 for (k = 0; k < 3; k++) {
662                                         if (dp->liss)
663                                                 dp->f[j][k][i] = sin(dp->liss_time * dp->df[j][k][i]);
664                                         else {
665                                                 double      t = dp->f[j][k][i] += dp->df[j][k][i];
666
667                                                 if (t < -1.0 || 1.0 < t)
668                                                         dp->df[j][k][i] *= -1.0;
669                                         }
670                                 }
671         }
672 }
673
674 ENTRYPOINT void
675 release_drift(ModeInfo * mi)
676 {
677         if (drifts != NULL) {
678                 int         screen;
679
680                 for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
681                         free_drift(&drifts[screen]);
682                 (void) free((void *) drifts);
683                 drifts = (driftstruct *) NULL;
684         }
685 }
686
687 ENTRYPOINT void
688 refresh_drift(ModeInfo * mi)
689 {
690         MI_CLEARWINDOW(mi);
691 }
692
693 XSCREENSAVER_MODULE ("Drift", drift)
694
695 #endif /* MODE_drift */