http://www.jwz.org/xscreensaver/xscreensaver-5.10.tar.gz
[xscreensaver] / hacks / fireworkx.c
1 /*
2  * Fireworkx 1.6 - pyrotechnics simulation program (XScreensaver version)
3  * Copyright (c) 1999-2007 Rony B Chandran <ronybc@asia.com>
4  *
5  * From Kerala, INDIA
6  * 
7  * url: http://www.ronybc.8k.com
8  *
9  * Permission to use, copy, modify, distribute, and sell this software and its
10  * documentation for any purpose is hereby granted without fee, provided that
11  * the above copyright notice appear in all copies and that both that
12  * copyright notice and this permission notice appear in supporting
13  * documentation.  No representations are made about the suitability of this
14  * software for any purpose.  It is provided "as is" without express or 
15  * implied warranty.
16  *
17  * Additional programming: 
18  * ------------------------
19  * Support for different dpy color modes: 
20  * Jean-Pierre Demailly <Jean-Pierre.Demailly@ujf-grenoble.fr>
21  *
22  * Fixed array access problems by beating on it with a large hammer.
23  * Nicholas Miell <nmiell@gmail.com>
24  *
25  * Freed 'free'ing up of memory by adding the forgotten 'XSync's
26  * Renuka S <renuka@local.net>
27  *
28  */
29
30 #include <math.h>
31 #include "screenhack.h"
32
33 #define FWXVERSION "1.6"
34
35 #define SHELLCOUNT 3                   /* 3 ; see light() before changing this value */
36 #define PIXCOUNT 500                   /* 500     */
37 #define POWER 5                        /* 5       */
38 #define FTWEAK 12                      /* 12      */
39
40 #if HAVE_X86_MMX
41 void mmx_blur(char *a, int b, int c, int d); 
42 void mmx_glow(char *a, int b, int c, int d, char *e);
43 #endif
44
45 #define rnd(x) ((x) ? (int)(random() % (x)) : 0)
46
47 typedef struct {
48   unsigned int burn;
49   float x;
50   float y;
51   float xv;
52   float yv;}firepix;
53
54 typedef struct {
55   unsigned int cx,cy;
56   unsigned int life;
57   unsigned int color;
58   unsigned int special;
59   unsigned int cshift;
60   unsigned int vgn,shy;
61   float air,flash;
62   firepix *fpix; }fireshell;
63
64 struct state {
65   Display *dpy;
66   Window window;
67
68   fireshell *fshell, *ffshell;
69   GC gc;
70
71   int depth;
72   int bigendian;
73   Bool flash_on;
74   Bool glow_on;
75   Bool verbose;
76   Bool shoot;
77   int width;
78   int height;
79   int rndlife;
80   int minlife;
81   int delay;
82   float flash_fade;
83   unsigned char *palaka1;
84   unsigned char *palaka2;
85   XImage *xim;
86   XColor *colors;
87   int ncolors;
88 };
89
90 static int explode(struct state *st, fireshell *fs)
91 {
92   float air,adg = 0.001;         /* gravity */
93   unsigned int n,c;
94   unsigned int h = st->height;
95   unsigned int w = st->width;
96   unsigned int *prgb;
97   unsigned char *palaka = st->palaka1;
98   firepix *fp = fs->fpix;
99   if(fs->vgn){
100     if(--fs->cy == fs->shy){  
101       fs->vgn   = 0;
102       fs->flash = rnd(30000)+25000;
103       fs->flash = fs->flash*fs->flash; }
104     else{  
105       fs->flash = 200000+(fs->cy - fs->shy)*(fs->cy - fs->shy)*8;
106       prgb=(unsigned int *)(palaka + (fs->cy * w + fs->cx + rnd(5)-2)*4);
107      *prgb=(rnd(8)+8)*0x000f0f10;
108       return(1);}}    
109   if(fs->cshift) --fs->cshift;
110   if((fs->cshift+1)%50==0) fs->color = ~fs->color;
111   c = fs->color;
112   air = fs->air;
113   fs->flash *= st->flash_fade;
114   for(n=PIXCOUNT;n;n--){
115   if(fp->burn){ --fp->burn; 
116   if(fs->special){
117   fp->x += fp->xv = fp->xv * air + (float)(rnd(200)-100)/2000;
118   fp->y += fp->yv = fp->yv * air + (float)(rnd(200)-100)/2000+ adg;}
119   else{
120   fp->x += fp->xv = fp->xv * air + (float)(rnd(200)-100)/20000;
121   fp->y += fp->yv = fp->yv * air + (float)(rnd(200)-100)/40000+ adg; }
122   if(fp->y > h){
123   if(rnd(5)==3) {fp->yv *= -0.24; fp->y = h;}
124   else fp->burn=0;} /* touch muddy ground :) */
125   if(fp->x < w && fp->x > 0 && fp->y < h && fp->y > 0){
126      prgb = (unsigned int *)(palaka + ((int)fp->y * w + (int)fp->x)*4);
127     *prgb = c; }
128   } fp++;
129   } return(--fs->life); }
130
131 static void recycle(struct state *st, fireshell *fs,int x,int y)
132 {
133   unsigned int n,pixlife;
134   firepix *fp = fs->fpix;
135   fs->vgn = st->shoot;
136   fs->shy = y;
137   fs->cx = x;
138   fs->cy = st->shoot ? st->height : y ;
139   fs->color = (rnd(155)+100) <<16 |
140               (rnd(155)+100) <<8  |
141                rnd(255);
142   fs->life = rnd(st->rndlife)+st->minlife;
143   fs->air  = 1-(float)(rnd(200))/10000;
144   fs->flash   = rnd(30000)+25000;       /*  million jouls...              */
145   fs->flash   = fs->flash*fs->flash;
146   fs->cshift  = !rnd(5) ? 120:0; 
147   fs->special = !rnd(10) ? 1:0; 
148   if(st->verbose)
149   printf("recycle(): color = %x air = %f life = %d \n",fs->color,fs->air,fs->life);
150   pixlife = rnd(fs->life)+fs->life/10+1;    /* ! */
151   for(n=0;n<PIXCOUNT;n++){
152   fp->burn = rnd(pixlife)+32;
153   fp->xv = POWER*(float)(rnd(20000)-10000)/10000;
154   fp->yv = sqrt(POWER*POWER - fp->xv * fp->xv) *
155                (float)(rnd(20000)-10000)/10000;
156   fp->x = x;
157   fp->y = y; 
158   fp++;             }}
159
160 static void glow(struct state *st)
161 {
162   unsigned int n,q;
163   unsigned int w = st->width;
164   unsigned int h = st->height;
165   unsigned char *pa, *pb, *pm, *po;
166   if (!st->xim) return;
167   pm = st->palaka1;
168   po = st->palaka2;
169   for(n=0;n<w*4;n++) 
170   {pm[n]=0; po[n]=0;}    /* clean first line */
171   pm+=n; po+=n; h-=2; 
172   pa = pm-(w*4);
173   pb = pm+(w*4);
174   for(n=4;n<w*h*4-4;n++){
175   q    = pm[n-4] + (pm[n]*8) + pm[n+4] + 
176          pa[n-4] + pa[n] + pa[n+4] + 
177          pb[n-4] + pb[n] + pb[n+4];
178   q    -= q>8 ? 8:q;
179   pm[n] = q>>4;
180   q     = q>>3;
181   po[n] = q>255 ? 255 : q;}
182   pm+=n; po+=n;
183   for(n=0;n<w*4;n++)
184   {pm[n]=0; po[n]=0;}}   /* clean last line */
185
186 static void blur(struct state *st)
187 {
188   unsigned int n,q;
189   unsigned int w = st->width;
190   unsigned int h = st->height;
191   unsigned char *pa, *pb, *pm;
192   pm = st->palaka1;
193   pm += w*4; h-=2;  /* line 0&h */
194   pa = pm-(w*4);
195   pb = pm+(w*4);
196   for(n=4;n<w*h*4-4;n++){
197   q    = pm[n-4] + (pm[n]*8) + pm[n+4] + 
198          pa[n-4] + pa[n] + pa[n+4] + 
199          pb[n-4] + pb[n] + pb[n+4];
200   q    -= q>8 ? 8:q;
201   pm[n] = q>>4;}
202   pm += n-4;    /* last line */
203   for(n=0;n<w*4+4;n++) pm[n]=0;
204   pm = st->palaka1; /* first line */
205   for(n=0;n<w*4+4;n++) pm[n]=pm[n+w*4]; }
206
207 static void light_2x2(struct state *st, fireshell *fss)
208 {
209   unsigned int l,t,x,y;
210   float s;
211   int w = st->width;
212   int h = st->height;
213   unsigned char *dim = st->palaka2;
214   unsigned char *sim = st->palaka1;
215   int nl = w*4;
216   fireshell *f;
217   if(st->glow_on) sim=dim;
218   for(y=0;y<h;y+=2){
219   for(x=0;x<w;x+=2){
220   f = fss;
221
222 /* Note: The follwing loop is unrolled for speed.
223          check this before changing the value of SHELLCOUNT
224   s = 0;
225   for(n=SHELLCOUNT;n;n--,f++){
226   s += f->flash/(1+(f->cx - x)*(f->cx - x)+(f->cy - y)*(f->cy - y));} */
227
228   s  = f->flash/(1+(f->cx - x)*(f->cx - x)+(f->cy - y)*(f->cy - y));
229   f++;
230   s += f->flash/(1+(f->cx - x)*(f->cx - x)+(f->cy - y)*(f->cy - y));
231   f++;
232   s += f->flash/(1+(f->cx - x)*(f->cx - x)+(f->cy - y)*(f->cy - y));
233
234   l = sqrtf(s);
235
236   t = l + sim[0];
237   dim[0] = (t > 255 ? 255 : t); 
238   t = l + sim[1];
239   dim[1] = (t > 255 ? 255 : t);
240   t = l + sim[2];
241   dim[2] = (t > 255 ? 255 : t);
242
243   t = l + sim[4];
244   dim[4] = (t > 255 ? 255 : t);
245   t = l + sim[5];
246   dim[5] = (t > 255 ? 255 : t);
247   t = l + sim[6];
248   dim[6] = (t > 255 ? 255 : t);
249
250   t = l + sim[nl+0];
251   dim[nl+0] = (t > 255 ? 255 : t);
252   t = l + sim[nl+1];
253   dim[nl+1] = (t > 255 ? 255 : t);
254   t = l + sim[nl+2];
255   dim[nl+2] = (t > 255 ? 255 : t);
256
257   t = l + sim[nl+4];
258   dim[nl+4] = (t > 255 ? 255 : t);
259   t = l + sim[nl+5];
260   dim[nl+5] = (t > 255 ? 255 : t);
261   t = l + sim[nl+6];
262   dim[nl+6] = (t > 255 ? 255 : t);
263
264   sim += 8; dim += 8; } sim += nl; dim += nl;}}
265
266 static void resize(struct state *st)
267 {
268   XWindowAttributes xwa;
269   XGetWindowAttributes (st->dpy, st->window, &xwa);
270   xwa.width  -= xwa.width % 2;
271   xwa.height -= xwa.height % 2;
272   if(xwa.height != st->height || xwa.width != st->width) {
273   st->width  = xwa.width;
274   st->height = xwa.height;
275   if (st->verbose)
276   printf("sky size: %dx%d ------------------------------\n",st->width,st->height);
277   if (st->xim) {
278   if (st->xim->data==(char *)st->palaka2) st->xim->data=NULL;  
279   XDestroyImage(st->xim);
280   if (st->palaka2!=st->palaka1) free(st->palaka2 - 8);
281   free(st->palaka1 - 8); 
282   }
283   st->palaka1 = NULL;
284   st->palaka2 = NULL;
285   st->xim = XCreateImage(st->dpy, xwa.visual, xwa.depth, ZPixmap, 0, 0,
286                      st->width, st->height, 8, 0);
287   if (!st->xim) return;
288   st->palaka1 = (unsigned char *) calloc(st->xim->height+1,st->xim->width*4) + 8;
289   if(st->flash_on|st->glow_on)
290   st->palaka2 = (unsigned char *) calloc(st->xim->height+1,st->xim->width*4) + 8;
291   else
292   st->palaka2 = st->palaka1;
293   if (st->depth>=24)
294   st->xim->data = (char *)st->palaka2;
295   else
296   st->xim->data = calloc(st->xim->height,st->xim->bytes_per_line); }}
297
298 static void put_image(struct state *st)
299 {
300   int x,y,i,j;
301   unsigned char r, g, b;
302   if (!st->xim) return;
303   i = 0;
304   j = 0;
305   if (st->depth==16) {
306      if(st->bigendian)
307      for (y=0;y<st->xim->height; y++)
308      for (x=0;x<st->xim->width; x++) {
309      r = st->palaka2[j++];
310      g = st->palaka2[j++];
311      b = st->palaka2[j++];
312      j++;
313      st->xim->data[i++] = (g&224)>>5 | (r&248);
314      st->xim->data[i++] = (b&248)>>3 | (g&28)<<3;
315      }
316      else
317      for (y=0;y<st->xim->height; y++)
318      for (x=0;x<st->xim->width; x++) {
319      r = st->palaka2[j++];
320      g = st->palaka2[j++];
321      b = st->palaka2[j++];
322      j++;
323      st->xim->data[i++] = (b&248)>>3 | (g&28)<<3;
324      st->xim->data[i++] = (g&224)>>5 | (r&248);
325      }
326   }
327   if (st->depth==15) {
328      if(st->bigendian)
329      for (y=0;y<st->xim->height; y++)
330      for (x=0;x<st->xim->width; x++) {
331      r = st->palaka2[j++];
332      g = st->palaka2[j++];
333      b = st->palaka2[j++];
334      j++;
335      st->xim->data[i++] = (g&192)>>6 | (r&248)>>1;
336      st->xim->data[i++] = (b&248)>>3 | (g&56)<<2;
337      }
338      else
339      for (y=0;y<st->xim->height; y++)
340      for (x=0;x<st->xim->width; x++) {
341      r = st->palaka2[j++];
342      g = st->palaka2[j++];
343      b = st->palaka2[j++];
344      j++;
345      st->xim->data[i++] = (b&248)>>3 | (g&56)<<2;
346      st->xim->data[i++] = (g&192)>>6 | (r&248)>>1;
347      }
348   }
349   if (st->depth==8) {
350      for (y=0;y<st->xim->height; y++)
351      for (x=0;x<st->xim->width; x++) {
352      r = st->palaka2[j++];
353      g = st->palaka2[j++];
354      b = st->palaka2[j++];
355      j++;     
356      st->xim->data[i++] = (((7*g)/256)*36)+(((6*r)/256)*6)+((6*b)/256);
357      }
358   }
359   XPutImage(st->dpy,st->window,st->gc,st->xim,0,0,0,0,st->xim->width,st->xim->height); }
360
361
362 static void *
363 fireworkx_init (Display *dpy, Window win)
364 {
365   struct state *st = (struct state *) calloc (1, sizeof(*st));
366   unsigned int n;
367   Visual *vi;
368   Colormap cmap;
369   Bool writable;
370   XWindowAttributes xwa;
371   XGCValues gcv;
372   firepix *fpix, *ffpix;
373
374   st->dpy = dpy;
375   st->window = win;
376
377   st->glow_on  = get_boolean_resource(st->dpy, "glow"    , "Boolean");
378   st->flash_on = get_boolean_resource(st->dpy, "flash"   , "Boolean");
379   st->shoot    = get_boolean_resource(st->dpy, "shoot"   , "Boolean");
380   st->verbose  = get_boolean_resource(st->dpy, "verbose" , "Boolean");
381   st->rndlife  = get_integer_resource(st->dpy, "maxlife" , "Integer");
382   st->delay    = get_integer_resource(st->dpy, "delay"   , "Integer");
383   st->minlife  = st->rndlife/4;
384   st->flash_fade=0.98;
385   if(st->rndlife < 1000) st->flash_fade=0.96;
386   if(st->rndlife <  500) st->flash_fade=0.94;
387   if(st->verbose){
388   printf("Fireworkx %s - pyrotechnics simulation program \n", FWXVERSION);
389   printf("Copyright (c) 1999-2007 Rony B Chandran <ronybc@asia.com> \n\n");
390   printf("url: http://www.ronybc.8k.com \n\n");}
391
392   XGetWindowAttributes(st->dpy,win,&xwa);
393   st->depth = xwa.depth;
394   vi        = xwa.visual;
395   cmap      = xwa.colormap;
396   st->bigendian = (ImageByteOrder(st->dpy) == MSBFirst);
397  
398   if(st->depth==8){
399   if(st->verbose){
400   printf("Pseudocolor color: use '-no-flash' for better results.\n");}
401   st->colors = (XColor *) calloc(sizeof(XColor),st->ncolors+1);
402   writable = False;
403   make_smooth_colormap(st->dpy, vi, cmap, st->colors, &st->ncolors,
404                                 False, &writable, True);
405   }
406   st->gc = XCreateGC(st->dpy, win, 0, &gcv);
407
408   resize(st);   /* initialize palakas */ 
409   
410   ffpix = malloc(sizeof(firepix) * PIXCOUNT * SHELLCOUNT);
411   st->ffshell = malloc(sizeof(fireshell) * SHELLCOUNT);
412   st->fshell = st->ffshell;
413   fpix = ffpix;
414   for (n=0;n<SHELLCOUNT;n++){
415   st->fshell->fpix = fpix;
416   recycle (st, st->fshell,rnd(st->width),rnd(st->height));
417   st->fshell++; 
418   fpix += PIXCOUNT; }
419   
420   return st;
421 }
422
423
424 static unsigned long
425 fireworkx_draw (Display *dpy, Window win, void *closure)
426 {
427   struct state *st = (struct state *) closure;
428   int q,n;
429   for(q=FTWEAK;q;q--){
430     st->fshell=st->ffshell;
431     for(n=SHELLCOUNT;n;n--){
432       if (!explode(st, st->fshell)){
433         recycle(st, st->fshell,rnd(st->width),rnd(st->height)); }
434       st->fshell++; }}
435 #if HAVE_X86_MMX
436   if(st->glow_on) mmx_glow(st->palaka1,st->width,st->height,8,st->palaka2);
437 #else
438   if(st->glow_on) glow(st);
439 #endif
440   if(st->flash_on) light_2x2(st, st->ffshell);
441   put_image(st);
442 #if HAVE_X86_MMX
443   if(!st->glow_on) mmx_blur(st->palaka1,st->width,st->height,8);
444 #else
445   if(!st->glow_on) blur(st);
446 #endif
447
448   return st->delay;
449 }
450
451
452 static void
453 fireworkx_reshape (Display *dpy, Window window, void *closure, 
454                  unsigned int w, unsigned int h)
455 {
456   struct state *st = (struct state *) closure;
457   resize(st);
458 }
459
460 static Bool
461 fireworkx_event (Display *dpy, Window window, void *closure, XEvent *event)
462 {
463   struct state *st = (struct state *) closure;
464   if (event->type == ButtonPress) {
465     recycle(st, st->ffshell, event->xbutton.x, event->xbutton.y);
466     return True;
467   }
468   return False;
469 }
470
471 static void
472 fireworkx_free (Display *dpy, Window window, void *closure)
473 {
474 }
475
476
477 static const char *fireworkx_defaults [] = {
478   ".background: black",
479   ".foreground: white",
480   "*delay:      20000",  /* never default to zero! */
481   "*maxlife:    2000",
482   "*flash:      True",
483   "*glow:       True",
484   "*shoot:      False",
485   "*verbose:    False",
486   0
487 };
488
489 static XrmOptionDescRec fireworkx_options [] = {
490   { "-delay",           ".delay",       XrmoptionSepArg, 0 },
491   { "-maxlife",         ".maxlife",     XrmoptionSepArg, 0 },
492   { "-no-flash",        ".flash",       XrmoptionNoArg, "False" },
493   { "-no-glow",         ".glow",        XrmoptionNoArg, "False" },
494   { "-shoot",           ".shoot",       XrmoptionNoArg, "True" },
495   { "-verbose",         ".verbose",     XrmoptionNoArg, "True" },
496   { 0, 0, 0, 0 }
497 };
498
499 XSCREENSAVER_MODULE ("Fireworkx", fireworkx)