http://www.jwz.org/xscreensaver/xscreensaver-5.13.tar.gz
[xscreensaver] / hacks / fuzzyflakes.c
1 /* fuzzyflakes, Copyright (c) 2004
2  *  Barry Dmytro <badcherry@mailc.net>
3  *
4  * ! 2004.06.10 21:05
5  * ! - Added support for resizing
6  * ! - Added a color scheme generation algorithm
7  * !    Thanks to <ZoeB> from #vegans@irc.blitzed.org
8  * ! - Added random color generation
9  * ! - Fixed errors in the xml config file
10  * ! - Cleaned up a few inconsistencies in the code
11  * ! - Changed the default color to #EFBEA5
12  *
13  * ! 2004.05.?? ??:??
14  * ! -original creation
15  *
16  * Permission to use, copy, modify, distribute, and sell this software and its
17  * documentation for any purpose is hereby granted without fee, provided that
18  * the above copyright notice appear in all copies and that both that
19  * copyright notice and this permission notice appear in supporting
20  * documentation.  No representations are made about the suitability of this
21  * software for any purpose.  It is provided "as is" without express or 
22  * implied warranty.
23  */
24
25 #include <math.h>
26 #include "screenhack.h"
27
28 /* I have need of 1/3 and 2/3 constants later on */
29 #define N1_3 0.3333333333
30 #define N2_3 0.6666666666
31
32 typedef struct _flake_var
33 {
34    double              Ticks;
35    double              XPos, YPos;
36    double              TrueX;
37    double              XOffset;
38    double              Angle;
39 } FlakeVariable;
40
41 /* Struct containing the atrributes to our flakes */
42 typedef struct _flake
43 {
44    Display *dpy;
45    Window window;
46
47    int                 Arms;
48    int                 Thickness;
49    int                 BorderThickness;
50    int                 Radius;
51    unsigned long       BordColor;
52    unsigned long       ForeColor;
53    unsigned long       BackColor;
54    Bool                RandomColors;
55    int                 Layers;
56    int                 Density;
57    int                 Delay;
58    int                 FallingSpeed;
59    struct _colors
60    {
61       char               *Fore;
62       char               *Bord;
63       char               *Back;
64    } Colors;
65 /* a dynamic array containing positions of all the flakes */
66    FlakeVariable    ***Flakes;
67    XGCValues           GCValues;
68    unsigned long       GCFlags;
69    GC                  GCVar;
70    XWindowAttributes   XGWA;
71    struct _dbevar
72    {
73       Bool                dbuf;
74       Pixmap              b, ba, bb;
75    } DB;
76 } Flake;
77
78 /*
79  *This gets the pixel resource for a color: #ffffff
80  */
81 static unsigned int
82 FuzzyFlakesColorResource(Flake *flake, char *Color)
83 {
84    XColor              color;
85
86    if (!XParseColor(flake->dpy, flake->XGWA.colormap, Color, &color))
87      {
88         fprintf(stderr, "%s: can't parse color %s", progname, Color);
89         return 0;
90      }
91    if (!XAllocColor(flake->dpy, flake->XGWA.colormap, &color))
92      {
93         fprintf(stderr, "%s: can't allocate color %s", progname, Color);
94         return 0;
95      }
96    return color.pixel;
97 }
98
99 /*
100  * This is a great color matching algorithm that I got from
101  * a friend of mine on #vegans@irc.blitzed.org
102  * She wrote it in PHP and I ported it over to C
103  * her site is http://beautifulfreak.net/
104  */
105 static int
106 FuzzyFlakesColorHelper(Flake *flake)
107 {
108    unsigned int        iR, iG, iB;
109    unsigned int        iR0, iG0, iB0;
110    unsigned int        iR1, iG1, iB1;
111    float               fR, fG, fB;
112    float               Max = 0, Min = 0, Lig, Sat;
113    float               Hue, Hue0, Hue1;
114    float               f1, f2;
115    float               fR0, fG0, fB0;
116    float               fR1, fG1, fB1;
117    float               nR0, nG0, nB0;
118    float               nR1, nG1, nB1;
119    XColor              color;
120
121    /* First convert from hex to dec */
122    /* while splitting up the RGB values */
123    if (!XParseColor(flake->dpy, flake->XGWA.colormap,
124                     flake->Colors.Back, &color))
125      {
126         fprintf(stderr, "%s: can't parse color %s", progname,
127                 flake->Colors.Back);
128         return 1;
129      }
130    iR = color.red   >> 8;
131    iG = color.green >> 8;
132    iB = color.blue  >> 8;
133
134    /* Convert from int to float */
135    fR = iR;
136    fG = iG;
137    fB = iB;
138
139    /* convert from 0-255 to 0-1 */
140    fR = fR / 255;
141    fG = fG / 255;
142    fB = fB / 255;
143
144    /* work out the lightness */
145    if (fR >= fG && fR >= fB)
146       Max = fR;
147    if (fG >= fR && fG >= fB)
148       Max = fG;
149    if (fB >= fR && fB >= fG)
150       Max = fB;
151
152    if (fR <= fG && fR <= fB)
153       Min = fR;
154    if (fG <= fR && fG <= fB)
155       Min = fG;
156    if (fB <= fR && fB <= fG)
157       Min = fB;
158
159    Lig = (Max + Min) / 2;
160
161    /* work out the saturation */
162    if (Max == Min)
163       Sat = 0;
164    else
165      {
166         if (Lig < 0.5)
167            Sat = (Max - Min) / (Max + Min);
168         else
169            Sat = (Max - Min) / (2 - Max - Min);
170      }
171
172    /*
173     * if our satration is too low we won't be
174     * able to see any objects
175     */
176    if (Sat < 0.03)
177      {
178         return 1;
179      }
180
181    /* work out the hue */
182    if (fR == Max)
183       Hue = (fG - fB) / (Max - Min);
184    else if (fG == Max)
185       Hue = 2 + (fB - fR) / (Max - Min);
186    else
187       Hue = 4 + (fR - fG) / (Max - Min);
188
189    Hue = Hue / 6;
190
191    /* fine two equidistant hues */
192    Hue0 = Hue + N1_3;
193    if (Hue0 > 1)
194       Hue0 = Hue0 - 1;
195    Hue1 = Hue0 + N1_3;
196    if (Hue1 > 1)
197       Hue1 = Hue1 - 1;
198
199    /* convert the colors into hex codes */
200    if (Lig < 0.5)
201       f2 = Lig * (1 + Sat);
202    else
203       f2 = (Lig + Sat) - (Lig * Sat);
204
205    f1 = (2 * Lig) - f2;
206
207    fR0 = (Hue0 + 1) / 3;
208    fR1 = (Hue1 + 1) / 3;
209    fG0 = Hue0;
210    fG1 = Hue1;
211    fB0 = (Hue0 - 1) / 3;
212    fB1 = (Hue1 - 1) / 3;
213
214    if (fR0 < 0)
215       fR0 = fR0 + 1;
216    if (fR0 > 1)
217       fR0 = fR0 - 1;
218    if (fG0 < 0)
219       fG0 = fG0 + 1;
220    if (fG0 > 1)
221       fG0 = fG0 - 1;
222    if (fB0 < 0)
223       fB0 = fB0 + 1;
224    if (fB0 > 1)
225       fB0 = fB0 - 1;
226
227    if (fR1 < 0)
228       fR1 = fR1 + 1;
229    if (fR1 > 1)
230       fR1 = fR1 - 1;
231    if (fG1 < 0)
232       fG1 = fG1 + 1;
233    if (fG1 > 1)
234       fG1 = fG1 - 1;
235    if (fB1 < 0)
236       fB1 = fB1 + 1;
237    if (fB1 > 1)
238       fB1 = fB1 - 1;
239
240    if (6 * fR0 < 1)
241       nR0 = f1 + (f2 - f1) * 6 * fR0;
242    else if (2 * fR0 < 1)
243       nR0 = f2;
244    else if (3 * fR0 < 2)
245       nR0 = f1 + (f2 - f1) * (N2_3 - fR0) * 6;
246    else
247       nR0 = f1;
248
249    if (6 * fG0 < 1)
250       nG0 = f1 + (f2 - f1) * 6 * fG0;
251    else if (2 * fG0 < 1)
252       nG0 = f2;
253    else if (3 * fG0 < 2)
254       nG0 = f1 + (f2 - f1) * (N2_3 - fG0) * 6;
255    else
256       nG0 = f1;
257
258    if (6 * fB0 < 1)
259       nB0 = f1 + (f2 - f1) * 6 * fB0;
260    else if (2 * fB0 < 1)
261       nB0 = f2;
262    else if (3 * fB0 < 2)
263       nB0 = f1 + (f2 - f1) * (N2_3 - fB0) * 6;
264    else
265       nB0 = f1;
266
267    if (6 * fR1 < 1)
268       nR1 = f1 + (f2 - f1) * 6 * fR1;
269    else if (2 * fR1 < 1)
270       nR1 = f2;
271    else if (3 * fR1 < 2)
272       nR1 = f1 + (f2 - f1) * (N2_3 - fR1) * 6;
273    else
274       nR1 = f1;
275
276    if (6 * fG1 < 1)
277       nG1 = f1 + (f2 - f1) * 6 * fG1;
278    else if (2 * fG1 < 1)
279       nG1 = f2;
280    else if (3 * fG1 < 2)
281       nG1 = f1 + (f2 - f1) * (N2_3 - fG1) * 6;
282    else
283       nG1 = f1;
284
285    if (6 * fB1 < 1)
286       nB1 = f1 + (f2 - f1) * 6 * fB1;
287    else if (2 * fB1 < 1)
288       nB1 = f2;
289    else if (3 * fB1 < 2)
290       nB1 = f1 + (f2 - f1) * (N2_3 - fB1) * 6;
291    else
292       nB1 = f1;
293
294    /* at last convert them to a hex string */
295    iR0 = nR0 * 255;
296    iG0 = nG0 * 255;
297    iB0 = nB0 * 255;
298
299    iR1 = nR1 * 255;
300    iG1 = nG1 * 255;
301    iB1 = nB1 * 255;
302
303    flake->Colors.Fore = malloc(sizeof(unsigned char) * 8);
304    flake->Colors.Bord = malloc(sizeof(unsigned char) * 8);
305
306    sprintf(flake->Colors.Fore, "#%02X%02X%02X", iR0, iG0, iB0);
307    sprintf(flake->Colors.Bord, "#%02X%02X%02X", iR1, iG1, iB1);
308
309    return 0;
310 }
311
312 static void
313 FuzzyFlakesInit(Flake *flake)
314 {
315    int                 i, j;
316    XWindowAttributes   xgwa;
317
318    XGetWindowAttributes(flake->dpy, flake->window, &xgwa);
319    flake->XGWA = xgwa;
320    flake->DB.b = flake->DB.ba = flake->DB.bb = 0;
321    flake->DB.dbuf = get_boolean_resource(flake->dpy, "doubleBuffer", "Boolean");
322
323 # ifdef HAVE_COCOA      /* Don't second-guess Quartz's double-buffering */
324    flake->DB.dbuf = False;
325 # endif
326
327    if (flake->DB.dbuf)
328      {
329         flake->DB.ba =
330            XCreatePixmap(flake->dpy, flake->window, xgwa.width, xgwa.height, xgwa.depth);
331         flake->DB.bb =
332            XCreatePixmap(flake->dpy, flake->window, xgwa.width, xgwa.height, xgwa.depth);
333         flake->DB.b = flake->DB.ba;
334      }
335    else
336      {
337         flake->DB.b = flake->window;
338      }
339
340    flake->Arms = get_integer_resource(flake->dpy, "arms", "Integer");
341    flake->Thickness = get_integer_resource(flake->dpy, "thickness", "Integer");
342    flake->BorderThickness = get_integer_resource(flake->dpy, "bthickness", "Integer");
343    flake->Radius = get_integer_resource(flake->dpy, "radius", "Integer");
344
345    flake->Density = get_integer_resource(flake->dpy, "density", "Integer");
346    flake->Layers = get_integer_resource(flake->dpy, "layers", "Integer");
347    flake->FallingSpeed = get_integer_resource(flake->dpy, "fallingspeed", "Integer");
348    flake->Delay = get_integer_resource(flake->dpy, "delay", "Integer");
349    if (flake->RandomColors == True)
350       flake->RandomColors = get_boolean_resource(flake->dpy, "randomColors", "Boolean");
351
352    if (flake->Delay < 0)
353       flake->Delay = 0;
354
355    if (!flake->Colors.Back)
356      {
357         flake->Colors.Back = get_string_resource(flake->dpy, "color", "Color");
358         if (!FuzzyFlakesColorResource(flake, flake->Colors.Back))
359           {
360              fprintf(stderr, " reverting to random\n");
361              flake->RandomColors = True;
362           }
363
364         if (flake->RandomColors)
365           {
366              if (flake->Colors.Back)
367                 free(flake->Colors.Back);
368              flake->Colors.Back = malloc(sizeof(unsigned char) * 8);
369              sprintf(flake->Colors.Back, "#%X%X%X%X%X%X", random() % 16,
370                      random() % 16, random() % 16, random() % 16, random() % 16,
371                      random() % 16);
372           }
373
374         /*
375          * Here we establish our colormap based on what is in
376          * flake->Colors.Back
377          */
378         if (FuzzyFlakesColorHelper(flake))
379           {
380              fprintf(stderr, " reverting to random\n");
381              if (flake->Colors.Back)
382                 free(flake->Colors.Back);
383              flake->Colors.Back = malloc(sizeof(unsigned char) * 8);
384              sprintf(flake->Colors.Back, "#%X%X%X%X%X%X", random() % 16,
385                      random() % 16, random() % 16, random() % 16, random() % 16,
386                      random() % 16);
387              FuzzyFlakesColorHelper(flake);
388           }
389
390         flake->ForeColor = FuzzyFlakesColorResource(flake, flake->Colors.Fore);
391         flake->BackColor = FuzzyFlakesColorResource(flake, flake->Colors.Back);
392         flake->BordColor = FuzzyFlakesColorResource(flake, flake->Colors.Bord);
393
394         flake->GCValues.foreground = flake->ForeColor;
395         flake->GCValues.background = flake->BackColor;
396         flake->RandomColors = False;
397      }
398
399    flake->GCValues.line_width = flake->Thickness;
400    flake->GCValues.cap_style = CapProjecting;
401    flake->GCValues.join_style = JoinMiter;
402    flake->GCFlags |= (GCLineWidth | GCCapStyle | GCJoinStyle);
403
404    flake->GCVar =
405       XCreateGC(flake->dpy, flake->window, flake->GCFlags,
406                 &flake->GCValues);
407
408    flake->Density = flake->XGWA.width / 200 * flake->Density;
409    flake->Flakes = malloc(sizeof(FlakeVariable **) * flake->Layers);
410    for (i = 1; i <= flake->Layers; i++)
411      {
412         flake->Flakes[i - 1] = malloc(sizeof(FlakeVariable *) * flake->Density);
413         for (j = 0; j < flake->Density; j++)
414           {
415              flake->Flakes[i - 1][j] = malloc(sizeof(FlakeVariable));
416              flake->Flakes[i - 1][j]->XPos = random() % flake->XGWA.width;
417              flake->Flakes[i - 1][j]->YPos = random() % flake->XGWA.height;
418              flake->Flakes[i - 1][j]->Angle = random() % 360 * (M_PI / 180);
419              flake->Flakes[i - 1][j]->Ticks = random() % 360;
420              flake->Flakes[i - 1][j]->XOffset = random() % flake->XGWA.height;
421           }
422      }
423 }
424
425 static void
426 FuzzyFlakesFreeFlake(Flake *flake)
427 {
428    int                 i, j;
429
430    for (i = 1; i <= flake->Layers; i++)
431      {
432         for (j = 0; j < flake->Density; j++)
433           {
434              free(flake->Flakes[i - 1][j]);
435           }
436         free(flake->Flakes[i - 1]);
437      }
438
439    if (flake->DB.bb) XFreePixmap(flake->dpy, flake->DB.bb);
440    if (flake->DB.ba) XFreePixmap(flake->dpy, flake->DB.ba);
441 }
442
443 static void
444 FuzzyFlakesMove(Flake *flake)
445 {
446    int                 i, j;
447
448    for (i = 1; i <= flake->Layers; i++)
449      {
450         for (j = 0; j < flake->Density; j++)
451           {
452              FlakeVariable      *FlakeVar;
453
454              FlakeVar = flake->Flakes[i - 1][j];
455              FlakeVar->Ticks++;
456              FlakeVar->YPos =
457                 FlakeVar->YPos + ((double)flake->FallingSpeed) / 10 / i;
458              FlakeVar->TrueX =
459                 (sin
460                  (FlakeVar->XOffset +
461                   FlakeVar->Ticks * (M_PI / 180) * ((double)flake->FallingSpeed /
462                                                     10))) * 10 + FlakeVar->XPos;
463              FlakeVar->Angle =
464                 FlakeVar->Angle + 0.005 * ((double)flake->FallingSpeed / 10);
465              if (FlakeVar->YPos - flake->Radius > flake->XGWA.height)
466                {
467                   FlakeVar->Ticks = 0;
468                   FlakeVar->YPos = 0 - flake->Radius;
469                }
470           }
471      }
472 }
473
474 static void
475 FuzzyFlakesDrawFlake(Flake *flake, int XPos, int YPos, double AngleOffset, int Layer)
476 {
477    int                 i;
478    double              x, y, Angle, Radius;
479
480    /* calculate the shrink factor debending on which layer we are drawing atm */
481    Radius = (double)(flake->Radius - Layer * 5);
482    /* draw the flake one arm at a time */
483    for (i = 1; i <= flake->Arms; i++)
484      {
485         int                 Diameter;
486
487         Diameter = (flake->BorderThickness * 2 + flake->Thickness) / Layer;
488         /* compute the angle of this arm of the flake */
489         Angle = ((2 * M_PI) / flake->Arms) * i + AngleOffset;
490         /* calculate the x and y dispositions for this arm */
491         y = (int)(sin(Angle) * Radius);
492         x = (int)(cos(Angle) * Radius);
493         /* draw the base for the arm */
494         flake->GCValues.line_width = Diameter;
495         XFreeGC(flake->dpy, flake->GCVar);
496         flake->GCVar =
497            XCreateGC(flake->dpy, flake->DB.b, flake->GCFlags,
498                      &flake->GCValues);
499         XSetForeground(flake->dpy, flake->GCVar, flake->BordColor);
500         XDrawLine(flake->dpy, flake->DB.b, flake->GCVar, XPos, YPos,
501                   XPos + x, YPos + y);
502      }
503    /* draw the flake one arm at a time */
504    for (i = 1; i <= flake->Arms; i++)
505      {
506         /* compute the angle of this arm of the flake */
507         Angle = ((2 * M_PI) / flake->Arms) * i + AngleOffset;
508         /* calculate the x and y dispositions for this arm */
509         y = (int)(sin(Angle) * Radius);
510         x = (int)(cos(Angle) * Radius);
511         /* draw the inside of the arm */
512         flake->GCValues.line_width = flake->Thickness / Layer;
513         XFreeGC(flake->dpy, flake->GCVar);
514         flake->GCVar =
515            XCreateGC(flake->dpy, flake->DB.b, flake->GCFlags,
516                      &flake->GCValues);
517         XSetForeground(flake->dpy, flake->GCVar, flake->ForeColor);
518         XDrawLine(flake->dpy, flake->DB.b, flake->GCVar, XPos, YPos,
519                   XPos + x, YPos + y);
520      }
521 }
522
523 static void
524 FuzzyFlakes(Flake *flake)
525 {
526    int                 i, j;
527
528    FuzzyFlakesMove(flake);
529    XSetForeground(flake->dpy, flake->GCVar, flake->BackColor);
530    XFillRectangle(flake->dpy, flake->DB.b, flake->GCVar, 0, 0,
531                   flake->XGWA.width, flake->XGWA.height);
532    for (i = flake->Layers; i >= 1; i--)
533      {
534         for (j = 0; j < flake->Density; j++)
535           {
536              FuzzyFlakesDrawFlake(flake,
537                                   flake->Flakes[i - 1][j]->TrueX,
538                                   flake->Flakes[i - 1][j]->YPos,
539                                   flake->Flakes[i - 1][j]->Angle, i);
540           }
541      }
542
543 }
544
545 static void *
546 fuzzyflakes_init (Display *dpy, Window window)
547 {
548    Flake *flake = (Flake *) calloc (1, sizeof(*flake));
549    flake->dpy = dpy;
550    flake->window = window;
551
552    /* This is needed even if it is going to be set to false */
553    flake->RandomColors = True;
554
555    /* set up our colors amoung many other things */
556    FuzzyFlakesInit(flake);
557
558    return flake;
559 }
560
561 static unsigned long
562 fuzzyflakes_draw (Display *dpy, Window window, void *closure)
563 {
564   Flake *flake = (Flake *) closure;
565
566   FuzzyFlakes(flake);
567   if (flake->DB.dbuf)
568     {
569       XCopyArea(flake->dpy, flake->DB.b, flake->window,
570                 flake->GCVar, 0, 0, flake->XGWA.width, flake->XGWA.height,
571                 0, 0);
572       flake->DB.b =
573         (flake->DB.b == flake->DB.ba ? flake->DB.bb : flake->DB.ba);
574     }
575
576   return flake->Delay;
577 }
578
579 static void
580 fuzzyflakes_reshape (Display *dpy, Window window, void *closure, 
581                  unsigned int w, unsigned int h)
582 {
583   Flake *flake = (Flake *) closure;
584
585   if (flake->XGWA.width != w || flake->XGWA.height != h)
586     {
587       FuzzyFlakesFreeFlake(flake);
588       FuzzyFlakesInit(flake);
589     }
590 }
591
592 static Bool
593 fuzzyflakes_event (Display *dpy, Window window, void *closure, XEvent *event)
594 {
595   return False;
596 }
597
598 static void
599 fuzzyflakes_free (Display *dpy, Window window, void *closure)
600 {
601   Flake *flake = (Flake *) closure;
602   FuzzyFlakesFreeFlake(flake);
603   free(flake);
604 }
605
606
607 static const char *fuzzyflakes_defaults[] = {
608    "*color:     #efbea5",
609    "*arms:      5",
610    "*thickness: 10",
611    "*bthickness:        3",
612    "*radius:    20",
613    "*layers:    3",
614    "*density:   5",
615    "*fallingspeed:      10",
616    "*delay:     10000",
617    "*doubleBuffer:      True",
618    "*randomColors:      False",
619    0
620 };
621
622 static XrmOptionDescRec fuzzyflakes_options[] = {
623    { "-color", ".color", XrmoptionSepArg, 0},
624    { "-arms", ".arms", XrmoptionSepArg, 0},
625    { "-thickness", ".thickness", XrmoptionSepArg, 0},
626    { "-bthickness", ".bthickness", XrmoptionSepArg, 0},
627    { "-radius", ".radius", XrmoptionSepArg, 0},
628    { "-layers", ".layers", XrmoptionSepArg, 0},
629    { "-density", ".density", XrmoptionSepArg, 0},
630    { "-speed", ".fallingspeed", XrmoptionSepArg, 0},
631    { "-delay", ".delay", XrmoptionSepArg, 0},
632    { "-db", ".doubleBuffer", XrmoptionNoArg, "True"},
633    { "-no-db", ".doubleBuffer", XrmoptionNoArg, "False"},
634    { "-random-colors", ".randomColors", XrmoptionNoArg, "True"},
635    { 0, 0, 0, 0}
636 };
637
638
639 XSCREENSAVER_MODULE ("FuzzyFlakes", fuzzyflakes)