647b7aab93180c8e8db6294e1e511fdaf4d252ef
[xscreensaver] / hacks / abstractile.c
1 /* 
2  * Copyright (c) 2004-2009 Steve Sundstrom
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and its
5  * documentation for any purpose is hereby granted without fee, provided that
6  * the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation.  No representations are made about the suitability of this
9  * software for any purpose.  It is provided "as is" without express or 
10  * implied warranty.
11  */
12
13 #include "screenhack.h"
14 #include "colors.h"
15 #include "hsv.h"
16 #include <stdio.h>
17 #include <math.h>
18 #include <sys/time.h>
19 /*#include <sys/utsname.h>*/
20
21 #define DEBUGFILE       "/tmp/abstractile.dbg"
22
23 #define MODE_CREATE             0   /* init, create, then finish sleep */
24 #define MODE_ERASE              1   /* erase, then reset colors */
25 #define MODE_DRAW               2
26
27 #define DIR_NONE                0
28 #define DIR_UP                  1
29 #define DIR_DOWN                2
30 #define DIR_LEFT                3
31 #define DIR_RIGHT               4
32
33 #define LINE_FORCE              1
34 #define LINE_NEW                2
35 #define LINE_BRIN               3
36 #define LINE_BROUT              4
37
38 #define PT_UL                   0
39 #define PT_MP                   1
40 #define PT_LR                   2
41 #define PT_NL                   3
42
43 #define D3D_NONE                0
44 #define D3D_BLOCK               1 
45 #define D3D_NEON                2
46 #define D3D_TILED               3
47
48 #define TILE_RANDOM             0
49 #define TILE_FLAT               1
50 #define TILE_THIN               2
51 #define TILE_OUTLINE            3
52 #define TILE_BLOCK              4
53 #define TILE_NEON               5
54 #define TILE_TILED              6
55
56 #define BASECOLORS              30
57 #define SHADES                  12
58 #define MAXCOLORS               40
59 #define LAYERS                  4
60 #define PATTERNS                40
61 #define SHAPES                  18
62 #define DRAWORDERS              40
63 #define COLORMAPS               20
64 #define WAVES                   6
65 #define STRETCHES               8
66
67 struct lineStruct {
68     unsigned int x, y, len, obj, color, ndol;
69     int deo;
70     Bool hv;
71 };
72
73 struct gridStruct {
74     unsigned int line, hl, hr, vu, vd, dhl, dhr, dvu, dvd;
75 };
76
77 /* basically the same as global variables, but used to keep them in a bucket 
78    and pass them around easier like the original C++ implementation */
79 struct state {
80   /* window values */
81   Display *display;
82   Window window;
83   XWindowAttributes xgwa;
84   GC fgc, bgc;
85   XColor colors[255];
86
87   /* memory values */
88   struct lineStruct *dline, *eline;
89   struct gridStruct *grid;
90   unsigned int *zlist, *fdol;
91   Bool *odi;
92     /* draw, erase, fill, init, line, object, z indexes */
93   unsigned int di, ei, fi, ii, bi, li, eli, oi, zi;
94   /* size variables */
95   unsigned int gridx, gridy, gridn;                     /* grid size */
96   int lwid, bwid, swid;/* line width, background width, shadow width */
97   int narray, max_wxh;
98   int elwid, elpu, egridx, egridy; /* for now */
99   /* fill variables */
100   int bnratio;                 /* ratio of branch lines to new lines */
101   int maxlen;                              /* maximum length of line */
102   int forcemax;                  /* make line be max possible length */
103   int olen;                           /* open length set by findopen */
104   int bln;          /* blocking line number set by findopen, -1=edge */
105   /* color variables */
106   int ncolors;                        /* number of colors for screen */
107   int shades;
108   int rco[MAXCOLORS];           /* random ordering of colors for deo */
109   int cmap;
110   int layers;
111   Bool newcols;      /* can we create new colormaps with each screen */
112   /* draw variables */
113   int dmap, emap;  /* pattern by which line draw order is determined */
114   int dvar, evar;             /* random number added to .deo to vary */
115   int ddir, edir;      /* draw/erase in forward direction or reverse */
116   int lpu;            /* lines drawn per update used to adjust speed */
117   int d3d;
118   int round;
119   int outline;
120   /* layered draw variables */
121   int pattern[LAYERS], shape[LAYERS], mix[LAYERS]; 
122   int csw[LAYERS], wsx[LAYERS], wsy[LAYERS], sec[LAYERS]; 
123   int cs1[LAYERS], cs2[LAYERS], cs3[LAYERS]; int cs4[LAYERS]; 
124   int wave[LAYERS], waveh[LAYERS], wavel[LAYERS]; 
125   int rx1[LAYERS], rx2[LAYERS], rx3[LAYERS];
126   int ry1[LAYERS], ry2[LAYERS], ry3[LAYERS];
127   /* misc variables */
128   int mode, sleep, speed, tile, dialog;
129   Bool grid_full, resized;
130   struct timeval time;
131 };
132
133 static int 
134 _min(int a, int b) 
135 {
136   if (a<=b)
137     return(a);
138   return(b);
139 }
140
141 static int 
142 _max(int a, int b) 
143 {
144   if (a>=b)
145     return(a);
146   return(b);
147 }
148
149 static int 
150 _dist(struct state *st, int x1, int x2, int y1, int y2, int s) 
151 {
152   double xd=x1-x2;
153   double yd=y1-y2;
154   switch(s) {
155     case 0:
156       return((int)sqrt(xd*xd+yd*yd));
157     case 1:
158       return((int)sqrt(xd*xd*st->cs1[0]*2+yd*yd));
159     case 2:
160       return((int)sqrt(xd*xd+yd*yd*st->cs2[0]*2));
161     default:
162       return((int)sqrt(xd*xd*st->cs1[0]/st->cs2[0]+yd*yd*st->cs3[0]/st->cs4[0]));
163   }
164 }
165
166 static int 
167 _wave(struct state *st, int x, int h, int l, int wave) 
168 {
169   l+=1; 
170   switch(wave) {
171     case 0:                                         /* cos wave*/
172       return((int)(cos((double)x*M_PI/l)*h));
173     case 1:                                      /* double wave*/
174     case 2:                                      /* double wave*/
175       return((int)(cos((double)x*M_PI/l)*h)+(int)(sin((double)x*M_PI/l/st->cs1[1])*h));
176     case 3:                                         /* zig zag */
177       return(abs((x%(l*2)-l))*h/l);
178     case 4:                                   /* giant zig zag */
179       return(abs((x%(l*4)-l*2))*h*3/l);
180     case 5:                                        /* sawtooth */
181       return((x%(l))*h/l); 
182     default:                                        /* no wave */
183       return(0);
184   } 
185 }
186
187 static int 
188 _triangle(struct state *st, int x, int y, int rx, int ry, int t) 
189 {
190   switch(t) {
191     case 1:
192       return(_min(_min(x+y+rx-(st->gridx/2),st->gridx-x+y),(st->gridy-y+(ry/2))*3/2));
193     case 2:
194       return(_min(_min(x-rx,y-ry),(rx+ry-x-y)*2/3)); 
195     case 3:
196       return(_min(_min(st->gridx-x-rx,y-ry),(rx+ry-st->gridx+x-y)*2/3));
197     case 4:
198       return(_min(_min(x-rx,st->gridy-y-ry),(rx+ry-x-st->gridy+y)*2/3));
199   } 
200   return(_min(_min(st->gridx-x-rx,st->gridy-y-ry),(rx+ry-st->gridx+x-st->gridy+y)*2/3));
201 }
202
203 static void 
204 _init_zlist(struct state *st) 
205 {
206   unsigned int tmp, y, z;
207
208   st->gridx=st->xgwa.width/st->lwid;
209   st->gridy=st->xgwa.height/st->lwid;
210   st->gridn=st->gridx*st->gridy;
211   /* clear grid */
212   for (z=0; z<st->gridn; z++) {
213     st->grid[z].line=st->grid[z].hl=st->grid[z].hr=st->grid[z].vu=st->grid[z].vd=st->grid[z].dhl=st->grid[z].dhr=st->grid[z].dvu=st->grid[z].dvd=0;
214     st->zlist[z]=z;
215   }
216   /* rather than pull x,y points randomly and wait to hit final empy cells a 
217      list of all points is created and mixed so empty cells do get hit last */
218   for (z=0; z<st->gridn; z++) {
219     y=random()%st->gridn;
220     tmp=st->zlist[y];
221     st->zlist[y]=st->zlist[z];
222     st->zlist[z]=tmp;
223   }
224 }
225
226 static void
227 make_color_ramp_rgb (Display *dpy, Colormap cmap,
228     int r1, int g1, int b1,  int r2, int g2, int b2,
229     XColor *colors, int *ncolorsP,
230     Bool closed_p, Bool allocate_p, Bool writable_p)
231 {
232     int h1, h2;
233     double s1, s2, v1, v2;
234     rgb_to_hsv(r1, g1, b1, &h1, &s1, &v1);
235     rgb_to_hsv(r2, g2, b2, &h2, &s2, &v2);
236     make_color_ramp(dpy, cmap, h1, s1, v1, h2, s2, v2,
237         colors, ncolorsP, False, allocate_p, writable_p);
238 }
239
240
241 static void 
242 _init_colors(struct state *st)
243 {
244   int col[BASECOLORS];
245   int c1, c2, c3, h1, h2, h3; 
246   int r1, g1, b1, r2, g2, b2, r3, g3, b3;
247   double s1, s2, s3, v1, v2, v3;
248   XColor tmp_col1[16], tmp_col2[16], tmp_col3[16];
249
250   unsigned short basecol[BASECOLORS][3]={
251     /* 0  dgray */    {0x3333,0x3333,0x3333},
252     /* 1  dbrown */   {0x6666,0x3333,0x0000},
253     /* 2  dred */     {0x9999,0x0000,0x0000},
254     /* 3  orange */   {0xFFFF,0x6666,0x0000},
255     /* 4  gold */     {0xFFFF,0xCCCC,0x0000},
256     /* 5  olive */    {0x6666,0x6666,0x0000},
257     /* 6  ivy */      {0x0000,0x6666,0x0000},
258     /* 7  dgreen */   {0x0000,0x9999,0x0000},
259     /* 8  bluegray */ {0x3333,0x6666,0x6666},
260     /* 9  dblue */    {0x0000,0x0000,0x9999},
261     /* 10 blue */     {0x3333,0x3333,0xFFFF},
262     /* 11 dpurple */  {0x6666,0x0000,0xCCCC},
263     /* 12 purple */   {0x6666,0x3333,0xFFFF},
264     /* 13 violet */   {0x9999,0x3333,0x9999},
265     /* 14 magenta */  {0xCCCC,0x3333,0xCCCC},
266     /* lights */
267     /* 15 gray */     {0x3333,0x3333,0x3333},
268     /* 16 brown */    {0x9999,0x6666,0x3333},
269     /* 17 tan */      {0xCCCC,0x9999,0x3333},
270     /* 18 red */      {0xFFFF,0x0000,0x0000},
271     /* 19 lorange */  {0xFFFF,0x9999,0x0000},
272     /* 20 yellow */   {0xFFFF,0xFFFF,0x0000},
273     /* 21 lolive */   {0x9999,0x9999,0x0000},
274     /* 22 green */    {0x3333,0xCCCC,0x0000},
275     /* 23 lgreen */   {0x3333,0xFFFF,0x3333},
276     /* 24 cyan */     {0x0000,0xCCCC,0xCCCC},
277     /* 25 sky */      {0x3333,0xFFFF,0xFFFF},
278     /* 26 marine */   {0x3333,0x6666,0xFFFF},
279     /* 27 lblue */    {0x3333,0xCCCC,0xFFFF},
280     /* 28 lpurple */  {0x9999,0x9999,0xFFFF},
281     /* 29 pink */     {0xFFFF,0x9999,0xFFFF}};
282
283   if (st->d3d) {
284     st->shades = (st->d3d==D3D_TILED) ? 5 : st->lwid/2+1;      
285     st->ncolors=4+random()%4;
286     if (st->cmap>0) {                      /* tint the basecolors a bit */
287       for (c1=0; c1<BASECOLORS; c1++)
288         for (c2=0; c2<2; c2++)
289           if (!basecol[c1][c2]) {
290             basecol[c1][c2]+=random()%16000;
291           } else if (basecol[c1][c2]==0xFFFF) {
292             basecol[c1][c2]-=random()%16000;
293           } else {
294             basecol[c1][c2]-=8000;
295             basecol[c1][c2]+=random()%16000;
296           }
297     }
298     switch(st->cmap%4) {
299       case 0:                                            /* all */
300         for (c1=0; c1<st->ncolors; c1++) 
301           col[c1]=random()%BASECOLORS;
302         break;
303       case 1:                                          /* darks */
304         for (c1=0; c1<st->ncolors; c1++) 
305           col[c1]=random()%15;
306         break;
307       case 2:                                   /* semi consecutive darks */
308         col[0]=random()%15;
309         for (c1=1; c1<st->ncolors; c1++) 
310           col[c1]=(col[c1-1]+1+random()%2)%15;
311         break;
312       case 3:                                   /* consecutive darks */
313         col[0]=random()%(15-st->ncolors);
314         for (c1=1; c1<st->ncolors; c1++) 
315           col[c1]=col[c1-1]+1;
316         break;
317     }
318     for (c1=0; c1<st->ncolors; c1++) {
319       /* adjust colors already set */
320       for (h1=c1*st->shades-1; h1>=0; h1--) 
321         st->colors[h1+st->shades]=st->colors[h1];
322       make_color_ramp_rgb(st->display, st->xgwa.colormap,
323         basecol[col[c1]][0], basecol[col[c1]][1], basecol[col[c1]][2], 
324         0xFFFF, 0xFFFF, 0xFFFF, st->colors, &st->shades, 
325         False, True, False);
326     }
327     return;
328   }
329   /* not 3d */
330   st->shades=1;
331   if (st->cmap%2) {                                  /* basecolors */
332     if (random()%3) {           
333       c1=random()%15;                
334       c2=(c1+3+(random()%5))%15;
335       c3=(c2+3+(random()%5))%15;
336     } else {
337       c1=random()%BASECOLORS;                
338       c2=(c1+5+(random()%10))%BASECOLORS;
339       c3=(c2+5+(random()%10))%BASECOLORS;
340     }
341     r1=basecol[c1][0];
342     g1=basecol[c1][1];
343     b1=basecol[c1][2];
344     r2=basecol[c2][0];
345     g2=basecol[c2][1];
346     b2=basecol[c2][2];
347     r3=basecol[c3][0];
348     g3=basecol[c3][1];
349     b3=basecol[c3][2];
350   } else {                                             /* random rgb's */
351     r1=random()%65535;
352     g1=random()%65535;
353     b1=random()%65535;
354     r2=(r1+16384+random()%32768)%65535;
355     g2=(g1+16384+random()%32768)%65535;
356     b2=(b1+16384+random()%32768)%65535;
357     r3=(r2+16384+random()%32768)%65535;
358     g3=(g2+16384+random()%32768)%65535;
359     b3=(b2+16384+random()%32768)%65535;
360  }
361  switch(st->cmap) {
362     case 0:                           /* make_color_ramp color->color */
363     case 1:
364     case 2:                           /* make_color_ramp color->white */
365     case 3:
366       st->ncolors=5+random()%5;
367       if (st->cmap>1)
368         r2=g2=b2=0xFFFF;
369       make_color_ramp_rgb(st->display, st->xgwa.colormap,
370         r1, g1, b1, r2, g2, b2, 
371         st->colors, &st->ncolors, random()%2, True, False);
372       break;
373     case 4:                                /* 3 color make_color_loop */
374     case 5:
375     case 6:
376     case 7:
377       st->ncolors=8+random()%12;
378       rgb_to_hsv(r1, g1, b1, &h1, &s1, &v1);
379       rgb_to_hsv(r2, g2, b2, &h2, &s2, &v2);
380       rgb_to_hsv(r3, g3, b3, &h3, &s3, &v3);
381
382       make_color_loop(st->display, st->xgwa.colormap,
383         h1, s1, v1, h2, s2, v2, h3, s3, v3,
384         st->colors, &st->ncolors, True, False);
385       break;
386     case 8:                                            /* random smooth */
387     case 9:
388       st->ncolors=(random()%4)*6+12;
389       make_smooth_colormap (st->display, st->xgwa.visual, 
390         st->xgwa.colormap, st->colors, &st->ncolors, 
391         True, False, True);
392       break;
393     case 10:                                                 /* rainbow */
394       st->ncolors=(random()%4)*6+12;
395       make_uniform_colormap (st->display, st->xgwa.visual, 
396         st->xgwa.colormap, st->colors, &st->ncolors, 
397         True, False, True);
398       break;
399     case 11:                                     /* dark to light blend */
400     case 12:
401     case 13:
402     case 14:
403       st->ncolors=7;
404       make_color_ramp_rgb(st->display, st->xgwa.colormap,
405         r1, g1, b1, 0xFFFF, 0xFFFF, 0xFFFF, 
406         tmp_col1, &st->ncolors, False, True, False);
407       make_color_ramp_rgb(st->display, st->xgwa.colormap,
408         r2, g2, b2, 0xFFFF, 0xFFFF, 0xFFFF, 
409         tmp_col2, &st->ncolors, False, True, False);
410       if (st->cmap<13) {
411         for(c1=0; c1<=4; c1++) {
412            st->colors[c1*2]=tmp_col1[c1];
413            st->colors[c1*2+1]=tmp_col2[c1];
414         }
415         st->ncolors=10;
416       } else {
417         make_color_ramp_rgb(st->display, st->xgwa.colormap,
418           r3, g3, b3, 0xFFFF, 0xFFFF, 0xFFFF, 
419           tmp_col3, &st->ncolors, False, True, False);
420         for(c1=0; c1<=4; c1++) {
421            st->colors[c1*3]=tmp_col1[c1];
422            st->colors[c1*3+1]=tmp_col2[c1];
423            st->colors[c1*3+2]=tmp_col3[c1];
424         }
425         st->ncolors=15;
426       }
427       break;
428     default:                                                  /* random */
429       st->ncolors=(random()%4)*6+12;
430       make_random_colormap (st->display, st->xgwa.visual, 
431         st->xgwa.colormap, st->colors, &st->ncolors, 
432         False, True, False, True);
433       break;
434   }
435
436   /* set random color order for drawing and erasing */
437   for (c1=0; c1<MAXCOLORS; c1++)
438     st->rco[c1]=c1;
439   for (c1=0; c1<MAXCOLORS; c1++) {
440     c3=random()%MAXCOLORS;
441     c2=st->rco[c1];
442     st->rco[c1]=st->rco[c3];
443     st->rco[c3]=c2;
444   }
445 }
446
447 static int _comparedeo(const void *i, const void *j)
448 {
449         struct lineStruct *h1, *h2;
450                                                                                 
451         h1=(struct lineStruct *)i;
452         h2=(struct lineStruct *)j;
453         if (h1->deo > h2->deo)
454                 return(1);
455         if (h1->deo < h2->deo)
456                 return(-1);
457         return(0);
458 }
459
460 static int 
461 _hv(struct state *st, int x, int y, int d1, int d2, int pn, Bool de)
462 {
463   int v1, v2, r;
464
465   switch (d1) {
466     case 0:
467       v1 = (de) ? st->egridx-x : st->gridx-x;
468       break;
469     case 1:
470       v1 = y;
471       break;
472     case 2:
473       v1 = x;
474       break;
475     default:
476       v1 = (de) ? st->egridy-y : st->gridy-y;
477       break;
478   }
479   switch (d2) {
480     case 0:
481       v2 = (de) ? st->egridx-x : st->gridx-x;
482       break;
483     case 1:
484       v2 = y;
485       break;
486     case 2:
487       v2 = x;
488       break;
489     default:
490       v2 = (de) ? st->egridy-y : st->gridy-y;
491       break;
492   }
493   r = (de) ? (st->dline[st->li].hv) ? (v1+10000)*pn : (v2+10000)*-pn :
494     (st->eline[st->li].hv) ? (v1+10000)*pn : (v2+10000)*-pn;
495   return(r);
496 }
497         
498 static int 
499 _getdeo(struct state *st, int x, int y, int map, int de)
500 {
501   int cr;
502   switch(map) {
503     case 0:                                        /* horizontal one side */
504       return(x);
505     case 1:                                          /* vertical one side */
506       return(y);
507     case 2:                                        /* horizontal two side */
508       return(_min(x,st->gridx-x)+1); 
509     case 3:                                          /* vertical two side */
510       return(_min(y,st->gridy-y)+1); 
511     case 4:                                                     /* square */
512       return(_max(abs(x-st->rx3[de]),abs(y-st->ry3[de]))+1);
513     case 5:                                                /* two squares */
514       return(_min(_max(abs(x-(st->rx3[de]/2)),abs(y-st->ry3[de])),_max(abs(x-(st->gridx-(st->rx2[de]/2))),abs(y-st->ry2[de])))+1); 
515     case 6:                                       /* horizontal rectangle */
516       return(_max(abs(x-st->rx3[de]),abs(y-(st->ry3[de]))*st->cs1[de])+1); 
517     case 7:                                         /* vertical rectangle */
518       return(_max(abs(x-st->rx3[de])*st->cs1[de],abs(y-(st->ry3[de])))+1); 
519     case 8:                                                    /* + cross */
520       return(_min(abs(x-st->rx3[de]),abs(y-(st->ry3[de])))+1); 
521     case 9:                                                   /* diagonal */
522       return((x*3/4+y)+1);
523     case 10:                                         /* opposite diagonal */
524       return((x*3/4+st->gridy-y)+1); 
525     case 11:                                                   /* diamond */
526       return((abs(x-st->rx3[de])+abs(y-st->ry3[de]))/2+1); 
527     case 12:                                              /* two diamonds */
528       return(_min(abs(x-(st->rx3[de]/2))+abs(y-st->ry3[de]),abs(x-(st->gridx-(st->rx2[de]/2)))+abs(y-st->ry2[de]))/2+1);
529     case 13:                                                    /* circle */
530       return(_dist(st,x,st->rx3[de],y,st->ry3[de],0)+1); 
531     case 14:                                        /* horizontal ellipse */
532       return(_dist(st,x,st->rx3[de],y,st->ry3[de],1)+1); 
533     case 15:                                          /* vertical ellipse */
534       return(_dist(st,x,st->rx3[de],y,st->ry3[de],2)+1); 
535     case 16:                                               /* two circles */
536       return(_min(_dist(st,x,st->rx3[de]/2,y,st->ry3[de],0),_dist(st,x,st->gridx-(st->rx2[de]/2),y,st->ry2[de],0))+1); 
537     case 17:                                  /* horizontal straight wave */
538       return(x+_wave(st,st->gridy+y,st->csw[0]*st->cs1[0],st->csw[0]*st->cs2[0],st->wave[de]));
539     case 18:                                    /* vertical straight wave */
540       return(y+_wave(st,st->gridx+x,st->csw[0]*st->cs1[0],st->csw[0]*st->cs2[0],st->wave[de])); 
541     case 19:                                     /* horizontal wavey wave */
542       return(x+_wave(st,st->gridy+y+((x/5)*st->edir),st->csw[de]*st->cs1[de],st->csw[de]*st->cs2[de],st->wave[de])+1);
543     case 20:                                       /* vertical wavey wave */
544       return(y+_wave(st,st->gridx+x+((y/5)*st->edir),st->csw[de]*st->cs1[de],st->csw[de]*st->cs2[de],st->wave[de])+1);
545 /* no d3d for 21,22 */
546     case 21:                                  /* simultaneous directional */
547       return(_hv(st,x,y,st->cs1[0]%2,st->cs2[0]%2,1,de));
548     case 22:                                       /* reverse directional */
549       return(_hv(st,x,y,st->cs1[0]%2,st->cs2[0]%2,-1,de)); 
550     case 23:                                                    /* length */
551       if (de) 
552         return(st->dline[st->li].len*1000+random()%5000); 
553       else 
554         return(st->eline[st->li].len*1000+random()%5000);
555     case 24:                                                    /* object */
556     case 25:                                                    
557     case 26:                                                    
558     case 27:                                                    
559       if (de) 
560         return(st->dline[st->li].obj*100); 
561       else 
562         return(st->eline[st->li].obj*100);
563     default:                                                     /* color */
564       cr = (de) ? st->dline[st->li].color : st->eline[st->li].color;
565       if (map<34) cr=st->rco[cr];
566       if ((map%6<4) || (de))  {                               /* by color */
567         cr*=1000;
568         cr+=random()%1000;
569       } else if (map%6==4) {                      /* by color horizontaly */
570         cr*=st->gridx;
571         cr+=(x+random()%(st->gridx/2));
572       } else {                                     /* by color vertically */
573         cr*=st->gridy;
574         cr+=(y+random()%(st->gridy/2));
575       }
576       return(cr);
577   }
578   return(1);
579 }
580
581 static void 
582 _init_screen(struct state *st)
583 {
584   int nstr, x;
585   struct lineStruct *tmp;
586
587   /* malloc memory in case of resize */
588   if (st->resized) {
589     st->max_wxh=st->xgwa.width*st->xgwa.height;
590     if (st->dline!=NULL)
591       free(st->dline);
592     if (st->eline!=NULL)
593       free(st->eline);
594     if (st->grid!=NULL)
595       free(st->grid);
596     if (st->zlist!=NULL)
597       free(st->zlist);
598     if (st->fdol!=NULL)
599       free(st->fdol);
600     if (st->odi!=NULL)
601       free(st->odi);
602     st->narray = (st->xgwa.width+1)*(st->xgwa.height+1)/4+1;
603     st->dline = calloc(st->narray, sizeof(struct lineStruct));
604     st->eline = calloc(st->narray, sizeof(struct lineStruct));
605     st->grid = calloc(st->narray, sizeof(struct gridStruct));
606     st->zlist = calloc(st->narray, sizeof(unsigned int));
607     st->fdol = calloc(st->narray, sizeof(unsigned int));
608     st->odi = calloc(st->narray, sizeof(Bool));
609     if ((st->dline == NULL) || (st->eline == NULL) || 
610       (st->grid == NULL) || (st->zlist == NULL) ||
611       (st->fdol == NULL) || (st->odi == NULL)) {
612       fprintf(stderr, "not enough memory\n");
613       exit(1);
614     }
615     st->dialog = (st->xgwa.width<500) ? 1 : 0;
616     st->resized=False;
617   }
618   if (st->ii) {
619     /* swap st->dline and st->eline pointers to resort and erase */
620     tmp=st->eline;
621     st->eline=st->dline;
622     st->dline=tmp;
623     st->eli=st->li;
624     st->elwid=st->lwid;
625     st->elpu=st->lpu;
626     st->egridx=st->gridx;
627     st->egridy=st->gridy;
628
629     /* create new erase order */
630     for (st->li=1; st->li<=st->eli; st->li++) 
631       st->eline[st->li].deo=(_getdeo(st,st->eline[st->li].x,st->eline[st->li].y,st->emap,0) + (random()%st->evar) + (random()%st->evar))*st->edir;
632     qsort(st->eline, st->eli+1, sizeof(struct lineStruct), _comparedeo);
633   }
634   st->ii++;
635
636   /* clear arrays and other counters */
637   st->di=st->ei=st->fi=st->li=st->oi=st->zi=0;
638   st->grid_full=False;
639   /* li starts from 1 */
640   st->dline[0].x=st->dline[0].y=st->dline[0].len=0; 
641   /* to keep it first after sorting so di is never null */
642   st->dline[0].deo=-999999999; 
643
644   /* set random screen variables */
645   st->lwid = (st->ii==1) ? 3 : 2+((random()%6)%4);
646   st->d3d = ((st->tile==TILE_FLAT) || (st->tile==TILE_THIN) ||
647     (st->tile==TILE_OUTLINE)) ? D3D_NONE :
648     (st->tile==TILE_BLOCK) ? D3D_BLOCK :
649     (st->tile==TILE_NEON) ? D3D_NEON :
650     (st->tile==TILE_TILED) ? D3D_TILED : 
651     /* force TILE_D3D on first screen to properly load all shades */
652     ((st->ii==1) && (!st->newcols)) ? D3D_TILED : (random()%5)%4; 
653 /* st->d3d=D3D_BLOCK; st->lwid=2; */
654   st->outline = (st->tile==TILE_OUTLINE) ? 1 :
655      ((st->tile!=TILE_RANDOM) || (random()%5)) ? 0 : 1; 
656   st->round = (st->d3d==D3D_NEON) ? 1 : 
657     ((st->d3d==D3D_BLOCK) || (st->outline) || (random()%6)) ? 0 : 1;
658   if ((st->d3d) || (st->outline) || (st->round))
659     st->lwid+=2;
660   if ((!st->d3d) && (!st->round) && (!st->outline) && (st->lwid>3))
661     st->lwid-=2;
662   if (st->d3d==D3D_TILED)
663     st->lwid++;
664   if (st->tile==TILE_THIN)
665     st->lwid=2;
666  
667   _init_zlist(st);
668
669   st->maxlen=(st->lwid>6) ? 2+(random()%4) :
670                 (st->lwid>4) ? 2+(random()%8)%6 :
671                 (st->lwid>2) ? 2+(random()%12)%8 : 2+(random()%15)%10;
672   st->bnratio = 4+(random()%4)+(random()%4);
673   st->forcemax = (random()%6) ? 0 : 1;
674
675   if ((st->ii==1) || (st->newcols))
676     _init_colors(st);
677
678   st->dmap = (st->emap+5+(random()%5))%DRAWORDERS;
679
680   st->dmap=20+random()%20;
681   
682   st->dvar = (st->dmap>22) ? 100 : 10+(st->csw[0]*(random()%5));
683   st->ddir= (random()%2) ? 1 : -1;
684   
685   st->emap = (st->dmap+10+(random()%10))%20;
686   st->evar = (st->emap>22) ? 100 : 10+(st->csw[0]*(random()%5));
687   st->edir= (random()%2) ? 1 : -1;
688
689   st->layers= (random()%2) ? 2 : (random()%2) ? 1 : (random()%2) ? 3 : 4;
690   st->cmap=(st->cmap+5+(random()%10))%COLORMAPS;
691
692   for (x=0; x<LAYERS; x++) {
693     st->pattern[x]=random()%PATTERNS;
694     st->shape[x]=random()%SHAPES;
695     st->mix[x]=random()%20;
696     nstr = (st->lwid==2) ? 20+random()%12 :
697       (st->lwid==3) ? 16+random()%8 : 
698       (st->lwid==4) ? 12+random()%6 : 
699       (st->lwid==5) ? 10+random()%5 : 
700       (st->lwid==6) ? 8+random()%4 : 
701         5+random()%5;
702     st->csw[x] = _max(5,st->gridy/nstr);
703     st->wsx[x] = (st->wsx[x]+3+(random()%3))%STRETCHES;
704     st->wsy[x] = (st->wsy[x]+3+(random()%3))%STRETCHES;
705     st->sec[x] = random()%5;
706     if ((!st->dialog) && (st->sec[x]<2)) st->csw[x]/=2;
707     st->cs1[x] = (st->dialog) ? 1+random()%3 : 2+random()%5;
708     st->cs2[x] = (st->dialog) ? 1+random()%3 : 2+random()%5;
709     st->cs3[x] = (st->dialog) ? 1+random()%3 : 2+random()%5;
710     st->cs4[x] = (st->dialog) ? 1+random()%3 : 2+random()%5;
711     st->wave[x]=random()%WAVES;
712     st->wavel[x]=st->csw[x]*(2+random()%6); 
713     st->waveh[x]=st->csw[x]*(1+random()%3);
714     st->rx1[x]=(st->gridx/10+random()%(st->gridx*8/10));
715     st->ry1[x]=(st->gridy/10+random()%(st->gridy*8/10));
716     st->rx2[x]=(st->gridx*2/10+random()%(st->gridx*6/10));
717     st->ry2[x]=(st->gridy*2/10+random()%(st->gridy*6/10));
718     st->rx3[x]=(st->gridx*3/10+random()%(st->gridx*4/10));
719     st->ry3[x]=(st->gridy*3/10+random()%(st->gridy*4/10));
720   }
721 }
722
723 static int 
724 _shape(struct state *st, int x, int y, int rx, int ry, int n)
725 {
726   switch(st->shape[n]) {
727     case 0:                                        /* square/rectangle */
728     case 1:
729     case 2:
730       return(1+_max(abs(x-rx)*st->cs1[n]/st->cs2[n],abs(y-ry)*st->cs3[n]/st->cs4[n]));
731     case 3:                                                 /* diamond */
732     case 4:
733       return(1+(abs(x-rx)*st->cs1[n]/st->cs2[n]+abs(y-ry)*st->cs3[n]/st->cs4[n]));
734     case 5:                                            /* 8 point star */
735       return(1+_min(_max(abs(x-rx),abs(y-ry))*3/2,abs(x-rx)+abs(y-ry)));
736     case 6:                                             /* circle/oval */
737     case 7:
738     case 8:
739       return(1+_dist(st,x,rx,y,ry,st->cs1[n]));
740     case 9:                                       /* black hole circle */
741       return(1+(st->gridx*st->gridy/(1+(_dist(st,x,rx,y,ry,st->cs2[n]))))); 
742     case 10:                                                   /* sun */
743       return(1+_min(abs(x-rx)*st->gridx/(abs(y-ry)+1),abs(y-ry)*st->gridx/(abs(x-rx)+1)));
744     case 11:                             /* 2 circles+inverted circle */
745       return(1+(_dist(st,x,rx,y,ry,st->cs1[n])*_dist(st,x,(rx*3)%st->gridx,y,(ry*5)%st->gridy,st->cs1[n])/(1+_dist(st,x,(rx*4)%st->gridx,y,(ry*7)%st->gridy,st->cs1[n])))); 
746     case 12:                                                   /* star */
747       return(1+(int)sqrt(abs((x-rx)*(y-ry))));
748     case 13:                                       /* centered ellipse */
749       return(1+_dist(st,x,rx,y,ry,0)+_dist(st,x,st->gridx-rx,y,st->gridy-ry,0));
750     default:                                               /* triangle */
751       return(1+_triangle(st,x,y,rx,ry,st->cs4[n]));
752   } 
753   return(1+_triangle(st,x,y,rx,ry,st->cs4[n]));
754 }
755
756 static int 
757 _pattern(struct state *st, int x, int y, int n)
758 {
759   int v=0, ox;
760   ox=x;
761   switch(st->wsx[n]) {
762     case 0:                                             /* slants */
763       x+=y/(1+st->cs4[n]);
764       break;
765     case 1:
766       x+=(st->gridy-y)/(1+st->cs4[n]);
767       break;
768     case 2:                                             /* curves */
769       x+=_wave(st,y,st->gridx/(1+st->cs1[n]),st->gridy,0);
770       break;
771     case 3:
772       x+=_wave(st,st->gridy-y,st->gridy/(1+st->cs1[n]),st->gridy,0);
773       break;
774     case 4:                                           /* U curves */
775       x+=_wave(st,y,st->cs1[n]*st->csw[n]/2,st->gridy*2/M_PI,0);
776       break;
777     case 5:
778       x-=_wave(st,y,st->cs1[n]*st->csw[n]/2,st->gridy*2/M_PI,0);
779       break;
780   }
781   switch(st->wsy[0]) {
782     case 0:                                          /* slants */
783       y+=ox/(1+st->cs1[n]);
784       break;
785     case 1:
786       y+=(st->gridx-ox)/(1+st->cs1[n]);
787       break;
788     case 2:                                           /* curves */
789       y+=_wave(st,ox,st->gridx/(1+st->cs1[n]),st->gridx,0);
790       break;
791     case 3:
792       y+=_wave(st,st->gridx-ox,st->gridx/(1+st->cs1[n]),st->gridx,0);
793       break;
794     case 4:                                         /* U curves */
795       y+=_wave(st,ox,st->cs1[n]*st->csw[n]/2,st->gridy*2/M_PI,0);
796       break;
797     case 5:
798       y-=_wave(st,ox,st->cs1[n]*st->csw[n]/2,st->gridy*2/M_PI,0);
799       break;
800   }
801   switch(st->pattern[n]) {
802     case 0:                                          /* horizontal stripes */
803       v=y;
804       break;
805     case 1:                                            /* vertical stripes */
806       v=x;
807       break;
808     case 2:                                            /* diagonal stripes */
809       v=(x+(y*st->cs1[n]/st->cs2[n]));
810       break;
811     case 3:                                    /* reverse diagonal stripes */
812       v=(x-(y*st->cs1[n]/st->cs2[n]));
813       break;
814     case 4:                                                /* checkerboard */
815       v=(y/st->csw[n]*3+x/st->csw[n])*st->csw[n];
816       break;
817     case 5:                                       /* diagonal checkerboard */
818       v=((x+y)/2/st->csw[n]+(x+st->gridy-y)/2/st->csw[n]*3)*st->csw[n];
819       break;
820     case 6:                                                     /* + cross */
821       v=st->gridx+(_min(abs(x-st->rx3[n]),abs(y-st->ry3[n]))*2);
822       break;
823     case 7:                                              /* double + cross */
824       v=_min(_min(abs(x-st->rx2[n]),abs(y-st->ry2[n])),_min(abs(x-st->rx1[n]),abs(y-st->ry1[n])))*2;
825       break;
826     case 8:                                                     /* X cross */
827       v=st->gridx+(_min(abs(x-st->rx3[n])*st->cs1[n]/st->cs2[n]+abs(y-st->ry2[n])*st->cs3[n]/st->cs4[n],abs(x-st->rx3[n])*st->cs1[n]/st->cs2[n]-abs(y-st->ry3[n])*st->cs3[n]/st->cs4[n])*2);
828       break;
829     case 9:                                              /* double X cross */
830       v=_min(_min(abs(x-st->rx2[n])+abs(y-st->ry2[n]),abs(x-st->rx2[n])-abs(y-st->ry2[n])),_min(abs(x-st->rx1[n])+abs(y-st->ry1[n]),abs(x-st->rx1[n])-abs(y-st->ry1[n])))*2;
831       break;
832     case 10:                                   /* horizontal stripes/waves */
833       v=st->gridy+(y+_wave(st,x,st->waveh[n],st->wavel[n],st->wave[n]));
834       break;
835     case 11:                                     /* vertical stripes/waves */
836       v=st->gridx+(x+_wave(st,y,st->waveh[n],st->wavel[n],st->wave[n]));
837       break;
838     case 12:                                     /* diagonal stripes/waves */
839       v=st->gridx+(x+(y*st->cs1[n]/st->cs2[n])+_wave(st,x,st->waveh[n],st->wavel[n],st->wave[n]));
840       break;
841     case 13:                                     /* diagonal stripes/waves */
842       v=st->gridx+(x-(y*st->cs1[n]/st->cs2[n])+_wave(st,y,st->waveh[n],st->wavel[n],st->wave[n]));
843       break;
844     case 14:                                    /* horizontal spikey waves */
845       v=y+(st->csw[n]*st->cs4[n]/st->cs3[n])+_wave(st,x+((y/st->cs3[n])*st->edir),st->csw[n]/2*st->cs1[n]/st->cs2[n],st->csw[n]/2*st->cs2[n]/st->cs1[n],st->wave[n]);
846       break;
847     case 15:                                      /* vertical spikey waves */
848       v=x+(st->csw[n]*st->cs1[n]/st->cs2[n])+_wave(st,y+((x/st->cs3[n])*st->edir),st->csw[n]/2*st->cs1[n]/st->cs2[n],st->csw[n]/2*st->cs3[n]/st->cs4[n],st->wave[n]);
849       break;
850     case 16:                                    /* big slanted hwaves */
851       v=st->gridy-y-(x*st->cs1[n]/st->cs3[n])+(st->csw[n]*st->cs1[n]*st->cs2[n]) +_wave(st,x,st->csw[n]/3*st->cs1[n]*st->cs2[n],st->csw[n]/3*st->cs3[n]*st->cs2[n],st->wave[n]);
852       break;
853     case 17:                                    /* big slanted vwaves */
854       v=x-(y*st->cs1[n]/st->cs3[n])+(st->csw[n]*st->cs1[n]*st->cs2[n]) +_wave(st,y, st->csw[n]/3*st->cs1[n]*st->cs2[n], st->csw[n]/3*st->cs3[n]*st->cs2[n], st->wave[n]);
855       break;
856     case 18:                                          /* double hwave */
857       v=y+(y+st->csw[n]*st->cs3[n])+_wave(st,x,st->csw[n]/3*st->cs3[n],st->csw[n]/3*st->cs2[n],st->wave[n])+_wave(st,x,st->csw[n]/3*st->cs4[n],st->csw[n]/3*st->cs1[n]*3/2,st->wave[n]);
858       break;
859     case 19:                                          /* double vwave */
860       v=x+(x+st->csw[n]*st->cs1[n])+_wave(st,y,st->csw[n]/3*st->cs1[n],st->csw[n]/3*st->cs3[n],st->wave[n])+_wave(st,y,st->csw[n]/3*st->cs2[n],st->csw[n]/3*st->cs4[n]*3/2,st->wave[n]); 
861       break;
862     case 20:                                                  /* one shape */
863     case 21:
864     case 22:
865       v=_shape(st,x, y, st->rx3[n], st->ry3[n], n);
866       break;
867     case 23:                                                 /* two shapes */
868     case 24:
869     case 25:
870       v=_min(_shape(st,x, y, st->rx1[n], st->ry1[n], n),_shape(st,x, y, st->rx2[n], st->ry2[n], n));
871       break;
872     case 26:                                       /* two shapes opposites */
873     case 27:
874       v=_min(_shape(st,x, y, st->rx2[n], st->ry2[n], n),_shape(st,x, y, st->gridx-st->rx2[n], st->gridy-st->rx2[n], n));
875       break;
876     case 28:                                     /* two shape checkerboard */
877     case 29:
878       v=((_shape(st,x, y, st->rx1[n], st->ry1[n], n)/st->csw[n])+(_shape(st,x, y, st->rx2[n], st->ry2[n], n)/st->csw[n]))*st->csw[n];
879       break;
880     case 30:                                             /* two shape blob */
881     case 31:
882       v=(_shape(st,x, y, st->rx1[n], st->ry1[n], n)+_shape(st,x, y, st->rx2[n], st->ry2[n], n))/2;
883       break;
884     case 32:                                    /* inverted two shape blob */
885     case 33:
886       v=(_shape(st,x, y, st->rx1[n], st->ry1[n], n)+_shape(st,st->gridx-x, st->gridy-y, st->rx1[n], st->ry1[n], n))/2;
887       break;
888     case 34:                                               /* three shapes */
889     case 35:
890       v=_min(_shape(st,x, y, st->rx3[n], st->ry3[n], n),_min(_shape(st,x, y, st->rx1[n], st->ry1[n], n),_shape(st,x, y, st->rx2[n], st->ry2[n], n)));
891       break;
892     case 36:                                           /* three shape blob */
893     case 37:
894       v=(_shape(st,x, y, st->rx1[n], st->ry1[n], n)+_shape(st,x, y, st->rx2[n], st->ry2[n], n)+_shape(st,x, y, st->rx3[n], st->ry3[n], n))/3;
895       break;
896     case 38:                                                  /* 4 shapes */    
897       v=(_min(_shape(st,x, y, st->rx2[n], st->ry2[n], n),_shape(st,x, y, st->gridx-st->rx2[n], st->gridy-st->ry2[n], n)),_min(_shape(st,x, y, st->gridx-st->rx2[n], st->ry2[n], n),_shape(st,x, y, st->rx2[n], st->gridy-st->ry2[n], n)));
898       break;
899     case 39:                                            /* four rainbows */
900       v=(_min(_shape(st,x, y, st->gridx-st->rx2[n]/2, st->csw[n], n),_shape(st,x, y, st->csw[n], st->ry2[n]/2, n)),_min(_shape(st,x, y, st->rx2[n]/2, st->gridy-st->csw[n], n),_shape(st,x, y, st->gridx-st->csw[n], st->gridy-(st->ry2[n]/2), n))); 
901       break;
902   }
903   /* stretch or contract stripe */
904   switch(st->sec[n]) {
905     case 0:
906       v=(int)sqrt((int)sqrt(abs(v)*st->gridx)*st->gridx);
907       break;
908     case 1:
909       v=((int)pow(v,2)/st->gridx);
910       break;
911   }
912   return (abs(v));
913 }
914
915 static int 
916 _getcolor(struct state *st, int x, int y)
917 {
918   int n, cv[LAYERS];
919   
920   for (n=0; n<st->layers; n++) {
921     cv[n]=_pattern(st,x,y,n);
922                   /* first wave/shape */
923     cv[0] = (!n) ? cv[0]/st->csw[0] : 
924                     /* checkerboard+1 */
925       (st->mix[n]<5) ? (cv[0]*st->csw[0]+cv[n])/st->csw[n] : 
926                /* checkerboard+ncol/2 */
927       (st->mix[n]<12) ? cv[0]+(cv[n]/st->csw[n]*st->ncolors/2) : 
928                            /* add mix */
929       (st->mix[n]<16) ? cv[0]+(cv[n]/st->csw[n]) : 
930                       /* subtract mix */
931       (st->mix[n]<18) ? cv[0]-(cv[n]/st->csw[n]) : 
932                   /* r to l morph mix */
933       (st->mix[n]==18) ? ((cv[0]*x)+(cv[n]*(st->gridx-x)/st->csw[n]))/st->gridx : 
934                   /* u to d morph mix */
935       ((cv[0]*y)+(cv[n]*(st->gridy-y)/st->csw[n]))/st->gridy; 
936   }
937   return(cv[0]);
938 }
939
940 /* return value=line direction
941    st->olen=open space to edge or next blocking line
942    st->bln=blocking line number or -1 if edge blocks */
943 static int 
944 _findopen(struct state *st, int x, int y, int z)
945 {
946   int dir, od[4], no=0;
947
948   if (((st->grid[z].hl) || (st->grid[z].hr)) && 
949     ((st->grid[z].vu) || (st->grid[z].vd))) 
950     return(DIR_NONE);
951   if ((z>st->gridx) && (!st->grid[z].hl) && (!st->grid[z].hr) && 
952     (!st->grid[z-st->gridx].line)) { 
953     od[no]=DIR_UP; 
954     no++; 
955   }
956   if ((z<st->gridn-st->gridx) && (!st->grid[z].hl) && 
957     (!st->grid[z].hr) && (!st->grid[z+st->gridx].line)) { 
958     od[no]=DIR_DOWN; 
959     no++; 
960   }
961   if ((x) && (!st->grid[z].hl) && (!st->grid[z].hr) && 
962     (!st->grid[z-1].line)) {
963     od[no]=DIR_LEFT; 
964     no++; 
965   }
966   if (((z+1)%st->gridx) && (!st->grid[z].hl) && (!st->grid[z].hr) && 
967     (!st->grid[z+1].line)) { 
968     od[no]=DIR_RIGHT; 
969     no++; 
970   }
971   if (!no) 
972     return(DIR_NONE);
973   dir=od[random()%no];
974   st->olen=st->bln=0;
975   while ((st->olen<=st->maxlen) && (!st->bln)) {
976     st->olen++;
977     if (dir==DIR_UP) 
978       st->bln = (y-st->olen<0) ? -1 : 
979         st->grid[z-(st->olen*st->gridx)].line;
980     if (dir==DIR_DOWN) 
981       st->bln = (y+st->olen>=st->gridy) ? -1 : 
982         st->grid[z+(st->olen*st->gridx)].line;
983     if (dir==DIR_LEFT) 
984       st->bln = (x-st->olen<0) ? -1 : 
985         st->grid[z-st->olen].line;
986     if (dir==DIR_RIGHT) 
987       st->bln = (x+st->olen>=st->gridx) ? -1 : 
988         st->grid[z+st->olen].line;
989   }
990   st->olen--; 
991   return(dir);
992 }
993
994 static void 
995 _fillgrid(struct state *st)
996 {
997   unsigned int gridc, n, add;
998
999   gridc=st->gridx*st->dline[st->li].y+st->dline[st->li].x;
1000   add = (st->dline[st->li].hv) ? 1 : st->gridx;
1001   for (n=0;  n<=st->dline[st->li].len; n++) {
1002     if (n)
1003       gridc+=add;
1004     if (!st->grid[gridc].line) {
1005       st->fi++;
1006       st->grid[gridc].line=st->li;
1007     }
1008     if (st->dline[st->li].hv) {
1009       if (n) 
1010         st->grid[gridc].hr=st->li;
1011       if (n<st->dline[st->li].len)
1012         st->grid[gridc].hl=st->li;
1013     } else {
1014       if (n) 
1015         st->grid[gridc].vd=st->li;
1016       if (n<st->dline[st->li].len) 
1017         st->grid[gridc].vu=st->li;
1018     }
1019     if (st->fi>=st->gridn) {
1020       st->grid_full=True;
1021       return;
1022     }
1023   }
1024 }
1025
1026 static void 
1027 _newline(struct state *st)
1028 {
1029   int bl, bz, dir, lt, x, y, z;
1030
1031   bl=0;
1032   z=st->zlist[st->zi];
1033   x=z%st->gridx;
1034   y=z/st->gridx;
1035   st->zi++;
1036   dir=_findopen(st,x,y,z);
1037
1038   if (!st->grid[z].line) { 
1039   /* this is an empty space, make a new line unless nothing is open around it */
1040     if (dir==DIR_NONE) {
1041       /* nothing is open, force a len 1 branch in any direction */
1042       lt=LINE_FORCE; 
1043       while ((dir==DIR_NONE) || 
1044         ((dir==DIR_UP) && (!y)) || 
1045         ((dir==DIR_DOWN) && (y+1==st->gridy)) ||
1046         ((dir==DIR_LEFT) && (!x)) || 
1047         ((dir==DIR_RIGHT) && (x+1==st->gridx))) {
1048           dir=random()%4;
1049       }
1050       bz = (dir==DIR_UP) ? z-st->gridx : (dir==DIR_DOWN) ? z+st->gridx : (dir==DIR_LEFT) ? z-1 : z+1;
1051       bl = st->grid[bz].line;
1052     } else if ((st->bnratio>1) && (st->bln>0) && 
1053       (st->olen<st->maxlen) && (random()%st->bnratio)) { 
1054       /* branch into blocking line */
1055       lt=LINE_BRIN; 
1056       bl = st->bln;
1057     } else { 
1058       /* make a new line and new object */
1059       lt=LINE_NEW; 
1060       st->oi++;
1061     }  
1062   } else { 
1063     /* this is a filled space, make a branch unless nothing is open around it */
1064     if (dir==DIR_NONE) 
1065       return;
1066     /* make a branch out of this line */
1067     lt=LINE_BROUT; 
1068     bl=st->grid[z].line;
1069   }
1070   st->li++;
1071   st->dline[st->li].len = (lt==LINE_FORCE) ? 1 :  (lt==LINE_BRIN) ? 
1072     st->olen+1 : (!st->forcemax) ? st->olen : 1+random()%st->olen;
1073   st->dline[st->li].x=x;
1074   if (dir==DIR_LEFT) 
1075     st->dline[st->li].x-=st->dline[st->li].len;
1076   st->dline[st->li].y=y;
1077   if (dir==DIR_UP) 
1078     st->dline[st->li].y-=st->dline[st->li].len;
1079   st->dline[st->li].hv = ((dir==DIR_LEFT) || (dir==DIR_RIGHT)) ? 
1080     True : False;
1081   st->dline[st->li].obj = (lt==LINE_NEW) ? st->oi : 
1082     st->dline[bl].obj;
1083   st->dline[st->li].color = (lt==LINE_NEW) ? 
1084     (_getcolor(st,x,y))%st->ncolors : st->dline[bl].color;
1085   st->dline[st->li].deo=(_getdeo(st,x,y,st->dmap,1) + 
1086     (random()%st->dvar) + (random()%st->dvar))*st->ddir;
1087   st->dline[st->li].ndol=0;
1088   _fillgrid(st);
1089 }
1090
1091 static void 
1092 _create_screen(struct state *st)
1093 {
1094   while(!st->grid_full)
1095     _newline(st);
1096   qsort(st->dline, st->li+1, sizeof(struct lineStruct), _comparedeo);
1097 /*st->lpu=st->li/20/((6-st->speed)*3);
1098   Used to use a computed lpu, lines per update to control draw speed
1099   draw 1/lpu of the lines before each XSync which takes a split second 
1100   the higher the lpu, the quicker the screen draws.  This worked somewhat
1101   after the 4->5 update, however with the Mac updating so much more slowly,
1102   values tuned for it draw the screen in a blink on Linux.  Therefore we
1103   draw 1/200th of the screen with each update and sleep, if necessary */
1104   st->lpu = (st->dialog) ? st->li/50 : st->li/200;   
1105   if (!st->lpu) st->lpu = 1;
1106   st->bi=1;
1107   st->mode=MODE_ERASE;
1108 }
1109
1110 static void 
1111 _fill_outline(struct state *st, int di)
1112 {
1113   int x, y, h, w;
1114
1115   if (!di)
1116     return;
1117   x=st->dline[di].x*st->lwid+1;
1118   y=st->dline[di].y*st->lwid+1;
1119   if (st->dline[di].hv) {
1120     w=(st->dline[di].len+1)*st->lwid-3;
1121     h=st->lwid-3;
1122   } else {
1123     w=st->lwid-3; 
1124     h=(st->dline[di].len+1)*st->lwid-3;
1125   }
1126   XFillRectangle (st->display, st->window, st->bgc, x, y, w, h);
1127 }
1128
1129 static void 
1130 _XFillRectangle(struct state *st, int di, int adj)
1131 {
1132   int a, b, x, y, w, h;
1133
1134   x=st->dline[di].x*st->lwid;
1135   y=st->dline[di].y*st->lwid;
1136   if (st->dline[di].hv) {
1137     w=(st->dline[di].len+1)*st->lwid-1;
1138     h=st->lwid-1;
1139   } else {
1140     w=st->lwid-1; 
1141     h=(st->dline[di].len+1)*st->lwid-1;
1142   }
1143   switch (st->d3d) {
1144     case D3D_NEON:
1145       x+=adj;
1146       y+=adj;
1147       w-=adj*2;
1148       h-=adj*2;
1149     break;
1150     case D3D_BLOCK:
1151       x+=adj;
1152       y+=adj;
1153       w-=st->lwid/2-1;
1154       h-=st->lwid/2-1;
1155     break;
1156   }
1157   if (!st->round) { 
1158     XFillRectangle(st->display, st->window, st->fgc, x, y, w, h);
1159   } else {
1160     if (h<st->lwid) {                                   /* horizontal */
1161       a=(h-1)/2;
1162       for (b=0; b<=a; b++)
1163         XFillRectangle(st->display, st->window, st->fgc, 
1164           x+b, y+a-b, w-b*2, h-((a-b)*2));
1165     } else {                                               /* vertical */
1166       a=(w-1)/2;
1167       for (b=0; b<=a; b++)
1168         XFillRectangle(st->display, st->window, st->fgc, 
1169           x+a-b, y+b, w-((a-b)*2), h-b*2);
1170     }
1171   }
1172 }
1173
1174 static void 
1175 _XFillTriangle(struct state *st, int color, int x1, int y1, int x2, int y2, 
1176   int x3, int y3)
1177 {
1178   XPoint points[3];
1179
1180   points[0].x=x1;
1181   points[0].y=y1;
1182   points[1].x=x2;
1183   points[1].y=y2;
1184   points[2].x=x3;
1185   points[2].y=y3;
1186   XSetForeground(st->display, st->fgc, st->colors[color].pixel);
1187   XFillPolygon (st->display, st->window, st->fgc, points, 3, Convex, 
1188       CoordModeOrigin);
1189 }
1190
1191 static void 
1192 _XFillPolygon4(struct state *st, int color, int x1, int y1, int x2, int y2, 
1193   int x3, int y3, int x4, int y4)
1194 {
1195   XPoint points[4];
1196
1197   points[0].x=x1;
1198   points[0].y=y1;
1199   points[1].x=x2;
1200   points[1].y=y2;
1201   points[2].x=x3;
1202   points[2].y=y3;
1203   points[3].x=x4;
1204   points[3].y=y4;
1205   XSetForeground(st->display, st->fgc, st->colors[color].pixel);
1206   XFillPolygon (st->display, st->window, st->fgc, points, 4, Convex, 
1207       CoordModeOrigin);
1208 }
1209
1210 static void 
1211 _draw_tiled(struct state *st, int color)
1212 {
1213   int a, c, d, x, y, z, m1, m2, lr, nl, w, h;
1214   a = (st->dline[st->di].hv) ? 1 : st->gridx;
1215   z = st->dline[st->di].y*st->gridx+st->dline[st->di].x;
1216   m1 = (st->lwid-1)/2;
1217   m2 = st->lwid/2;
1218   lr = st->lwid-1;
1219   nl = st->lwid;
1220
1221   /* draw tiles one grid cell at a time */
1222   for (c=0; c<=st->dline[st->di].len; c++) {
1223     if (st->dline[st->di].hv) {
1224       x = (st->dline[st->di].x+c)*st->lwid;
1225       y = st->dline[st->di].y*st->lwid;
1226       if (c) 
1227         st->grid[z].dhr=st->di;
1228       if (c<st->dline[st->di].len) 
1229         st->grid[z].dhl=st->di;
1230     } else {
1231       x = st->dline[st->di].x*st->lwid;
1232       y = (st->dline[st->di].y+c)*st->lwid;
1233       if (c) 
1234         st->grid[z].dvd=st->di;
1235       if (c<st->dline[st->di].len) 
1236         st->grid[z].dvu=st->di;
1237     }
1238     d=0;
1239     if (st->grid[z].dhl) 
1240       d+=8;
1241     if (st->grid[z].dhr) 
1242       d+=4;
1243     if (st->grid[z].dvu) 
1244       d+=2;
1245     if (st->grid[z].dvd) 
1246       d++;
1247     /* draw line base */
1248     switch (d) {
1249       case 1:
1250       case 2:                                    /* vertical */
1251       case 3:
1252       case 5:
1253       case 6:
1254       case 7:
1255       case 11:
1256       case 15:
1257         h = ((d==1) || (d==5)) ? lr : nl;
1258         XSetForeground(st->display, st->fgc, 
1259           st->colors[color].pixel);
1260         XFillRectangle (st->display, st->window, st->fgc, 
1261           x, y, m2, h);
1262         XSetForeground(st->display, st->fgc, 
1263            st->colors[color+3].pixel);
1264         XFillRectangle (st->display, st->window, st->fgc, 
1265           x+m2, y, m1, h);
1266         break;
1267       case 4:
1268       case 8:                                     /* horizontal */
1269       case 9:
1270       case 10:
1271       case 12:
1272       case 13:
1273       case 14:
1274         w = (d==4) ? lr : nl;
1275         XSetForeground(st->display, st->fgc, 
1276           st->colors[color+1].pixel);
1277         XFillRectangle (st->display, st->window, st->fgc, 
1278           x, y, w, m2);
1279         XSetForeground(st->display, st->fgc, 
1280            st->colors[color+2].pixel);
1281         XFillRectangle (st->display, st->window, st->fgc, 
1282           x, y+m2, w, m1);
1283         break;
1284     }
1285     /* draw angles */
1286     switch(d) {
1287       case 1:                                      /* bottom end ^ */
1288         _XFillTriangle(st,color+2, x, y+lr, x+lr, y+lr, x+m2, y+m2);
1289         break;
1290       case 2:                                       /* top end \/ */
1291         _XFillTriangle(st,color+1, x, y, x+lr, y, x+m2, y+m2);
1292         break;
1293       case 4:                                       /* right end < */
1294         _XFillTriangle(st,color+3, x+lr, y, x+lr, y+lr, x+m2, y+m2);
1295         break;
1296       case 5:                                        /* LR corner */
1297         _XFillTriangle(st,color+1, x, y+m2, x+m2, y+m2, x, y);
1298         _XFillPolygon4(st,color+2, x, y+m2, x+m2, y+m2, x+lr, y+lr, x, y+lr);
1299         break;
1300       case 6:                                        /* UR corner */
1301         _XFillPolygon4(st,color+1, x, y+m2, x+m2, y+m2, x+lr, y, x, y);
1302         _XFillTriangle(st,color+2, x, y+m2, x+m2, y+m2, x, y+lr);
1303         break;
1304       case 7:                                        /* T > into line */
1305         _XFillTriangle(st,color+1, x, y+m2, x+m2, y+m2, x, y);
1306         _XFillTriangle(st,color+2, x, y+m2, x+m2, y+m2, x, y+lr);
1307         break;
1308       case 8:                                       /* left end > */
1309         _XFillTriangle(st,color, x, y, x, y+lr, x+m2, y+m2);
1310         break;
1311       case 9:                                       /* LL corner */
1312         _XFillPolygon4(st,color, x+m2, y, x+m2, y+m2, x, y+lr, x, y);
1313         _XFillTriangle(st,color+3, x+m2, y, x+m2, y+m2, x+lr, y);
1314         break;
1315       case 10:                                      /* UL corner */
1316         _XFillPolygon4(st,color, x+m2, y+nl, x+m2, y+m2, x, y, x, y+nl);
1317         _XFillPolygon4(st,color+3, x+m2, y+nl, x+m2, y+m2, x+lr, y+lr, x+lr, y+nl);
1318         break;
1319       case 11:                                       /* T < into line */
1320         _XFillPolygon4(st,color+1, x+nl, y+m2, x+m2, y+m2, x+lr, y, x+nl, y);
1321         _XFillPolygon4(st,color+2, x+nl, y+m2, x+m2, y+m2, x+lr, y+lr, x+nl, y+lr);
1322         break;
1323       case 13:                                        /* T \/ into line */
1324         _XFillTriangle(st,color, x+m2, y, x+m2, y+m2, x, y);
1325         _XFillTriangle(st,color+3, x+m2, y, x+m2, y+m2, x+lr, y);
1326         break;
1327       case 14:                                        /* T ^ into line */
1328         _XFillPolygon4(st,color, x+m2, y+nl, x+m2, y+m2, x, y+lr, x, y+nl);
1329         _XFillPolygon4(st,color+3, x+m2, y+nl, x+m2, y+m2, x+lr, y+lr, x+lr, y+nl);
1330         break;
1331       case 15:                                        /* X intersection */
1332         _XFillTriangle(st,color+1, x, y+m2, x+m2, y+m2, x, y);
1333         _XFillTriangle(st,color+2, x, y+m2, x+m2, y+m2, x, y+lr);
1334         _XFillPolygon4(st,color+1, x+nl, y+m2, x+m2, y+m2, x+lr, y, x+nl, y);
1335         _XFillPolygon4(st,color+2, x+nl, y+m2, x+m2, y+m2, x+lr, y+lr, x+nl, y+lr);
1336         break;
1337     }
1338     z+=a;
1339   }
1340 }
1341
1342 static long 
1343 _mselapsed(struct state *st)
1344 {
1345   struct timeval t;
1346   gettimeofday(&t, NULL);
1347   t.tv_sec -= st->time.tv_sec;
1348   t.tv_usec -= st->time.tv_usec;
1349   return ((long)t.tv_sec*1000000+t.tv_usec);
1350 }
1351
1352 static void 
1353 _draw_lines(struct state *st)
1354 {
1355   int n, z, a, color, sh, di;
1356   if (st->bi==1)
1357     for (a=0; a<=st->oi; a++)
1358       st->fdol[a]=0;
1359
1360   for (st->di=st->bi; st->di<_min(st->li+1,st->bi+st->lpu); st->di++) {
1361     color=(st->dline[st->di].color%st->ncolors)*st->shades;
1362     XSetForeground(st->display, st->fgc, st->colors[color].pixel);
1363
1364     switch (st->d3d) {
1365       case D3D_NEON:
1366         st->dline[st->di].ndol=st->fdol[st->dline[st->di].obj];
1367         st->fdol[st->dline[st->di].obj]=st->di;
1368         for (sh=0; sh<st->lwid/2; sh++) {
1369           XSetForeground(st->display, st->fgc, 
1370             st->colors[color+sh].pixel);
1371           di=st->di;
1372           while(di>0) {
1373             _XFillRectangle(st,di,sh);
1374             di=st->dline[di].ndol;
1375           }
1376         }
1377         break;
1378       case D3D_BLOCK:
1379         st->dline[st->di].ndol=st->fdol[st->dline[st->di].obj];
1380         st->fdol[st->dline[st->di].obj]=st->di;
1381         for (sh=0; sh<st->lwid/2; sh++) {
1382           XSetForeground(st->display, st->fgc, 
1383             st->colors[color+(st->lwid/2)-sh-1].pixel);
1384           di=st->di;
1385           while(di>0) {
1386             _XFillRectangle(st,di,sh);
1387             di=st->dline[di].ndol;
1388           }
1389         }
1390         break;
1391       case D3D_TILED:
1392         _draw_tiled(st,color);
1393         break;
1394       default:               /* D3D_NONE */
1395         _XFillRectangle(st,st->di,0);
1396         if (st->outline) {
1397           _fill_outline(st, st->di);
1398           z=st->dline[st->di].y*st->gridx+st->dline[st->di].x;
1399           a = (st->dline[st->di].hv) ? 1 : st->gridx;
1400           for (n=0; n<=st->dline[st->di].len; n++) {
1401             _fill_outline(st, st->grid[z].dhl);
1402             _fill_outline(st, st->grid[z].dhr);
1403             _fill_outline(st, st->grid[z].dvu);
1404             _fill_outline(st, st->grid[z].dvd);
1405             if (st->dline[st->di].hv) {
1406               if (n) 
1407                 st->grid[z].dhr=st->di;
1408               if (n<st->dline[st->di].len) 
1409                 st->grid[z].dhl=st->di;
1410             } else {
1411               if (n) 
1412                 st->grid[z].dvd=st->di;
1413               if (n<st->dline[st->di].len) 
1414                 st->grid[z].dvu=st->di;
1415             }
1416             z+=a;
1417           }
1418         }
1419         break;
1420     }
1421   }
1422   if (st->di>st->li) {
1423       st->bi=1;
1424       st->mode=MODE_CREATE;
1425   } else {
1426       st->bi+=st->lpu;
1427   }
1428 }
1429
1430 static void 
1431 _erase_lines(struct state *st)
1432 {
1433   if (!st->ii)
1434     return;
1435   for (st->di=st->bi; st->di<_min(st->eli+1,st->bi+st->elpu); st->di++) {
1436     if (st->eline[st->di].hv) {
1437       XFillRectangle (st->display, st->window, st->bgc, 
1438       st->eline[st->di].x*st->elwid, 
1439       st->eline[st->di].y*st->elwid,
1440       (st->eline[st->di].len+1)*st->elwid, st->elwid);
1441     } else {
1442       XFillRectangle (st->display, st->window, st->bgc, 
1443       st->eline[st->di].x*st->elwid, 
1444       st->eline[st->di].y*st->elwid,
1445       st->elwid, (st->eline[st->di].len+1)*st->elwid);
1446     }
1447     if (st->di==st->eli) /* clear just in case */
1448       XFillRectangle(st->display, st->window, st->bgc, 0, 0, 
1449         st->xgwa.width, st->xgwa.height);
1450   }
1451   if (st->di>st->eli) {
1452       st->bi=1;
1453       if (st->resized) {
1454          st->mode=MODE_CREATE;
1455       } else {
1456          st->mode=MODE_DRAW;
1457       }
1458   } else {
1459       st->bi+=st->elpu;
1460   }
1461 }
1462
1463 static void *
1464 abstractile_init(Display *display, Window window)
1465 {
1466   struct state *st = (struct state *) calloc (1, sizeof(*st));
1467   XGCValues gcv;
1468 /*  struct utsname os;*/
1469
1470   char *tile = get_string_resource(display, "tile", "Tile");
1471   if      (tile && !strcmp(tile, "random")) st->tile = TILE_RANDOM;
1472   else if (tile && !strcmp(tile, "flat")) st->tile = TILE_FLAT;
1473   else if (tile && !strcmp(tile, "thin")) st->tile = TILE_THIN;
1474   else if (tile && !strcmp(tile, "outline")) st->tile = TILE_OUTLINE;
1475   else if (tile && !strcmp(tile, "block")) st->tile = TILE_BLOCK;
1476   else if (tile && !strcmp(tile, "neon")) st->tile = TILE_NEON;
1477   else if (tile && !strcmp(tile, "tiled")) st->tile = TILE_TILED;
1478   else {
1479     if (tile && *tile && !!strcmp(tile, "random"))
1480       fprintf(stderr, "%s: unknown tile option %s\n", progname, tile);
1481     st->tile = TILE_RANDOM;
1482   }
1483
1484   st->speed = get_integer_resource(display, "speed", "Integer");
1485   if (st->speed < 0) st->speed = 0;
1486   if (st->speed > 5) st->speed = 5;
1487   st->sleep = get_integer_resource(display, "sleep", "Integer");
1488   if (st->sleep < 0) st->sleep = 0;
1489   if (st->sleep > 60) st->sleep = 60;
1490
1491   st->display=display;
1492   st->window=window;
1493
1494   /* get screen size and create Graphics Contexts */
1495   XGetWindowAttributes (display, window, &st->xgwa);
1496   gcv.foreground = get_pixel_resource(display, st->xgwa.colormap, 
1497       "foreground", "Foreground");
1498   st->fgc = XCreateGC (display, window, GCForeground, &gcv);
1499   gcv.foreground = get_pixel_resource(display, st->xgwa.colormap,
1500       "background", "Background");
1501   st->bgc = XCreateGC (display, window, GCForeground, &gcv);
1502
1503 /* Um, no. This is obscene. -jwz.
1504   uname(&os);
1505   st->newcols=((!strcmp(os.sysname,"Linux")) || (!strcmp(os.sysname,"Darwin")))
1506       ? True : False;
1507 */
1508   st->newcols=False;
1509
1510   st->mode=MODE_CREATE;
1511   st->ii=0;
1512   st->resized=True;
1513   return st;
1514 }
1515
1516 static unsigned long 
1517 abstractile_draw (Display *dpy, Window window, void *closure)
1518 {
1519   struct state *st = (struct state *) closure;
1520   int mse, usleep;
1521  
1522   gettimeofday(&st->time, NULL);
1523
1524   /* If the window is too small, do nothing, sorry! */
1525   if (st->xgwa.width > 20 && st->xgwa.height > 20) {
1526     switch (st->mode) {
1527     case MODE_CREATE:
1528       _init_screen(st);
1529       _create_screen(st);
1530       break;
1531     case MODE_ERASE:
1532       _erase_lines(st);
1533       break;
1534     case MODE_DRAW:
1535       _draw_lines(st);
1536       break;
1537     }
1538   }
1539   mse=_mselapsed(st);
1540   usleep = ((!st->ii) && (st->mode==MODE_CREATE)) ?  0 :
1541       (st->mode==MODE_CREATE) ?  st->sleep*1000000-mse : 
1542       /* speed=0-5, goal is 10,8,6,4,2,0 sec normal and 5,4,3,2,1,0 dialog */
1543       (5-st->speed)*(2-st->dialog)*100000/st->lpu-mse; 
1544   if (usleep>=0)
1545       return usleep;
1546   return 0;
1547 }
1548
1549 static void
1550 abstractile_reshape (Display *dpy, Window window, void *closure,
1551                  unsigned int w, unsigned int h)
1552 {
1553   struct state *st = (struct state *) closure;
1554   st->xgwa.width = w;
1555   st->xgwa.height = h;
1556   if (w*h>st->max_wxh)
1557     st->resized=True;
1558 }
1559
1560 static Bool
1561 abstractile_event (Display *dpy, Window window, void *closure, XEvent *event)
1562 {
1563   return False;
1564 }
1565
1566 static void
1567 abstractile_free (Display *dpy, Window window, void *closure)
1568 {
1569   struct state *st = (struct state *) closure;
1570   free (st);
1571 }
1572
1573 static const char *abstractile_defaults [] = {
1574   ".background:    black",
1575   ".foreground:    white",
1576   "*fpsSolid:      true",
1577   "*sleep:             3",
1578   "*speed:             3",
1579   "*tile:         random",
1580   0
1581 };
1582
1583 static XrmOptionDescRec abstractile_options [] = {
1584   { "-sleep",  ".sleep",  XrmoptionSepArg, 0 },
1585   { "-speed",  ".speed",  XrmoptionSepArg, 0 },
1586   { "-tile",   ".tile",   XrmoptionSepArg, 0 },
1587   { 0, 0, 0, 0 }
1588 };
1589
1590 XSCREENSAVER_MODULE ("Abstractile", abstractile)