git.hungrycats.org Git - xscreensaver/blob - hacks/kumppa.c

   1 /*
   2
   3 Copyright (C) Teemu Suutari (temisu@utu.fi) Feb 1998
   4
   5 Permission is hereby granted, free of charge, to any person obtaining
   6 a copy of this software and associated documentation files (the
   7 "Software"), to deal in the Software without restriction, including
   8 without limitation the rights to use, copy, modify, merge, publish,
   9 distribute, sublicense, and/or sell copies of the Software, and to
  10 permit persons to whom the Software is furnished to do so, subject to
  11 the following conditions:
  12
  13 The above copyright notice and this permission notice shall be included
  14 in all copies or substantial portions of the Software.
  15
  16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  19 IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22 OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall
  25 not be used in advertising or otherwise to promote the sale, use or
  26 other dealings in this Software without prior written authorization
  27 from the X Consortium.
  28
  29 */
  30
  31
  32
  33
  34 /*
  35
  36 *** This is contest-version. Don't look any further, code is *very* ugly.
  37
  38 */
  39
  40 #include <math.h>
  41 #include "screenhack.h"
  42
  43 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
  44 # include "xdbe.h"
  45 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
  46
  47 #undef countof
  48 #define countof(x) (sizeof((x))/sizeof((*x)))
  49
  50 static const char *kumppa_defaults [] ={
  51   ".background:         black",
  52   "*fpsSolid:           true",
  53   "*speed:              0.1",
  54   "*delay:              10000",
  55   "*random:             True",
  56   /* leave this off by default, since it slows things down.  -- jwz. */
  57   "*useDBE:             False",
  58   0
  59 };
  60
  61 static XrmOptionDescRec kumppa_options [] = {
  62   {"-delay",     ".delay",  XrmoptionSepArg, 0 },
  63   {"-speed",     ".speed",  XrmoptionSepArg, 0 },
  64   {"-random",    ".random", XrmoptionNoArg, "True"  },
  65   {"-no-random", ".random", XrmoptionNoArg, "False" },
  66   {"-db",       ".useDBE",  XrmoptionNoArg, "True"  },
  67   {"-no-db",    ".useDBE",  XrmoptionNoArg, "False" },
  68   {0,0,0,0}
  69 };
  70
  71 static const unsigned char colors[96]=
  72   {0,0,255, 0,51,255, 0,102,255, 0,153,255, 0,204,255,
  73    0,255,255,0,255,204, 0,255,153, 0,255,102, 0,255,51,
  74    0,255,0, 51,255,0, 102,255,0, 153,255,0, 204,255,0,
  75    255,255,0, 255,204,0, 255,153,0, 255,102,0, 255,51,0,
  76    255,0,0, 255,0,51, 255,0,102, 255,0,153, 255,0,204,
  77    255,0,255, 219,0,255, 182,0,255, 146,0,255, 109,0,255,
  78    73,0,255, 37,0,255};
  79 static const float cosinus[8][6]=
  80  {{-0.07,0.12,-0.06,32,25,37},{0.08,-0.03,0.05,51,46,32},{0.12,0.07,-0.13,27,45,36},
  81   {0.05,-0.04,-0.07,36,27,39},{-0.02,-0.07,0.1,21,43,42},{-0.11,0.06,0.02,51,25,34},{0.04,-0.15,0.02,42,32,25},
  82   {-0.02,-0.04,-0.13,34,20,15}};
  83
  84
  85 struct state {
  86   Display *dpy;
  87   Window win[2];
  88
  89   float acosinus[8][3];
  90   int coords[8];
  91   int ocoords[8];
  92
  93   GC fgc[33];
  94   GC cgc;
  95   int sizx,sizy;
  96   int midx,midy;
  97   unsigned long delay;
  98   Bool cosilines;
  99
 100   int *Xrotations;
 101   int *Yrotations;
 102   int *Xrottable;
 103   int *Yrottable;
 104
 105   int *rotateX;
 106   int *rotateY;
 107
 108   int rotsizeX,rotsizeY;
 109   int stateX,stateY;
 110
 111   int rx,ry;
 112
 113 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
 114   XdbeSwapInfo xdswp;
 115   Bool usedouble;
 116 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
 117
 118   int draw_count;
 119 };
 120
 121
 122 static int Satnum(int maxi)
 123 {
 124   return (int)(maxi*frand(1));
 125 }
 126
 127
 128 static void palaRotate(struct state *st, int x,int y)
 129 {
 130   int ax,ay,bx,by,cx,cy;
 131
 132   ax=st->rotateX[x];
 133   ay=st->rotateY[y];
 134   bx=st->rotateX[x+1]+2;
 135   by=st->rotateY[y+1]+2;
 136   cx=st->rotateX[x]-(y-st->ry)+x-st->rx;
 137   cy=st->rotateY[y]+(x-st->rx)+y-st->ry;
 138   if (cx<0)
 139     {
 140       ax-=cx;
 141       cx=0;
 142     }
 143   if (cy<0)
 144     {
 145       ay-=cy;
 146       cy=0;
 147     }
 148   if (cx+bx-ax>st->sizx) bx=ax-cx+st->sizx;
 149   if (cy+by-ay>st->sizy) by=ay-cy+st->sizy;
 150   if (ax<bx && ay<by)
 151     XCopyArea(st->dpy,st->win[0],st->win[1],st->cgc,ax,ay,bx-ax,by-ay,cx,cy);
 152 }
 153
 154
 155 static void rotate(struct state *st)
 156 {
 157   int x,y;
 158   int dx,dy;
 159
 160   st->rx=st->Xrottable[st->stateX+1]-st->Xrottable[st->stateX];
 161   st->ry=st->Yrottable[st->stateY+1]-st->Yrottable[st->stateY];
 162
 163
 164   for (x=0;x<=st->rx;x++)
 165     st->rotateX[x]=(x)?st->midx-1-st->Xrotations[st->Xrottable[st->stateX+1]-x]:0;
 166   for (x=0;x<=st->rx;x++)
 167     st->rotateX[x+st->rx+1]=(x==st->rx)?st->sizx-1:st->midx+st->Xrotations[st->Xrottable[st->stateX]+x];
 168   for (y=0;y<=st->ry;y++)
 169     st->rotateY[y]=(y)?st->midy-1-st->Yrotations[st->Yrottable[st->stateY+1]-y]:0;
 170   for (y=0;y<=st->ry;y++)
 171     st->rotateY[y+st->ry+1]=(y==st->ry)?st->sizy-1:st->midy+st->Yrotations[st->Yrottable[st->stateY]+y];
 172
 173   x=(st->rx>st->ry)?st->rx:st->ry;
 174   for (dy=0;dy<(x+1)<<1;dy++)
 175     for (dx=0;dx<(x+1)<<1;dx++)
 176       {
 177         y=(st->rx>st->ry)?st->ry-st->rx:0;
 178         if (dy+y>=0 && dy<(st->ry+1)<<1 && dx<(st->rx+1)<<1)
 179           if (dy+y+dx<=st->ry+st->rx && dy+y-dx<=st->ry-st->rx)
 180             {
 181               palaRotate(st, (st->rx<<1)+1-dx,dy+y);
 182               palaRotate(st, dx,(st->ry<<1)+1-dy-y);
 183             }
 184         y=(st->ry>st->rx)?st->rx-st->ry:0;
 185         if (dy+y>=0 && dx<(st->ry+1)<<1 && dy<(st->rx+1)<<1)
 186           if (dy+y+dx<=st->ry+st->rx && dx-dy-y>=st->ry-st->rx)
 187             {
 188               palaRotate(st, dy+y,dx);
 189               palaRotate(st, (st->rx<<1)+1-dy-y,(st->ry<<1)+1-dx);
 190             }
 191       }
 192   st->stateX++;
 193   if (st->stateX==st->rotsizeX) st->stateX=0;
 194   st->stateY++;
 195   if (st->stateY==st->rotsizeY) st->stateY=0;
 196 }
 197
 198
 199
 200 static Bool make_rots(struct state *st, double xspeed,double yspeed)
 201 {
 202   int a,b,c,f,g,j,k=0,l;
 203   double m,om,ok;
 204   double d,ix,iy;
 205   int maxi;
 206
 207   Bool *chks;
 208
 209   st->rotsizeX=(int)(2/xspeed+1);
 210   ix=(double)(st->midx+1)/(double)(st->rotsizeX);
 211   st->rotsizeY=(int)(2/yspeed+1);
 212   iy=(double)(st->midy+1)/(double)(st->rotsizeY);
 213
 214   st->Xrotations=malloc((st->midx+2)*sizeof(unsigned int));
 215   st->Xrottable=malloc((st->rotsizeX+1)*sizeof(unsigned int));
 216   st->Yrotations=malloc((st->midy+2)*sizeof(unsigned int));
 217   st->Yrottable=malloc((st->rotsizeY+1)*sizeof(unsigned int));
 218   chks=malloc(((st->midx>st->midy)?st->midx:st->midy)*sizeof(Bool));
 219   if (!st->Xrottable || !st->Yrottable || !st->Xrotations || !st->Yrotations || !chks) return False;
 220
 221
 222   maxi=0;
 223   c=0;
 224   d=0;
 225   g=0;
 226   for (a=0;a<st->midx;a++) chks[a]=True;
 227   for (a=0;a<st->rotsizeX;a++)
 228     {
 229       st->Xrottable[a]=c;
 230       f=(int)(d+ix)-g;                          /*viivojen lkm.*/
 231       g+=f;
 232       if (g>st->midx)
 233         {
 234           f-=g-st->midx;
 235           g=st->midx;
 236         }
 237       for (b=0;b<f;b++)
 238         {
 239           m=0;
 240           for (j=0;j<st->midx;j++)                      /*testi*/
 241             {
 242               if (chks[j])
 243                 {
 244                   om=0;
 245                   ok=1;
 246                   l=0;
 247                   while (j+l<st->midx && om+12*ok>m)
 248                     {
 249                       if (j-l>=0) if (chks[j-l]) om+=ok;
 250                       else; else if (chks[l-j]) om+=ok;
 251                       if (chks[j+l]) om+=ok;
 252                       ok/=1.5;
 253                       l++;
 254                     }
 255                   if (om>=m)
 256                     {
 257                       k=j;
 258                       m=om;
 259                     }
 260                 }
 261             }
 262           chks[k]=False;
 263           l=c;
 264           while (l>=st->Xrottable[a])
 265             {
 266               if (l!=st->Xrottable[a]) st->Xrotations[l]=st->Xrotations[l-1];
 267               if (k>st->Xrotations[l] || l==st->Xrottable[a])
 268                 {
 269                   st->Xrotations[l]=k;
 270                   c++;
 271                   l=st->Xrottable[a];
 272                 }
 273               l--;
 274             }
 275         }
 276       d+=ix;
 277       if (maxi<c-st->Xrottable[a]) maxi=c-st->Xrottable[a];
 278     }
 279   st->Xrottable[a]=c;
 280   st->rotateX=malloc((maxi+2)*sizeof(int)<<1);
 281   if (!st->rotateX) return False;
 282
 283   maxi=0;
 284   c=0;
 285   d=0;
 286   g=0;
 287   for (a=0;a<st->midy;a++) chks[a]=True;
 288   for (a=0;a<st->rotsizeY;a++)
 289     {
 290       st->Yrottable[a]=c;
 291       f=(int)(d+iy)-g;                          /*viivojen lkm.*/
 292       g+=f;
 293       if (g>st->midy)
 294         {
 295           f-=g-st->midy;
 296           g=st->midy;
 297         }
 298       for (b=0;b<f;b++)
 299         {
 300           m=0;
 301           for (j=0;j<st->midy;j++)                      /*testi*/
 302             {
 303               if (chks[j])
 304                 {
 305                   om=0;
 306                   ok=1;
 307                   l=0;
 308                   while (j+l<st->midy && om+12*ok>m)
 309                     {
 310                       if (j-l>=0) if (chks[j-l]) om+=ok;
 311                       else; else if (chks[l-j]) om+=ok;
 312                       if (chks[j+l]) om+=ok;
 313                       ok/=1.5;
 314                       l++;
 315                     }
 316                   if (om>=m)
 317                     {
 318                       k=j;
 319                       m=om;
 320                     }
 321                 }
 322             }
 323           chks[k]=False;
 324           l=c;
 325           while (l>=st->Yrottable[a])
 326             {
 327               if (l!=st->Yrottable[a]) st->Yrotations[l]=st->Yrotations[l-1];
 328               if (k>st->Yrotations[l] || l==st->Yrottable[a])
 329                 {
 330                   st->Yrotations[l]=k;
 331                   c++;
 332                   l=st->Yrottable[a];
 333                 }
 334               l--;
 335             }
 336
 337         }
 338       d+=iy;
 339       if (maxi<c-st->Yrottable[a]) maxi=c-st->Yrottable[a];
 340     }
 341   st->Yrottable[a]=c;
 342   st->rotateY=malloc((maxi+2)*sizeof(int)<<1);
 343   if (!st->rotateY) return False;
 344
 345   free(chks);
 346   return (True);
 347 }
 348
 349
 350 static Bool InitializeAll(struct state *st)
 351 {
 352   XGCValues xgcv;
 353   XWindowAttributes xgwa;
 354 /*  XSetWindowAttributes xswa;*/
 355   Colormap cmap;
 356   XColor color;
 357   int n,i;
 358   double rspeed;
 359
 360   st->cosilines = True;
 361
 362   XGetWindowAttributes(st->dpy,st->win[0],&xgwa);
 363   cmap=xgwa.colormap;
 364 /*  xswa.backing_store=Always;
 365   XChangeWindowAttributes(st->dpy,st->win[0],CWBackingStore,&xswa);*/
 366   xgcv.function=GXcopy;
 367
 368   xgcv.foreground=get_pixel_resource (st->dpy, cmap, "background", "Background");
 369   st->fgc[32]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
 370
 371   n=0;
 372   if (mono_p)
 373     {
 374       st->fgc[0]=st->fgc[32];
 375       xgcv.foreground=get_pixel_resource (st->dpy, cmap, "foreground", "Foreground");
 376       st->fgc[1]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
 377       for (i=0;i<32;i+=2) st->fgc[i]=st->fgc[0];
 378       for (i=1;i<32;i+=2) st->fgc[i]=st->fgc[1];
 379     } else
 380     for (i=0;i<32;i++)
 381       {
 382         color.red=colors[n++]<<8;
 383         color.green=colors[n++]<<8;
 384         color.blue=colors[n++]<<8;
 385         color.flags=DoRed|DoGreen|DoBlue;
 386         XAllocColor(st->dpy,cmap,&color);
 387         xgcv.foreground=color.pixel;
 388         st->fgc[i]=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
 389       }
 390   st->cgc=XCreateGC(st->dpy,st->win[0],GCForeground|GCFunction,&xgcv);
 391   XSetGraphicsExposures(st->dpy,st->cgc,False);
 392
 393   st->cosilines = get_boolean_resource(st->dpy, "random","Boolean");
 394
 395 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
 396   if (get_boolean_resource (st->dpy, "useDBE", "Boolean"))
 397     st->usedouble = True;
 398   st->win[1] = xdbe_get_backbuffer (st->dpy, st->win[0], XdbeUndefined);
 399   if (!st->win[1])
 400     {
 401       st->usedouble = False;
 402       st->win[1] = st->win[0];
 403     }
 404 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
 405
 406   st->delay=get_integer_resource(st->dpy, "delay","Integer");
 407   rspeed=get_float_resource(st->dpy, "speed","Float");
 408   if (rspeed<0.0001 || rspeed>0.2)
 409     {
 410       fprintf(stderr,"Speed not in valid range! (0.0001 - 0.2), using 0.1 \n");
 411       rspeed=0.1;
 412     }
 413
 414   st->sizx=xgwa.width;
 415   st->sizy=xgwa.height;
 416   st->midx=st->sizx>>1;
 417   st->midy=st->sizy>>1;
 418   st->stateX=0;
 419   st->stateY=0;
 420
 421   if (!make_rots(st,rspeed,rspeed))
 422     {
 423       fprintf(stderr,"Not enough memory for tables!\n");
 424       return False;
 425     }
 426   return True;
 427 }
 428
 429 static void *
 430 kumppa_init (Display *d, Window w)
 431 {
 432   struct state *st = (struct state *) calloc (1, sizeof(*st));
 433   st->dpy=d;
 434   st->win[0]=w;
 435   if (!InitializeAll(st)) abort();
 436
 437 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
 438   if (st->usedouble)
 439     {
 440       st->xdswp.swap_action=XdbeUndefined;
 441       st->xdswp.swap_window=st->win[0];
 442     }
 443   else
 444 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
 445     st->win[1]=st->win[0];
 446
 447   return st;
 448 }
 449
 450 static unsigned long
 451 kumppa_draw (Display *d, Window w, void *closure)
 452 {
 453   struct state *st = (struct state *) closure;
 454   if (st->cosilines)
 455     {
 456       int a;
 457       st->draw_count++;
 458       for (a=0;a<8;a++)
 459         {
 460           float f=0;
 461           int b;
 462           for (b=0;b<3;b++)
 463             {
 464               st->acosinus[a][b]+=cosinus[a][b];
 465               f+=cosinus[a][b+3]*sin((double)st->acosinus[a][b]);
 466             }
 467           st->coords[a]=(int)f;
 468         }
 469       for (a=0;a<4;a++)
 470         {
 471           XDrawLine(st->dpy,st->win[0],(mono_p)?st->fgc[1]:st->fgc[((a<<2)+st->draw_count)&31],st->midx+st->ocoords[a<<1],st->midy+st->ocoords[(a<<1)+1]
 472                     ,st->midx+st->coords[a<<1],st->midy+st->coords[(a<<1)+1]);
 473           st->ocoords[a<<1]=st->coords[a<<1];
 474           st->ocoords[(a<<1)+1]=st->coords[(a<<1)+1];
 475         }
 476
 477     } else {
 478     int e;
 479     for (e=0;e<8;e++)
 480       {
 481         int a=Satnum(50);
 482         int b;
 483         if (a>=32) a=32;
 484         b=Satnum(32)-16+st->midx;
 485         st->draw_count=Satnum(32)-16+st->midy;
 486         XFillRectangle(st->dpy,st->win[0],st->fgc[a],b,st->draw_count,2,2);
 487       }
 488   }
 489   XFillRectangle(st->dpy,st->win[0],st->fgc[32],st->midx-2,st->midy-2,4,4);
 490   rotate(st);
 491 #ifdef HAVE_DOUBLE_BUFFER_EXTENSION
 492   if (st->usedouble) XdbeSwapBuffers(st->dpy,&st->xdswp,1);
 493 #endif /* HAVE_DOUBLE_BUFFER_EXTENSION */
 494
 495   return st->delay;
 496 }
 497
 498
 499 static void
 500 kumppa_reshape (Display *dpy, Window window, void *closure,
 501                  unsigned int w, unsigned int h)
 502 {
 503   struct state *st = (struct state *) closure;
 504   st->sizx=w;
 505   st->sizy=w;
 506   st->midx=st->sizx>>1;
 507   st->midy=st->sizy>>1;
 508   st->stateX=0;
 509   st->stateY=0;
 510 }
 511
 512 static Bool
 513 kumppa_event (Display *dpy, Window window, void *closure, XEvent *event)
 514 {
 515   return False;
 516 }
 517
 518 static void
 519 kumppa_free (Display *dpy, Window window, void *closure)
 520 {
 521   struct state *st = (struct state *) closure;
 522   int i;
 523   for (i = 0; i < countof(st->fgc); i++)
 524     if (st->fgc[i]) XFreeGC (dpy, st->fgc[i]);
 525   XFreeGC (dpy, st->cgc);
 526   free (st->Xrotations);
 527   free (st->Yrotations);
 528   free (st->Xrottable);
 529   free (st->Yrottable);
 530   free (st);
 531 }
 532
 533 XSCREENSAVER_MODULE ("Kumppa", kumppa)