From http://www.jwz.org/xscreensaver/xscreensaver-5.35.tar.gz
[xscreensaver] / hacks / ripples.c
1 /* ripples, Copyright (c) 1999 Ian McConnell <ian@emit.demon.co.uk>
2  *
3  * Permission to use, copy, modify, distribute, and sell this software and its
4  * documentation for any purpose is hereby granted without fee, provided that
5  * the above copyright notice appear in all copies and that both that
6  * copyright notice and this permission notice appear in supporting
7  * documentation.  No representations are made about the suitability of this
8  * software for any purpose.  It is provided "as is" without express or
9  * implied warranty.
10  */
11
12 /*
13  * "Water" ripples that can cross and interfere with each other.
14  *
15  * I can't remember where I got this idea from, but it's been around for a
16  * while in various demos. Some inspiration from
17  *      water.txt by Tom Hammersley,tomh@globalnet.co.uk
18  *
19  * Options
20  * -delay       usleep every iteration
21  * -rate        Add one drop every "rate" iterations
22  * -box         Add big square splash every "box" iters (not very good)
23  * -water       Ripples on a grabbed background image
24  * -foreground  Interpolate ripples between these two colors
25  * -background
26  * -oily        Psychedelic colours like man
27  * -stir        Add a regular pattern of drops
28  * -fluidity    Between 0 and 16. 16 = big drops
29  * -light       Hack to add lighting effect
30  *
31  * Code mainly hacked from xflame and decayscreen.
32  */
33
34 /* Version history:
35  * 13 Oct 1999: Initial hack
36  * 30 Oct 1999: Speeded up graphics with dirty buffer. Returned to using
37  *              putpixel for greater portability
38  *              Added a variety of methods for splashing screen.
39  * 31 Oct 1999: Added in lighting hack
40  * 13 Nov 1999: Speed up tweaks
41  *              Adjust "light" for different bits per colour (-water only)
42  *
43  */
44
45 #include <math.h>
46 #include "screenhack.h"
47
48 typedef enum {ripple_drop, ripple_blob, ripple_box, ripple_stir} ripple_mode;
49
50 #ifdef HAVE_XSHM_EXTENSION
51 #include "xshm.h"
52 #endif /* HAVE_XSHM_EXTENSION */
53
54 #define TABLE 256
55
56 struct state {
57   Display *dpy;
58   Window window;
59   GC gc;
60   Visual *visual;
61
62   XImage *orig_map, *buffer_map;
63   int ctab[256];
64   Colormap colormap;
65   Screen *screen;
66   int ncolors;
67   int light;
68
69   int width, height; /* ripple size */
70   int bigwidth, bigheight; /* screen size */
71
72   Bool transparent;
73   short *bufferA, *bufferB, *temp;
74   char *dirty_buffer;
75
76   double cos_tab[TABLE];
77
78   Bool grayscale_p;
79
80   unsigned long rmask;  /* This builds on the warp effect by adding */
81   unsigned long gmask;  /* in a lighting effect: brighten pixels by an */
82   unsigned long bmask;  /* amount corresponding to the vertical gradient */
83
84   int rshift;
85   int gshift;
86   int bshift;
87
88   double stir_ang;
89
90   int draw_toggle;
91   int draw_count;
92
93   int iterations, delay, rate, box, oily, stir, fluidity;
94   int duration;
95   time_t start_time;
96
97   void (*draw_transparent) (struct state *st, short *src);
98
99   async_load_state *img_loader;
100
101 #ifdef HAVE_XSHM_EXTENSION
102   Bool use_shm;
103   XShmSegmentInfo shm_info;
104 #endif /* HAVE_XSHM_EXTENSION */
105 };
106
107
108 /* Distribution of drops: many little ones and a few big ones. */
109 static const double drop_dist[] =
110   {0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.2, 0.6};
111
112
113 /* How hard to hit the water */
114 #define SPLASH 512
115 #undef  MIN
116 #define MIN(x, y) ((x) < (y) ? (x) : (y))
117 #undef  MAX
118 #define MAX(x, y) ((x) > (y) ? (x) : (y))
119 #undef  DIRTY
120 #define DIRTY 3 /* dirty >= 2, 1 = restore original pixel, 0 = leave alone */
121
122 /* From fortune(6) */
123 /* -- really weird C code to count the number of bits in a word */
124 #define BITCOUNT(x)     (((BX_(x)+(BX_(x)>>4)) & 0x0F0F0F0F) % 255)
125 #define BX_(x)          ((x) - (((x)>>1)&0x77777777) \
126                              - (((x)>>2)&0x33333333) \
127                              - (((x)>>3)&0x11111111))
128
129
130 static unsigned long grayscale(struct state *st, unsigned long color);
131
132 /*      -------------------------------------------             */
133
134
135 static int
136 map_color(struct state *st, int grey)
137 {
138   /* Clip it */
139   grey = st->ncolors * abs(grey) / (SPLASH/4);
140   if (grey > st->ncolors)
141     grey = st->ncolors;
142
143   /* Display it */
144   return st->ctab[grey];
145 }
146
147
148 static void
149 draw_ripple(struct state *st, short *src)
150 {
151   int across, down;
152   char *dirty = st->dirty_buffer;
153
154   for (down = 0; down < st->height - 1; down++, src += 1, dirty += 1)
155     for (across = 0; across < st->width - 1; across++, src++, dirty++) {
156       int v1, v2, v3, v4;
157       v1 = (int)*src;
158       v2 = (int)*(src + 1);
159       v3 = (int)*(src + st->width);
160       v4 = (int)*(src + st->width + 1);
161       if ((v1 == 0 && v2 == 0 && v3 == 0 && v4 == 0)) {
162         if (*dirty > 0)
163           (*dirty)--;
164       } else
165         *dirty = DIRTY;
166
167       if (*dirty > 0) {
168         int dx;
169         if (st->light > 0) {
170           dx = ((v3 - v1) + (v4 - v2)) << st->light; /* light from top */
171         } else
172           dx = 0;
173         XPutPixel(st->buffer_map,(across<<1),  (down<<1),  map_color(st, dx + v1));
174         XPutPixel(st->buffer_map,(across<<1)+1,(down<<1),  map_color(st, dx + ((v1 + v2) >> 1)));
175         XPutPixel(st->buffer_map,(across<<1),  (down<<1)+1,map_color(st, dx + ((v1 + v3) >> 1)));
176         XPutPixel(st->buffer_map,(across<<1)+1,(down<<1)+1,map_color(st, dx + ((v1 + v4) >> 1)));
177       }
178     }
179 }
180
181
182 /*      -------------------------------------------             */
183
184
185 /* Uses the horizontal gradient as an offset to create a warp effect  */
186 static void
187 draw_transparent_vanilla(struct state *st, short *src)
188 {
189   int across, down, pixel;
190   char *dirty = st->dirty_buffer;
191
192   pixel = 0;
193   for (down = 0; down < st->height - 2; down++, pixel += 2)
194     for (across = 0; across < st->width-2; across++, pixel++) {
195       int gradx, grady, gradx1, grady1;
196       int x0, x1, x2, y1, y2;
197
198       x0 = src[pixel];
199       x1 = src[pixel + 1];
200       x2 = src[pixel + 2];
201       y1 = src[pixel + st->width];
202       y2 = src[pixel + 2*st->width];
203
204       gradx = (x1 - x0);
205       grady = (y1 - x0);
206       gradx1= (x2 - x1);
207       grady1= (y2 - y1);
208       gradx1 = 1 + (gradx + gradx1) / 2;
209       grady1 = 1 + (grady + grady1) / 2;
210
211       if ((2*across+MIN(gradx,gradx1) < 0) ||
212           (2*across+MAX(gradx,gradx1) >= st->bigwidth)) {
213         gradx = 0;
214         gradx1= 1;
215       }
216       if ((2*down+MIN(grady,grady1) < 0) ||
217           (2*down+MAX(grady,grady1) >= st->bigheight)) {
218         grady = 0;
219         grady1 = 1;
220       }
221
222       if ((gradx == 0 && gradx1 == 1 && grady == 0 && grady1 == 1)) {
223         if (dirty[pixel] > 0)
224           dirty[pixel]--;
225       } else
226         dirty[pixel] = DIRTY;
227
228       if (dirty[pixel] > 0) {
229         XPutPixel(st->buffer_map, (across<<1),  (down<<1),
230                   grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx, (down<<1) + grady)));
231         XPutPixel(st->buffer_map, (across<<1)+1,(down<<1),
232                   grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx1,(down<<1) + grady)));
233         XPutPixel(st->buffer_map, (across<<1),  (down<<1)+1,
234                   grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx, (down<<1) + grady1)));
235         XPutPixel(st->buffer_map, (across<<1)+1,(down<<1)+1,
236                   grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx1,(down<<1) + grady1)));
237       }
238     }
239 }
240
241
242 /*      -------------------------------------------             */
243
244
245 static void
246 set_mask(unsigned long color, unsigned long *mask, int *shift)
247 {
248   *shift = 0;
249   while (color != 0 && (color & 1) == 0) {
250     (*shift)++;
251     color >>= 1;
252   }
253   *mask = color;
254 }
255
256
257 static unsigned long
258 cadd(unsigned long color, int dx, unsigned long mask, int shift)
259 {
260   int x;
261   color >>= shift;
262   x = (color & mask);
263   x += dx;
264   if (x < 0) x = 0;
265   else if (x > (int)mask) x = mask;
266   color = x;
267   return color << shift;
268 }
269
270
271 static unsigned long
272 bright(struct state *st, int dx, unsigned long color)
273 {
274   return (cadd(color, dx, st->rmask, st->rshift) |
275           cadd(color, dx, st->gmask, st->gshift) |
276           cadd(color, dx, st->bmask, st->bshift));
277 }
278
279
280 static unsigned long
281 grayscale(struct state *st, unsigned long color)
282 {
283   int red;
284   int green;
285   int blue;
286   int total;
287   int gray_r;
288   int gray_g;
289   int gray_b;
290
291   if (!st->grayscale_p)
292     return color;
293   if (!st->transparent)
294     return color;
295   if ((st->rmask == 0) || (st->gmask == 0) || (st->bmask == 0))
296     return color;
297
298   red = ((color >> st->rshift) & st->rmask);
299   green =  ((color >> st->gshift) & st->gmask);
300   blue =  ((color >> st->bshift) & st->bmask);
301   total = red * st->gmask * st->bmask + green * st->rmask * st->bmask + blue * st->rmask * st->gmask;
302
303   gray_r = total / (3 * st->gmask * st->bmask);
304   if (gray_r < 0)
305     gray_r = 0;
306   if (gray_r > st->rmask)
307     gray_r = st->rmask;
308   
309   gray_g = total / (3 * st->rmask * st->bmask);
310   if (gray_g < 0)
311     gray_g = 0;
312   if (gray_g > st->gmask)
313     gray_g = st->gmask;
314
315   gray_b = total / (3 * st->rmask * st->gmask);
316   if (gray_b < 0)
317     gray_b = 0;
318   if (gray_b > st->bmask)
319     gray_b = st->bmask;
320
321   return ((unsigned long)
322           ((gray_r << st->rshift) | (gray_g << st->gshift) | (gray_b << st->bshift)));
323 }
324
325
326 static void
327 draw_transparent_light(struct state *st, short *src)
328 {
329   int across, down, pixel;
330   char *dirty = st->dirty_buffer;
331
332   pixel = 0;
333   for (down = 0; down < st->height - 2; down++, pixel += 2)
334     for (across = 0; across < st->width-2; across++, pixel++) {
335       int gradx, grady, gradx1, grady1;
336       int x0, x1, x2, y1, y2;
337
338       x0 = src[pixel];
339       x1 = src[pixel + 1];
340       x2 = src[pixel + 2];
341       y1 = src[pixel + st->width];
342       y2 = src[pixel + 2*st->width];
343
344       gradx = (x1 - x0);
345       grady = (y1 - x0);
346       gradx1= (x2 - x1);
347       grady1= (y2 - y1);
348       gradx1 = 1 + (gradx + gradx1) / 2;
349       grady1 = 1 + (grady + grady1) / 2;
350
351       if ((2*across+MIN(gradx,gradx1) < 0) ||
352           (2*across+MAX(gradx,gradx1) >= st->bigwidth)) {
353         gradx = 0;
354         gradx1= 1;
355       }
356       if ((2*down+MIN(grady,grady1) < 0) ||
357           (2*down+MAX(grady,grady1) >= st->bigheight)) {
358         grady = 0;
359         grady1 = 1;
360       }
361
362       if ((gradx == 0 && gradx1 == 1 && grady == 0 && grady1 == 1)) {
363         if (dirty[pixel] > 0)
364           dirty[pixel]--;
365       } else
366         dirty[pixel] = DIRTY;
367
368       if (dirty[pixel] > 0) {
369         int dx;
370
371         /* light from top */
372         if (4-st->light >= 0)
373           dx = (grady + (src[pixel+st->width+1]-x1)) >> (4-st->light);
374         else
375           dx = (grady + (src[pixel+st->width+1]-x1)) << (st->light-4);
376
377         if (dx != 0) {
378           XPutPixel(st->buffer_map, (across<<1),  (down<<1),
379                     bright(st, dx, grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx, (down<<1) + grady))));
380           XPutPixel(st->buffer_map, (across<<1)+1,(down<<1),
381                     bright(st, dx, grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx1,(down<<1) + grady))));
382           XPutPixel(st->buffer_map, (across<<1),  (down<<1)+1,
383                     bright(st, dx, grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx, (down<<1) + grady1))));
384           XPutPixel(st->buffer_map, (across<<1)+1,(down<<1)+1,
385                     bright(st, dx, grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx1,(down<<1) + grady1))));
386         } else {
387           /* Could use XCopyArea, but XPutPixel is faster */
388           XPutPixel(st->buffer_map, (across<<1),  (down<<1),
389                     grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx, (down<<1) + grady)));
390           XPutPixel(st->buffer_map, (across<<1)+1,(down<<1),
391                     grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx1,(down<<1) + grady)));
392           XPutPixel(st->buffer_map, (across<<1),  (down<<1)+1,
393                     grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx, (down<<1) + grady1)));
394           XPutPixel(st->buffer_map, (across<<1)+1,(down<<1)+1,
395                     grayscale(st, XGetPixel(st->orig_map, (across<<1) + gradx1,(down<<1) + grady1)));
396         }
397       }
398     }
399 }
400
401
402 /*      -------------------------------------------             */
403
404
405 #if 0
406 /* Doesn't go any faster and doesn't work at all colour depths */
407 static void
408 draw_transparent16l(short *src)
409 {
410   int across, down, bigpix, pixel;
411   char *dirty = st->dirty_buffer;
412   unsigned short *buffer, *orig;
413
414   buffer = (unsigned short *) st->buffer_map->data;
415   orig = (unsigned short *) st->orig_map->data;
416
417   for (pixel = bigpix = down = 0;
418        down < st->height - 2;
419        down++, pixel += 2, bigpix += st->bigwidth+4)
420     for (across = 0; across < st->width-2; across++, pixel++, bigpix+=2) {
421       int gradx, grady, gradx1, grady1;
422       int x0, x1, x2, y1, y2;
423
424       x0 = src[pixel];
425       x1 = src[pixel + 1];
426       x2 = src[pixel + 2];
427       y1 = src[pixel + st->width];
428       y2 = src[pixel + 2*st->width];
429
430       gradx = (x1 - x0);
431       grady = (y1 - x0);
432       gradx1= (x2 - x1);
433       grady1= (y2 - y1);
434       gradx1 = 1 + (gradx + gradx1) / 2;
435       grady1 = 1 + (grady + grady1) / 2;
436
437       if ((2*across+MIN(gradx,gradx1) < 0) ||
438           (2*across+MAX(gradx,gradx1) >= st->bigwidth)) {
439         gradx = 0;
440         gradx1= 1;
441       }
442       if ((2*down+MIN(grady,grady1) < 0) ||
443           (2*down+MAX(grady,grady1) >= st->bigheight)) {
444         grady = 0;
445         grady1 = 1;
446       }
447
448       if ((gradx == 0 && gradx1 == 1 && grady == 0 && grady1 == 1)) {
449         if (dirty[pixel] > 0)
450           dirty[pixel]--;
451       } else
452         dirty[pixel] = DIRTY;
453
454       if (dirty[pixel] > 0) {
455         unsigned short *dest = buffer + bigpix;
456         unsigned short *image = orig + bigpix;
457         int dx;
458
459         /* light from top */
460         if (4-st->light >= 0)
461           dx = (grady + (src[pixel+st->width+1]-x1)) >> (4-st->light);
462         else
463           dx = (grady + (src[pixel+st->width+1]-x1)) << (st->light-4);
464
465         grady *= st->bigwidth;
466         grady1*= st->bigwidth;
467
468         if (dx != 0) {
469           *dest++ = dobright(dx, *(image + gradx  + grady));
470           *dest   = dobright(dx, *(image + gradx1 + grady));
471           dest   += st->bigwidth - 1;
472           *dest++ = dobright(dx, *(image + gradx  + grady1));
473           *dest   = dobright(dx, *(image + gradx1 + grady1));
474         } else {
475           *dest++ = *(image + gradx  + grady);
476           *dest   = *(image + gradx1 + grady);
477           dest   += st->bigwidth - 1;
478           *dest++ = *(image + gradx  + grady1);
479           *dest   = *(image + gradx1 + grady1);
480         }
481       }
482     }
483 }
484 #endif
485
486
487 /*      -------------------------------------------             */
488
489
490 static void
491 setup_X(struct state *st)
492 {
493   XWindowAttributes xgwa;
494   int depth;
495
496   XGetWindowAttributes(st->dpy, st->window, &xgwa);
497   depth = xgwa.depth;
498   st->colormap = xgwa.colormap;
499   st->screen = xgwa.screen;
500   st->bigwidth = xgwa.width;
501   st->bigheight = xgwa.height;
502   st->visual = xgwa.visual;
503
504
505   /* This causes buffer_map to be 1 pixel taller and wider than orig_map,
506      which can cause the two XImages to have different bytes-per-line,
507      which causes stair-stepping.  So this better not be necessary...
508      -jwz, 23-Nov-01
509    */
510 #if 0 /* I'm not entirely sure if I need this */
511   if (st->bigwidth % 2)
512     st->bigwidth++;
513   if (st->bigheight % 2)
514     st->bigheight++;
515 #endif
516
517
518   st->width = st->bigwidth / 2;
519   st->height = st->bigheight / 2;
520
521   if (st->transparent) {
522     XGCValues gcv;
523     long gcflags;
524
525     gcv.function = GXcopy;
526     gcv.subwindow_mode = IncludeInferiors;
527
528     gcflags = GCFunction;
529     if (use_subwindow_mode_p(xgwa.screen, st->window))  /* see grabscreen.c */
530       gcflags |= GCSubwindowMode;
531
532     st->gc = XCreateGC(st->dpy, st->window, gcflags, &gcv);
533
534     st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
535                                               st->window, 0, 0);
536     st->start_time = time ((time_t *) 0);
537   } else {
538     XGCValues gcv;
539
540     st->gc = XCreateGC(st->dpy, st->window, 0, &gcv);
541     st->orig_map = 0;
542   }
543
544   if (!st->gc) {
545     fprintf(stderr, "XCreateGC failed\n");
546     exit(1);
547   }
548
549   st->buffer_map = 0;
550
551 #ifdef HAVE_XSHM_EXTENSION
552   if (st->use_shm) {
553     st->buffer_map = create_xshm_image(st->dpy, xgwa.visual, depth,
554                                    ZPixmap, 0, &st->shm_info, st->bigwidth, st->bigheight);
555     if (!st->buffer_map) {
556       st->use_shm = False;
557       fprintf(stderr, "create_xshm_image failed\n");
558     }
559   }
560 #endif /* HAVE_XSHM_EXTENSION */
561
562   if (!st->buffer_map) {
563     st->buffer_map = XCreateImage(st->dpy, xgwa.visual,
564                               depth, ZPixmap, 0, 0,
565                               st->bigwidth, st->bigheight, 8, 0);
566     st->buffer_map->data = (char *)
567       calloc(st->buffer_map->height, st->buffer_map->bytes_per_line);
568   }
569 }
570
571
572 static void
573 DisplayImage(struct state *st)
574 {
575 #ifdef HAVE_XSHM_EXTENSION
576   if (st->use_shm)
577     XShmPutImage(st->dpy, st->window, st->gc, st->buffer_map, 0, 0, 0, 0,
578                  st->bigwidth, st->bigheight, False);
579   else
580 #endif /* HAVE_XSHM_EXTENSION */
581     XPutImage(st->dpy, st->window, st->gc, st->buffer_map, 0, 0, 0, 0,
582               st->bigwidth, st->bigheight);
583 }
584
585
586 /*      -------------------------------------------             */
587
588
589 static int
590 cinterp(double a, int bg, int fg)
591 {
592   int result;
593   result = (int)((1-a) * bg + a * fg + 0.5);
594   if (result < 0) result = 0;
595   if (result > 255) result = 255;
596   return result;
597 }
598
599
600 /* Interpolate the ripple colours between the background colour and
601    foreground colour */
602 static void
603 init_linear_colors(struct state *st)
604 {
605   int i, j, red, green, blue, bred, bgreen, bblue;
606   XColor fg, bg;
607
608   if (st->ncolors < 2 || mono_p)
609     st->ncolors = 2;
610   if (st->ncolors <= 2)
611     mono_p = True;
612
613   /* Make it possible to set the color of the ripples,
614      Based on work by Raymond Medeiros <ray@stommel.marine.usf.edu> and jwz.
615    */
616   fg.pixel = get_pixel_resource(st->dpy, st->colormap, "foreground", "Foreground");
617   XQueryColor(st->dpy, st->colormap, &fg);
618   red = (fg.red >> 8);
619   green = (fg.green >> 8);
620   blue = (fg.blue >> 8);
621
622   bg.pixel = get_pixel_resource(st->dpy, st->colormap, "background", "Background");
623   XQueryColor(st->dpy, st->colormap, &bg);
624   bred = (bg.red >> 8);
625   bgreen = (bg.green >> 8);
626   bblue = (bg.blue >> 8);
627
628   j = 0;
629   for (i = 0; i < st->ncolors+1; i++) {
630     XColor xcl;
631     double a = (double)i / st->ncolors;
632     int r = cinterp(a, bred, red);
633     int g = cinterp(a, bgreen, green);
634     int b = cinterp(a, bblue, blue);
635
636     xcl.red = (unsigned short) ((r << 8) | r);
637     xcl.green = (unsigned short) ((g << 8) | g);
638     xcl.blue = (unsigned short) ((b << 8) | b);
639     xcl.flags = DoRed | DoGreen | DoBlue;
640
641     XAllocColor(st->dpy, st->colormap, &xcl);
642
643     st->ctab[j++] = (int) xcl.pixel;
644   }
645 }
646
647
648 static void
649 init_oily_colors(struct state *st)
650 {
651   XColor *colors = NULL;
652
653   if (st->ncolors < 2 || mono_p)
654     st->ncolors = 2;
655   if (st->ncolors <= 2)
656     mono_p = True;
657   colors = 0;
658
659   if (!mono_p) {
660     colors = (XColor *)malloc(sizeof(*colors) * (st->ncolors+1));
661     make_smooth_colormap(st->screen, st->visual, st->colormap,
662                          colors, &st->ncolors,
663                          True, /* allocate */
664                          False, /* not writable */
665                          True); /* verbose (complain about failure) */
666     if (st->ncolors <= 2) {
667       if (colors)
668         free (colors);
669       colors = 0;
670       mono_p = True;
671     }
672   }
673   if (!mono_p) {
674     int i, j = 0;
675     for (i = 0; i < st->ncolors+1; i++) {
676       XAllocColor(st->dpy, st->colormap, colors+i);
677       st->ctab[j++] = (int) colors[i].pixel;
678     }
679     free (colors);
680   } else {
681     st->ncolors = 2;
682     st->ctab[1] = get_pixel_resource(st->dpy, st->colormap, "foreground", "Foreground");
683     st->ctab[0] = get_pixel_resource(st->dpy, st->colormap, "background", "Background");
684   }
685 }
686
687
688 /*      -------------------------------------------             */
689
690
691 static void
692 init_cos_tab(struct state *st)
693 {
694   int i;
695   for (i = 0; i < TABLE; i++)
696     st->cos_tab[i] = cos(i * M_PI/2 / TABLE);
697 }
698
699
700 /* Shape of drop to add */
701 static double
702 sinc(struct state *st, double x)
703 {
704 #if 1
705   /* cosine hump */
706   int i;
707   i = (int)(x * TABLE + 0.5);
708   if (i >= TABLE) i = (TABLE-1) - (i-(TABLE-1));
709   if (i < 0) return 0.;
710   return st->cos_tab[i];
711 #elif 0
712   return cos(x * M_PI/2);
713 #else
714   if (fabs(x) < 0.1)
715     return 1 - x*x;
716   else
717     return sin(x) / x;
718 #endif
719 }
720
721
722 static void
723 add_circle_drop(struct state *st, int x, int y, int radius, int dheight)
724 {
725   int r, r2, cx, cy;
726   short *buf = (random()&1) ? st->bufferA : st->bufferB;
727
728   r2 = radius * radius;
729
730
731   for (cy = -radius; cy <= radius; cy++)
732     for (cx = -radius; cx <= radius; cx++) {
733       int xx = x+cx;
734       int yy = y+cy;
735       if (xx < 0 || yy < 0 || xx >= st->width || yy >= st->height) {break;}
736       r = cx*cx + cy*cy;
737       if (r > r2) break;
738       buf[xx + yy*st->width] =
739         (short)(dheight * sinc(st, (radius > 0) ? sqrt(r)/radius : 0));
740     }
741 }
742
743
744 static void
745 add_drop(struct state *st, ripple_mode mode, int drop)
746 {
747   int newx, newy, dheight;
748   int radius = MIN(st->width, st->height) / 50;
749   /* Don't put drops too near the edge of the screen or they get stuck */
750   int border = 8;
751
752   switch (mode) {
753   default:
754   case ripple_drop: {
755     int x;
756
757     dheight = 1 + (random() % drop);
758     newx = border + (random() % (st->width - 2*border));
759     newy = border + (random() % (st->height - 2*border));
760     x = newy * st->width + newx;
761     st->bufferA[x + 1] = st->bufferA[x] = st->bufferA[x + st->width] = st->bufferA[x + st->width + 1] =
762       st->bufferB[x + 1] = st->bufferB[x] = st->bufferB[x + st->width] = st->bufferB[x + st->width + 1] =
763       dheight;
764   }
765   break;
766   case ripple_blob: {
767     double power;
768
769     int tmp_i, tmp_j;
770     power = drop_dist[random() % (sizeof(drop_dist)/sizeof(drop_dist[0]))]; /* clumsy */
771     dheight = (int)(drop * (power + 0.01));
772     tmp_i = (int)(st->width - 2*border - 2*radius*power);
773     tmp_j = (int)(st->height - 2*border - 2*radius*power);
774     newx = radius + border + ((tmp_i > 0) ? random() % tmp_i : 0);
775     newy = radius + border + ((tmp_j > 0) ? random() % tmp_j : 0);
776     add_circle_drop(st, newx, newy, radius, dheight);
777   }
778   break;
779   /* Adding too many boxes too quickly (-box 1) doesn't give the waves time
780      to disperse and the waves build up (and overflow) */
781   case ripple_box: {
782     int x;
783     int cx, cy;
784     short *buf = (random()&1) ? st->bufferA : st->bufferB;
785     int tmp_i, tmp_j;
786
787     radius = (1 + (random() % 5)) * (1 + (random() % 5));
788     dheight = drop / 128;
789     if (random() & 1) dheight = -dheight;
790     tmp_i = st->width - 2*border - 2*radius;
791     tmp_j = st->height - 2*border - 2*radius;
792     newx = radius + border + ((tmp_i > 0) ? random() % tmp_i : 0);
793     newy = radius + border + ((tmp_j > 0) ? random() % tmp_j : 0);
794     x = newy * st->width + newx;
795     for (cy = -radius; cy <= radius; cy++)
796       for (cx = -radius; cx <= radius; cx++)
797         buf[x + cx + cy*st->width] = (short)(dheight);
798   }
799   break;
800   case ripple_stir: {
801     border += radius;
802     newx = border + (int)((st->width-2*border) * (1+cos(3*st->stir_ang)) / 2);
803     newy = border + (int)((st->height-2*border) * (1+sin(2*st->stir_ang)) / 2);
804     add_circle_drop(st, newx, newy, radius, drop / 10);
805     st->stir_ang += 0.02;
806     if (st->stir_ang > 12*M_PI) st->stir_ang = 0;
807   }
808   break;
809   }
810 }
811
812
813 static void
814 init_ripples(struct state *st, int ndrops, int splash)
815 {
816   int i;
817
818   st->bufferA = (short *)calloc(st->width * st->height, sizeof(*st->bufferA));
819   st->bufferB = (short *)calloc(st->width * st->height, sizeof(*st->bufferB));
820   st->temp = (short *)calloc(st->width * st->height, sizeof(*st->temp));
821
822   st->dirty_buffer = (char *)calloc(st->width * st->height, sizeof(*st->dirty_buffer));
823
824   for (i = 0; i < ndrops; i++)
825     add_drop(st, ripple_blob, splash);
826
827   if (st->transparent) {
828     if (st->grayscale_p)
829     {
830       int across, down;
831       for (down = 0; down < st->bigheight; down++)
832         for (across = 0; across < st->bigwidth; across++)
833           XPutPixel(st->buffer_map, across, down,
834                     grayscale(st, XGetPixel(st->orig_map, across, down)));
835     }
836     else
837     {  
838     /* There's got to be a better way of doing this  XCopyArea? */
839     memcpy(st->buffer_map->data, st->orig_map->data,
840            st->bigheight * st->buffer_map->bytes_per_line);
841     }
842   } else {
843     int across, down, color;
844
845     color = map_color(st, 0); /* background colour */
846     for (down = 0; down < st->bigheight; down++)
847       for (across = 0; across < st->bigwidth; across++)
848         XPutPixel(st->buffer_map,across,  down,  color);
849   }
850
851   DisplayImage(st);
852 }
853
854
855 /*
856  Explanation from hq_water.zip (Arturo R Montesinos (ARM) arami@fi.upm.es)
857
858  Differential equation is:  u  = a ( u  + u  )
859                              tt       xx   yy
860
861  Where a = tension * gravity / surface_density.
862
863  Approximating second derivatives by central differences:
864
865   [ u(t+1)-2u(t)+u(t-1) ] / dt = a [ u(x+1)+u(x-1)+u(y+1)+u(y-1)-4u ] / h
866
867  where dt = time step squared, h = dx*dy = mesh resolution squared.
868
869  From where u(t+1) may be calculated as:
870
871             dt  |   1   |                   dt
872  u(t+1) = a --  | 1 0 1 |u - u(t-1) + (2-4a --)u
873             h   |   1   |                    h
874
875  When a*dt/h = 1/2 last term vanishes, giving:
876
877                  1 |   1   |
878         u(t+1) = - | 1 0 1 |u - u(t-1)
879                  2 |   1   |
880
881  (note that u(t-1,x,y) is only used to calculate u(t+1,x,y) so
882   we can use the same array for both t-1 and t+1, needing only
883   two arrays, U[0] and U[1])
884
885  Dampening is simulated by subtracting 1/2^n of result.
886  n=4 gives best-looking result
887  n<4 (eg 2 or 3) thicker consistency, waves die out immediately
888  n>4 (eg 8 or 12) more fluid, waves die out slowly
889  */
890
891 static void
892 ripple(struct state *st)
893 {
894   int across, down, pixel;
895   short *src, *dest;
896
897   if (st->draw_toggle == 0) {
898     src = st->bufferA;
899     dest = st->bufferB;
900     st->draw_toggle = 1;
901   } else {
902     src = st->bufferB;
903     dest = st->bufferA;
904     st->draw_toggle = 0;
905   }
906
907   switch (st->draw_count) {
908   case 0: case 1:
909     pixel = 1 * st->width + 1;
910     for (down = 1; down < st->height - 1; down++, pixel += 2 * 1)
911       for (across = 1; across < st->width - 1; across++, pixel++) {
912         st->temp[pixel] =
913           (((src[pixel - 1] + src[pixel + 1] +
914              src[pixel - st->width] + src[pixel + st->width]) / 2)) - dest[pixel];
915       }
916
917     /* Smooth the output */
918     pixel = 1 * st->width + 1;
919     for (down = 1; down < st->height - 1; down++, pixel += 2 * 1)
920       for (across = 1; across < st->width - 1; across++, pixel++) {
921         if (st->temp[pixel] != 0) { /* Close enough for government work */
922           int damp =
923             (st->temp[pixel - 1] + st->temp[pixel + 1] +
924              st->temp[pixel - st->width] + st->temp[pixel + st->width] +
925              st->temp[pixel - st->width - 1] + st->temp[pixel - st->width + 1] +
926              st->temp[pixel + st->width - 1] + st->temp[pixel + st->width + 1] +
927              st->temp[pixel]) / 9;
928           dest[pixel] = damp - (damp >> st->fluidity);
929         } else
930           dest[pixel] = 0;
931       }
932     break;
933   case 2: case 3:
934     pixel = 1 * st->width + 1;
935     for (down = 1; down < st->height - 1; down++, pixel += 2 * 1)
936       for (across = 1; across < st->width - 1; across++, pixel++) {
937         int damp =
938           (((src[pixel - 1] + src[pixel + 1] +
939              src[pixel - st->width] + src[pixel + st->width]) / 2)) - dest[pixel];
940         dest[pixel] = damp - (damp >> st->fluidity);
941       }
942     break;
943   }
944   if (++st->draw_count > 3) st->draw_count = 0;
945
946   if (st->transparent)
947     st->draw_transparent(st, dest);
948   else
949     draw_ripple(st, dest);
950 }
951
952
953 /*      -------------------------------------------             */
954
955 static void *
956 ripples_init (Display *disp, Window win)
957 {
958   struct state *st = (struct state *) calloc (1, sizeof(*st));
959   st->dpy = disp;
960   st->window = win;
961   st->iterations = 0;
962   st->delay = get_integer_resource(disp, "delay", "Integer");
963   st->duration = get_integer_resource (st->dpy, "duration", "Seconds");
964   st->rate = get_integer_resource(disp, "rate", "Integer");
965   st->box = get_integer_resource(disp, "box", "Integer");
966   st->oily = get_boolean_resource(disp, "oily", "Boolean");
967   st->stir = get_boolean_resource(disp, "stir", "Boolean");
968   st->fluidity = get_integer_resource(disp, "fluidity", "Integer");
969   st->transparent = get_boolean_resource(disp, "water", "Boolean");
970   st->grayscale_p = get_boolean_resource(disp, "grayscale", "Boolean");
971 #ifdef HAVE_XSHM_EXTENSION
972   st->use_shm = get_boolean_resource(disp, "useSHM", "Boolean");
973 #endif /* HAVE_XSHM_EXTENSION */
974   st->light = get_integer_resource(disp, "light", "Integer");
975
976   if (st->delay < 0) st->delay = 0;
977   if (st->duration < 1) st->duration = 1;
978   if (st->fluidity <= 1) st->fluidity = 1;
979   if (st->fluidity > 16) st->fluidity = 16; /* 16 = sizeof(short) */
980   if (st->light < 0) st->light = 0;
981
982   init_cos_tab(st);
983   setup_X(st);
984
985   st->ncolors = get_integer_resource (disp, "colors", "Colors");
986   if (0 == st->ncolors)         /* English spelling? */
987     st->ncolors = get_integer_resource (disp, "colours", "Colors");
988
989   if (st->ncolors > sizeof(st->ctab)/sizeof(*st->ctab))
990     st->ncolors = sizeof(st->ctab)/sizeof(*st->ctab);
991
992   if (st->oily)
993     init_oily_colors(st);
994   else
995     init_linear_colors(st);
996
997   if (st->transparent && st->light > 0) {
998     int maxbits;
999     st->draw_transparent = draw_transparent_light;
1000     set_mask(st->visual->red_mask,   &st->rmask, &st->rshift);
1001     set_mask(st->visual->green_mask, &st->gmask, &st->gshift);
1002     set_mask(st->visual->blue_mask,  &st->bmask, &st->bshift);
1003     if (st->rmask == 0) st->draw_transparent = draw_transparent_vanilla;
1004
1005     /* Adjust the shift value "light" when we don't have 8 bits per colour */
1006     maxbits = MIN(MIN(BITCOUNT(st->rmask), BITCOUNT(st->gmask)), BITCOUNT(st->bmask));
1007     st->light -= 8-maxbits;
1008     if (st->light < 0) st->light = 0;
1009   } else {
1010     if (st->grayscale_p)
1011     { 
1012       set_mask(st->visual->red_mask,   &st->rmask, &st->rshift);
1013       set_mask(st->visual->green_mask, &st->gmask, &st->gshift);
1014       set_mask(st->visual->blue_mask,  &st->bmask, &st->bshift);
1015     }
1016     st->draw_transparent = draw_transparent_vanilla;
1017   }
1018   
1019   if (!st->transparent)
1020     init_ripples(st, 0, -SPLASH); /* Start off without any drops */
1021
1022   return st;
1023 }
1024
1025 static unsigned long
1026 ripples_draw (Display *dpy, Window window, void *closure)
1027 {
1028   struct state *st = (struct state *) closure;
1029
1030   if (st->img_loader)   /* still loading */
1031     {
1032       st->img_loader = load_image_async_simple (st->img_loader, 0, 0, 0, 0, 0);
1033       if (! st->img_loader) {  /* just finished */
1034         XWindowAttributes xgwa;
1035         XGetWindowAttributes(st->dpy, st->window, &xgwa);
1036         st->start_time = time ((time_t *) 0);
1037         st->orig_map = XGetImage (st->dpy, st->window, 0, 0, 
1038                                   xgwa.width, xgwa.height,
1039                                   ~0L, ZPixmap);
1040         init_ripples(st, 0, -SPLASH); /* Start off without any drops */
1041       }
1042       return st->delay;
1043     }
1044
1045     if (!st->img_loader &&
1046         st->start_time + st->duration < time ((time_t *) 0)) {
1047       XWindowAttributes xgwa;
1048       XGetWindowAttributes(st->dpy, st->window, &xgwa);
1049       st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
1050                                                 st->window, 0, 0);
1051       st->start_time = time ((time_t *) 0);
1052       return st->delay;
1053     }
1054
1055     if (st->rate > 0 && (st->iterations % st->rate) == 0)
1056       add_drop(st, ripple_blob, -SPLASH);
1057     if (st->stir)
1058       add_drop(st, ripple_stir, -SPLASH);
1059     if (st->box > 0 && (random() % st->box) == 0)
1060       add_drop(st, ripple_box, -SPLASH);
1061
1062     ripple(st);
1063     DisplayImage(st);
1064
1065     st->iterations++;
1066
1067     return st->delay;
1068 }
1069
1070
1071 static void
1072 ripples_reshape (Display *dpy, Window window, void *closure, 
1073                  unsigned int w, unsigned int h)
1074 {
1075 }
1076
1077 static Bool
1078 ripples_event (Display *dpy, Window window, void *closure, XEvent *event)
1079 {
1080   struct state *st = (struct state *) closure;
1081   if (screenhack_event_helper (dpy, window, event))
1082     {
1083       st->start_time = 0;
1084       return True;
1085     }
1086   return False;
1087 }
1088
1089 static void
1090 ripples_free (Display *dpy, Window window, void *closure)
1091 {
1092   struct state *st = (struct state *) closure;
1093   free (st);
1094 }
1095
1096 static const char *ripples_defaults[] =
1097 {
1098   ".background:         black",
1099   ".foreground:         #FFAF5F",
1100   "*colors:             200",
1101   "*dontClearRoot:      True",
1102   "*delay:              50000",
1103   "*duration:           120",
1104   "*rate:               5",
1105   "*box:                0",
1106   "*water:              True",
1107   "*oily:               False",
1108   "*stir:               False",
1109   "*fluidity:           6",
1110   "*light:              4",
1111   "*grayscale:          False",
1112 #ifdef HAVE_XSHM_EXTENSION
1113   "*useSHM: True",
1114 #else
1115   "*useSHM: False",
1116 #endif
1117 #ifdef HAVE_MOBILE
1118   "*ignoreRotation: True",
1119   "*rotateImages:   True",
1120 #endif
1121   0
1122 };
1123
1124 static XrmOptionDescRec ripples_options[] =
1125 {
1126   { "-colors",  ".colors",      XrmoptionSepArg, 0},
1127   { "-colours", ".colors",      XrmoptionSepArg, 0},
1128   {"-delay",    ".delay",       XrmoptionSepArg, 0},
1129   {"-duration", ".duration",    XrmoptionSepArg, 0 },
1130   {"-rate",     ".rate",        XrmoptionSepArg, 0},
1131   {"-box",      ".box",         XrmoptionSepArg, 0},
1132   {"-water",    ".water",       XrmoptionNoArg, "True"},
1133   {"-oily",     ".oily",        XrmoptionNoArg, "True"},
1134   {"-stir",     ".stir",        XrmoptionNoArg, "True"},
1135   {"-fluidity", ".fluidity",    XrmoptionSepArg, 0},
1136   {"-light",    ".light",       XrmoptionSepArg, 0},
1137   {"-grayscale",        ".grayscale",   XrmoptionNoArg, "True"},
1138   {"-shm",      ".useSHM",      XrmoptionNoArg, "True"},
1139   {"-no-shm",   ".useSHM",      XrmoptionNoArg, "False"},
1140   {0, 0, 0, 0}
1141 };
1142
1143
1144 XSCREENSAVER_MODULE ("Ripples", ripples)