git.hungrycats.org Git - xscreensaver/blob - hacks/glx/tronbit.c

   1 /* tronbit, Copyright (c) 2011-2014 Jamie Zawinski <jwz@jwz.org>
   2  *
   3  * Permission to use, copy, modify, distribute, and sell this software and its
   4  * documentation for any purpose is hereby granted without fee, provided that
   5  * the above copyright notice appear in all copies and that both that
   6  * copyright notice and this permission notice appear in supporting
   7  * documentation.  No representations are made about the suitability of this
   8  * software for any purpose.  It is provided "as is" without express or
   9  * implied warranty.
  10  */
  11
  12 #define DEFAULTS        "*delay:        30000       \n" \
  13                         "*count:        30          \n" \
  14                         "*showFPS:      False       \n" \
  15                         "*wireframe:    False       \n"
  16
  17 # define refresh_bit 0
  18 # define release_bit 0
  19 #undef countof
  20 #define countof(x) (sizeof((x))/sizeof((*x)))
  21
  22 #include "xlockmore.h"
  23 #include "colors.h"
  24 #include "sphere.h"
  25 #include "rotator.h"
  26 #include "gltrackball.h"
  27 #include <ctype.h>
  28
  29 #ifdef USE_GL /* whole file */
  30
  31 #include "gllist.h"
  32
  33 extern const struct gllist *tronbit_idle1, *tronbit_idle2,
  34   *tronbit_no, *tronbit_yes;
  35 static const struct gllist * const *all_objs[] = {
  36   &tronbit_idle1, &tronbit_idle2, &tronbit_no, &tronbit_yes };
  37
  38
  39 #define DEF_SPIN        "True"
  40 #define DEF_WANDER      "True"
  41 #define DEF_SPEED       "1.0"
  42
  43 #define HISTORY_LENGTH 512
  44 typedef enum { BIT_IDLE1, BIT_IDLE2, BIT_NO, BIT_YES } bit_state;
  45 #define MODELS 4
  46
  47
  48 typedef struct {
  49   GLXContext *glx_context;
  50   rotator *rot;
  51   trackball_state *trackball;
  52   Bool button_down_p;
  53
  54   double frequency;
  55   double confidence;
  56
  57   double last_time;
  58   unsigned char history   [HISTORY_LENGTH];
  59   unsigned char histogram [HISTORY_LENGTH];
  60   int history_fp, histogram_fp;
  61
  62   GLuint dlists[MODELS], polys[MODELS];
  63   char kbd;
  64
  65 } bit_configuration;
  66
  67 static bit_configuration *bps = NULL;
  68
  69 static const GLfloat colors[][4] = {
  70   { 0.66, 0.85, 1.00, 1.00 },
  71   { 0.66, 0.85, 1.00, 1.00 },
  72   { 1.00, 0.12, 0.12, 1.00 },
  73   { 0.98, 0.85, 0.30, 1.00 }
  74 };
  75
  76
  77 static Bool do_spin;
  78 static GLfloat speed;
  79 static Bool do_wander;
  80
  81 static XrmOptionDescRec opts[] = {
  82   { "-spin",   ".spin",   XrmoptionNoArg, "True" },
  83   { "+spin",   ".spin",   XrmoptionNoArg, "False" },
  84   { "-speed",  ".speed",  XrmoptionSepArg, 0 },
  85   { "-wander", ".wander", XrmoptionNoArg, "True" },
  86   { "+wander", ".wander", XrmoptionNoArg, "False" }
  87 };
  88
  89 static argtype vars[] = {
  90   {&do_spin,   "spin",   "Spin",   DEF_SPIN,   t_Bool},
  91   {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool},
  92   {&speed,     "speed",  "Speed",  DEF_SPEED,  t_Float},
  93 };
  94
  95 ENTRYPOINT ModeSpecOpt bit_opts = {countof(opts), opts, countof(vars), vars, NULL};
  96
  97
  98 /* Returns the current time in seconds as a double.
  99  */
 100 static double
 101 double_time (void)
 102 {
 103   struct timeval now;
 104 # ifdef GETTIMEOFDAY_TWO_ARGS
 105   struct timezone tzp;
 106   gettimeofday(&now, &tzp);
 107 # else
 108   gettimeofday(&now);
 109 # endif
 110
 111   return (now.tv_sec + ((double) now.tv_usec * 0.000001));
 112 }
 113
 114
 115 static int
 116 make_bit (ModeInfo *mi, bit_state which)
 117 {
 118   static const GLfloat spec[4] = {1.0, 1.0, 1.0, 1.0};
 119   static const GLfloat shiny   = 128.0;
 120   const GLfloat *color = colors[which];
 121   int wire = MI_IS_WIREFRAME(mi);
 122   int polys = 0;
 123   GLfloat s;
 124   const struct gllist *gll;
 125
 126   glMaterialfv (GL_FRONT, GL_SPECULAR,            spec);
 127   glMateriali  (GL_FRONT, GL_SHININESS,           shiny);
 128   glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
 129   glColor4f (color[0], color[1], color[2], color[3]);
 130
 131   glPushMatrix();
 132   switch (which)
 133     {
 134     case BIT_IDLE1:
 135       glRotatef (-44, 0, 1, 0);   /* line up the models with each other */
 136       glRotatef (-11, 1, 0, 0);
 137       glRotatef (  8, 0, 0, 1);
 138       s = 1.0;
 139       break;
 140     case BIT_IDLE2:
 141       glRotatef ( 16.0, 0, 0, 1);
 142       glRotatef (-28.0, 1, 0, 0);
 143       s = 1.0;
 144       break;
 145     case BIT_NO:
 146       glRotatef ( 16.0, 0, 0, 1);
 147       glRotatef (-28.0, 1, 0, 0);
 148       s = 1.6;
 149       break;
 150     case BIT_YES:
 151       glRotatef (-44.0, 0, 1, 0);
 152       glRotatef (-32.0, 1, 0, 0);
 153       s = 1.53;
 154       break;
 155     default:
 156       abort();
 157       break;
 158     }
 159   glScalef (s, s, s);
 160   gll = *all_objs[which];
 161   renderList (gll, wire);
 162   polys += gll->points / 3;
 163   glPopMatrix();
 164
 165   return polys;
 166 }
 167
 168
 169 static void
 170 tick_bit (ModeInfo *mi, double now)
 171 {
 172   bit_configuration *bp = &bps[MI_SCREEN(mi)];
 173   double freq = bp->frequency;
 174   int n = bp->history[bp->history_fp];
 175   int histogram_speed = 3 * speed;
 176   int i;
 177
 178   if (histogram_speed < 1) histogram_speed = 1;
 179
 180   if (n == BIT_YES || n == BIT_NO)
 181     freq *= 2;
 182
 183   if (bp->button_down_p) return;
 184
 185   for (i = 0; i < histogram_speed; i++)
 186     {
 187       int nn = (n == BIT_YES ? 240 : n == BIT_NO  ? 17 : 128);
 188       int on = bp->histogram[(bp->histogram_fp-1) % countof(bp->histogram)];
 189
 190       /* smooth out the square wave a little bit */
 191
 192       if (!(nn > 100 && nn < 200) !=
 193           !(on > 100 && on < 200))
 194         nn += (((random() % 48) - 32) *
 195                ((on > 100 && on < 200) ? 1 : -1));
 196
 197       nn += (random() % 16) - 8;
 198
 199       bp->histogram_fp++;
 200       if (bp->histogram_fp >= countof(bp->history))
 201         bp->histogram_fp = 0;
 202       bp->histogram [bp->histogram_fp] = nn;
 203     }
 204
 205
 206   if (bp->last_time + freq > now && !bp->kbd) return;
 207
 208   bp->last_time = now;
 209
 210   bp->history_fp++;
 211   if (bp->history_fp >= countof(bp->history))
 212     bp->history_fp = 0;
 213
 214   if (bp->kbd)
 215     {
 216       n = (bp->kbd == '1' ? BIT_YES :
 217            bp->kbd == '0' ? BIT_NO :
 218            (random() & 1) ? BIT_YES : BIT_NO);
 219       bp->kbd = 0;
 220     }
 221   else if (n == BIT_YES ||
 222            n == BIT_NO ||
 223            frand(1.0) >= bp->confidence)
 224     n = (n == BIT_IDLE1 ? BIT_IDLE2 : BIT_IDLE1);
 225   else
 226     n = (random() & 1) ? BIT_YES : BIT_NO;
 227
 228   bp->history [bp->history_fp] = n;
 229 }
 230
 231
 232 static int
 233 animate_bits (ModeInfo *mi, bit_state omodel, bit_state nmodel, GLfloat ratio)
 234 {
 235   bit_configuration *bp = &bps[MI_SCREEN(mi)];
 236   int polys = 0;
 237   GLfloat scale = sin (ratio * M_PI / 2);
 238   GLfloat osize, nsize, small;
 239   int wire = MI_IS_WIREFRAME(mi);
 240
 241   glShadeModel(GL_SMOOTH);
 242
 243   glEnable(GL_DEPTH_TEST);
 244   glEnable(GL_NORMALIZE);
 245   glEnable(GL_CULL_FACE);
 246
 247   if (!wire)
 248     {
 249       glEnable(GL_LIGHTING);
 250       glEnable(GL_DEPTH_TEST);
 251       glEnable(GL_CULL_FACE);
 252     }
 253
 254  if ((omodel == BIT_IDLE1 || omodel == BIT_IDLE2) &&
 255      (nmodel == BIT_IDLE1 || nmodel == BIT_IDLE2))
 256    small = 0.9;
 257  else
 258    small = 0.5;
 259
 260   nsize = small + (1 - small) * scale;
 261   osize = small + (1 - small) * (1 - scale);
 262
 263   glPushMatrix();
 264   glScalef (osize, osize, osize);
 265   glCallList (bp->dlists [omodel]);
 266   polys += bp->polys [omodel];
 267   glPopMatrix();
 268
 269   glPushMatrix();
 270   glScalef (nsize, nsize, nsize);
 271   glCallList (bp->dlists [nmodel]);
 272   polys += bp->polys [nmodel];
 273   glPopMatrix();
 274
 275   return polys;
 276 }
 277
 278
 279 static int
 280 draw_histogram (ModeInfo *mi, GLfloat ratio)
 281 {
 282   bit_configuration *bp = &bps[MI_SCREEN(mi)];
 283   int samples = countof (bp->histogram);
 284   GLfloat scalex = (GLfloat) mi->xgwa.width / samples;
 285   GLfloat scaley = mi->xgwa.height / 255.0 / 4;  /* about 1/4th of screen */
 286   int polys = 0;
 287   int overlays = 5;
 288   int k;
 289
 290   glDisable (GL_TEXTURE_2D);
 291   glDisable (GL_LIGHTING);
 292   glDisable (GL_BLEND);
 293   glDisable (GL_DEPTH_TEST);
 294   glDisable (GL_CULL_FACE);
 295
 296   glMatrixMode(GL_PROJECTION);
 297   glPushMatrix();
 298   {
 299     glLoadIdentity();
 300     glMatrixMode(GL_MODELVIEW);
 301     glPushMatrix();
 302
 303     glLoadIdentity();
 304     /* glRotatef(current_device_rotation(), 0, 0, 1); */
 305     glOrtho (0, mi->xgwa.width, 0, mi->xgwa.height, -1, 1);
 306
 307     for (k = 0; k < overlays; k++)
 308       {
 309         int i, j;
 310         GLfloat a = (GLfloat) k / overlays;
 311
 312         glColor3f (0.3 * a, 0.7 * a, 1.0 * a);
 313
 314         glBegin (GL_LINE_STRIP);
 315
 316         j = bp->histogram_fp + 1;
 317         for (i = 0; i < samples; i++)
 318           {
 319             GLfloat x, y, z;
 320             if (j >= samples) j = 0;
 321             x = i;
 322             y = bp->histogram[j];
 323             z = 0;
 324
 325             y += (int) ((random() % 16) - 8);
 326             y += 16;  /* margin at bottom of screen */
 327
 328             x *= scalex;
 329             y *= scaley;
 330
 331             glVertex3f (x, y, z);
 332             ++j;
 333             polys++;
 334           }
 335         glEnd();
 336       }
 337
 338     glPopMatrix();
 339   }
 340   glMatrixMode(GL_PROJECTION);
 341   glPopMatrix();
 342
 343   glMatrixMode(GL_MODELVIEW);
 344
 345   return polys;
 346 }
 347
 348
 349 /* Window management, etc
 350  */
 351 ENTRYPOINT void
 352 reshape_bit (ModeInfo *mi, int width, int height)
 353 {
 354   GLfloat h = (GLfloat) height / (GLfloat) width;
 355
 356   glViewport (0, 0, (GLint) width, (GLint) height);
 357
 358   glMatrixMode(GL_PROJECTION);
 359   glLoadIdentity();
 360   gluPerspective (30.0, 1/h, 1.0, 100.0);
 361
 362   glMatrixMode(GL_MODELVIEW);
 363   glLoadIdentity();
 364   gluLookAt( 0.0, 0.0, 30.0,
 365              0.0, 0.0, 0.0,
 366              0.0, 1.0, 0.0);
 367
 368   glClear(GL_COLOR_BUFFER_BIT);
 369 }
 370
 371
 372
 373 ENTRYPOINT Bool
 374 bit_handle_event (ModeInfo *mi, XEvent *event)
 375 {
 376   bit_configuration *bp = &bps[MI_SCREEN(mi)];
 377
 378   if (gltrackball_event_handler (event, bp->trackball,
 379                                  MI_WIDTH (mi), MI_HEIGHT (mi),
 380                                  &bp->button_down_p))
 381     return True;
 382   else if (event->xany.type == KeyPress)
 383     {
 384       KeySym keysym;
 385       char c = 0;
 386       XLookupString (&event->xkey, &c, 1, &keysym, 0);
 387
 388       if (keysym == XK_Up || keysym == XK_Left || keysym == XK_Prior)
 389         c = '1';
 390       else if (keysym == XK_Down || keysym == XK_Right || keysym == XK_Next)
 391         c = '0';
 392
 393       if (c == ' ' || c == '\t' || c == '\n' || c == '1' || c == '0')
 394         {
 395           bp->kbd = c;
 396           return True;
 397         }
 398     }
 399
 400   return False;
 401 }
 402
 403
 404 ENTRYPOINT void
 405 init_bit (ModeInfo *mi)
 406 {
 407   bit_configuration *bp;
 408   int i;
 409
 410   MI_INIT (mi, bps, NULL);
 411
 412   bp = &bps[MI_SCREEN(mi)];
 413
 414   bp->glx_context = init_GL(mi);
 415
 416   reshape_bit (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 417
 418   {
 419     double spin_speed   = 3.0;
 420     double wander_speed = 0.03 * speed;
 421     double spin_accel   = 4.0;
 422
 423     bp->rot = make_rotator (do_spin ? spin_speed : 0,
 424                             do_spin ? spin_speed : 0,
 425                             do_spin ? spin_speed : 0,
 426                             spin_accel,
 427                             do_wander ? wander_speed : 0,
 428                             False);
 429     bp->trackball = gltrackball_init (False);
 430   }
 431
 432   for (i = 0; i < countof(bp->dlists); i++)
 433     {
 434       bp->dlists[i] = glGenLists (1);
 435       glNewList (bp->dlists[i], GL_COMPILE);
 436       bp->polys [i] = make_bit (mi, i);
 437       glEndList ();
 438     }
 439
 440   bp->frequency  = 0.30 / speed;        /* parity around 3x/second */
 441   bp->confidence = 0.06;                /* provide answer 1/15 or so */
 442
 443   for (i = 0; i < countof(bp->histogram); i++)
 444     bp->histogram[i] = 128 + (random() % 16) - 8;
 445 }
 446
 447
 448 ENTRYPOINT void
 449 draw_bit (ModeInfo *mi)
 450 {
 451   bit_configuration *bp = &bps[MI_SCREEN(mi)];
 452   Display *dpy = MI_DISPLAY(mi);
 453   Window window = MI_WINDOW(mi);
 454   int wire = MI_IS_WIREFRAME(mi);
 455
 456   if (!bp->glx_context)
 457     return;
 458
 459   glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
 460
 461   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 462
 463   if (!wire)
 464     {
 465       GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0};
 466       GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};
 467       GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
 468       GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};
 469
 470       glEnable(GL_LIGHTING);
 471       glEnable(GL_LIGHT0);
 472       glLightfv(GL_LIGHT0, GL_POSITION, pos);
 473       glLightfv(GL_LIGHT0, GL_AMBIENT,  amb);
 474       glLightfv(GL_LIGHT0, GL_DIFFUSE,  dif);
 475       glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
 476     }
 477
 478   glPushMatrix ();
 479   glScalef(1.1, 1.1, 1.1);
 480
 481 # ifdef HAVE_MOBILE     /* Keep it the same relative size when rotated. */
 482   {
 483     GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
 484     int o = (int) current_device_rotation();
 485     if (o != 0 && o != 180 && o != -180)
 486       glScalef (1/h, 1/h, 1/h);
 487     glRotatef(o, 0, 0, 1);
 488   }
 489 # endif
 490
 491   {
 492     double x, y, z;
 493     get_position (bp->rot, &x, &y, &z, !bp->button_down_p);
 494     glTranslatef((x - 0.5) * 11,
 495                  (y - 0.5) * 5,
 496                  (z - 0.5) * 3);
 497     gltrackball_rotate (bp->trackball);
 498
 499     get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p);
 500     glRotatef (x * 360, 1.0, 0.0, 0.0);
 501     glRotatef (y * 360, 0.0, 1.0, 0.0);
 502     glRotatef (z * 360, 0.0, 0.0, 1.0);
 503   }
 504
 505   mi->polygon_count = 0;
 506
 507   glScalef (6, 6, 6);
 508
 509   {
 510     int nmodel = bp->history [bp->history_fp];
 511     int omodel = bp->history [bp->history_fp > 0
 512                               ? bp->history_fp-1
 513                               : countof(bp->history)-1];
 514     double now = double_time();
 515     double ratio = 1 - ((bp->last_time + bp->frequency) - now) / bp->frequency;
 516     if (ratio > 1) ratio = 1;
 517     mi->polygon_count += draw_histogram (mi, ratio);
 518     mi->polygon_count += animate_bits (mi, omodel, nmodel, ratio);
 519     tick_bit (mi, now);
 520   }
 521   glPopMatrix ();
 522
 523   if (mi->fps_p) do_fps (mi);
 524   glFinish();
 525
 526   glXSwapBuffers(dpy, window);
 527 }
 528
 529 XSCREENSAVER_MODULE_2 ("TronBit", tronbit, bit)
 530
 531 #endif /* USE_GL */