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

   1 /* geodesic, Copyright (c) 2013-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:        4           \n" \
  14                         "*showFPS:      False       \n" \
  15                         "*suppressRotationAnimation: True\n" \
  16
  17 # define refresh_geodesic 0
  18 # define release_geodesic 0
  19 #undef countof
  20 #define countof(x) (sizeof((x))/sizeof((*x)))
  21
  22 #include "xlockmore.h"
  23 #include "colors.h"
  24 #include "normals.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 #define DEF_SPIN        "True"
  34 #define DEF_WANDER      "True"
  35 #define DEF_SPEED       "1.0"
  36 #define DEF_MODE        "mesh"
  37
  38 typedef struct { double a, o; } LL;     /* latitude + longitude */
  39
  40 typedef struct {
  41   GLXContext *glx_context;
  42   rotator *rot;
  43   trackball_state *trackball;
  44   Bool button_down_p;
  45   int ncolors;
  46   XColor *colors;
  47   int ccolor, ccolor2;
  48   GLfloat color1[4], color2[4];
  49
  50   GLfloat depth;
  51   GLfloat delta;
  52
  53   GLfloat thickness;
  54   GLfloat thickdelta;
  55
  56   GLfloat morph_ratio;
  57
  58   Bool random_p;
  59   enum { WIRE, MESH, SOLID, STELLATED, STELLATED2 } mode;
  60
  61 } geodesic_configuration;
  62
  63 static geodesic_configuration *bps = NULL;
  64
  65 static Bool do_spin;
  66 static GLfloat speed;
  67 static Bool do_wander;
  68 static char *mode_str;
  69
  70 static XrmOptionDescRec opts[] = {
  71   { "-spin",      ".spin",   XrmoptionNoArg, "True"  },
  72   { "+spin",      ".spin",   XrmoptionNoArg, "False" },
  73   { "-speed",     ".speed",  XrmoptionSepArg, 0      },
  74   { "-wander",    ".wander", XrmoptionNoArg, "True"  },
  75   { "+wander",    ".wander", XrmoptionNoArg, "False" },
  76   { "-mode",      ".mode",   XrmoptionSepArg, 0      },
  77   { "-wireframe", ".mode",   XrmoptionNoArg, "wire"  },
  78 };
  79
  80 static argtype vars[] = {
  81   {&do_spin,   "spin",   "Spin",   DEF_SPIN,   t_Bool},
  82   {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool},
  83   {&speed,     "speed",  "Speed",  DEF_SPEED,  t_Float},
  84   {&mode_str,   "mode",  "Mode",   DEF_MODE,   t_String},
  85 };
  86
  87 ENTRYPOINT ModeSpecOpt geodesic_opts = {
  88   countof(opts), opts, countof(vars), vars, NULL};
  89
  90
  91 /* Renders a triangle specified by 3 cartesian endpoints.
  92  */
  93 static void
  94 triangle0 (ModeInfo *mi, XYZ p1, XYZ p2, XYZ p3)
  95 {
  96   geodesic_configuration *bp = &bps[MI_SCREEN(mi)];
  97   int wire = MI_IS_WIREFRAME(mi);
  98   GLfloat r = bp->thickness;
  99
 100   if (bp->mode == SOLID || bp->mode == STELLATED || bp->mode == STELLATED2)
 101     r = 1;
 102
 103   if (r <= 0.001) r = 0.001;
 104
 105   glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, bp->color1);
 106
 107   if (wire) r = 1;
 108
 109   if (r <= 0)
 110     ;
 111   else if (r >= 1)      /* solid triangular face */
 112     {
 113       glFrontFace (GL_CCW);
 114       glBegin (wire ? GL_LINE_LOOP : GL_TRIANGLES);
 115       do_normal (p1.x, p1.y, p1.z,
 116                  p2.x, p2.y, p2.z,
 117                  p3.x, p3.y, p3.z);
 118       glVertex3f (p1.x, p1.y, p1.z);
 119       glVertex3f (p2.x, p2.y, p2.z);
 120       glVertex3f (p3.x, p3.y, p3.z);
 121       glEnd();
 122       mi->polygon_count++;
 123     }
 124   else                  /* mesh: triangular face with a triangular hole */
 125     {
 126       XYZ p1b, p2b, p3b, c;
 127       GLfloat d = 0.98;
 128
 129       c.x = (p1.x + p2.x + p3.x) / 3;
 130       c.y = (p1.y + p2.y + p3.y) / 3;
 131       c.z = (p1.z + p2.z + p3.z) / 3;
 132
 133       p1b.x = p1.x + (r * (c.x - p1.x));
 134       p1b.y = p1.y + (r * (c.y - p1.y));
 135       p1b.z = p1.z + (r * (c.z - p1.z));
 136
 137       p2b.x = p2.x + (r * (c.x - p2.x));
 138       p2b.y = p2.y + (r * (c.y - p2.y));
 139       p2b.z = p2.z + (r * (c.z - p2.z));
 140
 141       p3b.x = p3.x + (r * (c.x - p3.x));
 142       p3b.y = p3.y + (r * (c.y - p3.y));
 143       p3b.z = p3.z + (r * (c.z - p3.z));
 144
 145       /* Outside faces */
 146
 147       do_normal (p1.x, p1.y, p1.z,
 148                  p2.x, p2.y, p2.z,
 149                  p3.x, p3.y, p3.z);
 150
 151       glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
 152       glVertex3f (p1.x,  p1.y,  p1.z);
 153       glVertex3f (p1b.x, p1b.y, p1b.z);
 154       glVertex3f (p3b.x, p3b.y, p3b.z);
 155       glVertex3f (p3.x,  p3.y,  p3.z);
 156       mi->polygon_count++;
 157
 158       glVertex3f (p1.x,  p1.y,  p1.z);
 159       glVertex3f (p2.x,  p2.y,  p2.z);
 160       glVertex3f (p2b.x, p2b.y, p2b.z);
 161       glVertex3f (p1b.x, p1b.y, p1b.z);
 162       mi->polygon_count++;
 163
 164       glVertex3f (p2.x,  p2.y,  p2.z);
 165       glVertex3f (p3.x,  p3.y,  p3.z);
 166       glVertex3f (p3b.x, p3b.y, p3b.z);
 167       glVertex3f (p2b.x, p2b.y, p2b.z);
 168       mi->polygon_count++;
 169       glEnd();
 170
 171       /* Inside faces */
 172
 173       glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, bp->color2);
 174
 175       do_normal (p3.x,  p3.y,  p3.z,
 176                  p3b.x, p3b.y, p3b.z,
 177                  p1b.x, p1b.y, p1b.z);
 178
 179       glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
 180       glVertex3f (d * p3.x,  d * p3.y,  d * p3.z);
 181       glVertex3f (d * p3b.x, d * p3b.y, d * p3b.z);
 182       glVertex3f (d * p1b.x, d * p1b.y, d * p1b.z);
 183       glVertex3f (d * p1.x,  d * p1.y,  d * p1.z);
 184       mi->polygon_count++;
 185
 186       glVertex3f (d * p1b.x, d * p1b.y, d * p1b.z);
 187       glVertex3f (d * p2b.x, d * p2b.y, d * p2b.z);
 188       glVertex3f (d * p2.x,  d * p2.y,  d * p2.z);
 189       glVertex3f (d * p1.x,  d * p1.y,  d * p1.z);
 190       mi->polygon_count++;
 191
 192       glVertex3f (d * p2b.x, d * p2b.y, d * p2b.z);
 193       glVertex3f (d * p3b.x, d * p3b.y, d * p3b.z);
 194       glVertex3f (d * p3.x,  d * p3.y,  d * p3.z);
 195       glVertex3f (d * p2.x,  d * p2.y,  d * p2.z);
 196       mi->polygon_count++;
 197       glEnd();
 198
 199
 200       /* Connecting edges */
 201
 202       glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, bp->color1);
 203
 204       glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
 205
 206       do_normal (p1b.x, p1b.y, p1b.z,
 207                  p2b.x, p2b.y, p2b.z,
 208                  p2b.x * d, p2b.y * d, p2b.z * d);
 209       glVertex3f (p1b.x, p1b.y, p1b.z);
 210       glVertex3f (p2b.x, p2b.y, p2b.z);
 211       glVertex3f (p2b.x * d, p2b.y * d, p2b.z * d);
 212       glVertex3f (p1b.x * d, p1b.y * d, p1b.z * d);
 213       mi->polygon_count++;
 214
 215       do_normal (p2b.x, p2b.y, p2b.z,
 216                  p3b.x, p3b.y, p3b.z,
 217                  p3b.x * d, p3b.y * d, p3b.z * d);
 218       glVertex3f (p2b.x, p2b.y, p2b.z);
 219       glVertex3f (p3b.x, p3b.y, p3b.z);
 220       glVertex3f (p3b.x * d, p3b.y * d, p3b.z * d);
 221       glVertex3f (p2b.x * d, p2b.y * d, p2b.z * d);
 222       mi->polygon_count++;
 223
 224       do_normal (p3b.x, p3b.y, p3b.z,
 225                  p1b.x, p1b.y, p1b.z,
 226                  p1b.x * d, p1b.y * d, p1b.z * d);
 227       glVertex3f (p3b.x, p3b.y, p3b.z);
 228       glVertex3f (p1b.x, p1b.y, p1b.z);
 229       glVertex3f (p1b.x * d, p1b.y * d, p1b.z * d);
 230       glVertex3f (p3b.x * d, p3b.y * d, p3b.z * d);
 231       mi->polygon_count++;
 232       glEnd();
 233     }
 234 }
 235
 236
 237 /* Renders a triangle specified by 3 polar endpoints.
 238  */
 239 static void
 240 triangle1 (ModeInfo *mi, LL v1, LL v2, LL v3)
 241 {
 242   XYZ p1, p2, p3;
 243
 244   p1.x = cos (v1.a) * cos (v1.o);
 245   p1.y = cos (v1.a) * sin (v1.o);
 246   p1.z = sin (v1.a);
 247
 248   p2.x = cos (v2.a) * cos (v2.o);
 249   p2.y = cos (v2.a) * sin (v2.o);
 250   p2.z = sin (v2.a);
 251
 252   p3.x = cos (v3.a) * cos (v3.o);
 253   p3.y = cos (v3.a) * sin (v3.o);
 254   p3.z = sin (v3.a);
 255
 256   triangle0 (mi, p1, p2, p3);
 257 }
 258
 259
 260 /* Computes the midpoint of a line between two polar coords.
 261  */
 262 static void
 263 midpoint2 (LL v1, LL v2, LL *vm_ret,
 264            XYZ *p1_ret, XYZ *p2_ret, XYZ *pm_ret)
 265 {
 266   XYZ p1, p2, pm;
 267   LL vm;
 268   GLfloat hyp;
 269
 270   p1.x = cos (v1.a) * cos (v1.o);
 271   p1.y = cos (v1.a) * sin (v1.o);
 272   p1.z = sin (v1.a);
 273
 274   p2.x = cos (v2.a) * cos (v2.o);
 275   p2.y = cos (v2.a) * sin (v2.o);
 276   p2.z = sin (v2.a);
 277
 278   pm.x = (p1.x + p2.x) / 2;
 279   pm.y = (p1.y + p2.y) / 2;
 280   pm.z = (p1.z + p2.z) / 2;
 281
 282   vm.o = atan2 (pm.y, pm.x);
 283   hyp = sqrt (pm.x * pm.x + pm.y * pm.y);
 284   vm.a = atan2 (pm.z, hyp);
 285
 286   *p1_ret = p1;
 287   *p2_ret = p2;
 288   *pm_ret = pm;
 289   *vm_ret = vm;
 290 }
 291
 292
 293 /* Computes the midpoint of a triangle specified in polar coords.
 294  */
 295 static void
 296 midpoint3 (LL v1, LL v2, LL v3, LL *vm_ret,
 297            XYZ *p1_ret, XYZ *p2_ret, XYZ *p3_ret, XYZ *pm_ret)
 298 {
 299   XYZ p1, p2, p3, pm;
 300   LL vm;
 301   GLfloat hyp;
 302
 303   p1.x = cos (v1.a) * cos (v1.o);
 304   p1.y = cos (v1.a) * sin (v1.o);
 305   p1.z = sin (v1.a);
 306
 307   p2.x = cos (v2.a) * cos (v2.o);
 308   p2.y = cos (v2.a) * sin (v2.o);
 309   p2.z = sin (v2.a);
 310
 311   p3.x = cos (v3.a) * cos (v3.o);
 312   p3.y = cos (v3.a) * sin (v3.o);
 313   p3.z = sin (v3.a);
 314
 315   pm.x = (p1.x + p2.x + p3.x) / 3;
 316   pm.y = (p1.y + p2.y + p3.y) / 3;
 317   pm.z = (p1.z + p2.z + p3.z) / 3;
 318
 319   vm.o = atan2 (pm.y, pm.x);
 320   hyp = sqrt (pm.x * pm.x + pm.y * pm.y);
 321   vm.a = atan2 (pm.z, hyp);
 322
 323   *p1_ret = p1;
 324   *p2_ret = p2;
 325   *p3_ret = p3;
 326   *pm_ret = pm;
 327   *vm_ret = vm;
 328 }
 329
 330
 331 /* Renders a triangular geodesic facet to the given depth.
 332  */
 333 static void
 334 triangle (ModeInfo *mi, LL v1, LL v2, LL v3, int depth)
 335 {
 336   geodesic_configuration *bp = &bps[MI_SCREEN(mi)];
 337
 338   if (depth <= 0)
 339     triangle1 (mi, v1, v2, v3);
 340   else
 341     {
 342       LL v12, v23, v13;
 343       XYZ p1, p2, p3, p12, p23, p13;
 344       GLfloat r = bp->morph_ratio;
 345
 346       midpoint2 (v1, v2, &v12, &p1, &p2, &p12);
 347       midpoint2 (v2, v3, &v23, &p2, &p3, &p23);
 348       midpoint2 (v1, v3, &v13, &p1, &p3, &p13);
 349       depth--;
 350
 351       if (depth == 0 &&
 352           r != 0 &&
 353           (bp->mode == STELLATED || bp->mode == STELLATED2))
 354         {                       /* morph between flat and stellated faces */
 355           XYZ pc, pc2;
 356           LL vc;
 357           midpoint3 (v1, v2, v3, &vc, &p1, &p2, &p3, &pc);
 358
 359           pc2.x = cos (vc.a) * cos (vc.o);
 360           pc2.y = cos (vc.a) * sin (vc.o);
 361           pc2.z = sin (vc.a);
 362
 363           pc.x = pc.x + r * (pc2.x - pc.x);
 364           pc.y = pc.y + r * (pc2.y - pc.y);
 365           pc.z = pc.z + r * (pc2.z - pc.z);
 366
 367           triangle0 (mi, p1, p2, pc);
 368           triangle0 (mi, p2, p3, pc);
 369           triangle0 (mi, p3, p1, pc);
 370         }
 371       else if (depth == 0 && r < 1)
 372         {                       /* morph between flat and sphere-oid faces */
 373           XYZ p12b, p23b, p13b;
 374
 375           p12b.x = cos (v12.a) * cos (v12.o);
 376           p12b.y = cos (v12.a) * sin (v12.o);
 377           p12b.z = sin (v12.a);
 378
 379           p23b.x = cos (v23.a) * cos (v23.o);
 380           p23b.y = cos (v23.a) * sin (v23.o);
 381           p23b.z = sin (v23.a);
 382
 383           p13b.x = cos (v13.a) * cos (v13.o);
 384           p13b.y = cos (v13.a) * sin (v13.o);
 385           p13b.z = sin (v13.a);
 386
 387           p12.x = p12.x + r * (p12b.x - p12.x);
 388           p12.y = p12.y + r * (p12b.y - p12.y);
 389           p12.z = p12.z + r * (p12b.z - p12.z);
 390
 391           p23.x = p23.x + r * (p23b.x - p23.x);
 392           p23.y = p23.y + r * (p23b.y - p23.y);
 393           p23.z = p23.z + r * (p23b.z - p23.z);
 394
 395           p13.x = p13.x + r * (p13b.x - p13.x);
 396           p13.y = p13.y + r * (p13b.y - p13.y);
 397           p13.z = p13.z + r * (p13b.z - p13.z);
 398
 399           triangle0 (mi, p1,  p12, p13);
 400           triangle0 (mi, p12, p2,  p23);
 401           triangle0 (mi, p13, p23, p3);
 402           triangle0 (mi, p12, p23, p13);
 403         }
 404       else
 405         {
 406           triangle (mi, v1,  v12, v13, depth);
 407           triangle (mi, v12, v2,  v23, depth);
 408           triangle (mi, v13, v23, v3,  depth);
 409           triangle (mi, v12, v23, v13, depth);
 410         }
 411     }
 412 }
 413
 414
 415 /* Renders a geodesic sphere to the given depth (frequency).
 416  */
 417 static void
 418 make_geodesic (ModeInfo *mi, int depth)
 419 {
 420   GLfloat th0 = atan (0.5);  /* lat division: 26.57 deg */
 421   GLfloat s = M_PI / 5;      /* lon division: 72 deg    */
 422   int i;
 423
 424   for (i = 0; i < 10; i++)
 425     {
 426       GLfloat th1 = s * i;
 427       GLfloat th2 = s * (i+1);
 428       GLfloat th3 = s * (i+2);
 429       LL v1, v2, v3, vc;
 430       v1.a = th0;    v1.o = th1;
 431       v2.a = th0;    v2.o = th3;
 432       v3.a = -th0;   v3.o = th2;
 433       vc.a = M_PI/2; vc.o = th2;
 434
 435       if (i & 1)                        /* north */
 436         {
 437           triangle (mi, v1, v2, vc, depth);
 438           triangle (mi, v2, v1, v3, depth);
 439         }
 440       else                              /* south */
 441         {
 442           v1.a = -v1.a;
 443           v2.a = -v2.a;
 444           v3.a = -v3.a;
 445           vc.a = -vc.a;
 446           triangle (mi, v2, v1, vc, depth);
 447           triangle (mi, v1, v2, v3, depth);
 448         }
 449     }
 450 }
 451
 452
 453 /* Window management, etc
 454  */
 455 ENTRYPOINT void
 456 reshape_geodesic (ModeInfo *mi, int width, int height)
 457 {
 458   GLfloat h = (GLfloat) height / (GLfloat) width;
 459
 460   glViewport (0, 0, (GLint) width, (GLint) height);
 461
 462   glMatrixMode(GL_PROJECTION);
 463   glLoadIdentity();
 464   gluPerspective (30.0, 1/h, 1.0, 100.0);
 465
 466   glMatrixMode(GL_MODELVIEW);
 467   glLoadIdentity();
 468   gluLookAt( 0.0, 0.0, 30.0,
 469              0.0, 0.0, 0.0,
 470              0.0, 1.0, 0.0);
 471
 472 # ifdef HAVE_MOBILE     /* Keep it the same relative size when rotated. */
 473   {
 474     int o = (int) current_device_rotation();
 475     if (o != 0 && o != 180 && o != -180)
 476       glScalef (1/h, 1/h, 1/h);
 477   }
 478 # endif
 479
 480   glClear(GL_COLOR_BUFFER_BIT);
 481 }
 482
 483
 484
 485 ENTRYPOINT void
 486 init_geodesic (ModeInfo *mi)
 487 {
 488   geodesic_configuration *bp;
 489   int wire = MI_IS_WIREFRAME(mi);
 490
 491   MI_INIT (mi, bps, NULL);
 492
 493   bp = &bps[MI_SCREEN(mi)];
 494
 495   bp->glx_context = init_GL(mi);
 496
 497   reshape_geodesic (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 498
 499   /* This comes first because it sets wire. */
 500   if (!mode_str || !*mode_str)
 501     mode_str = DEF_MODE;
 502   if (!strcasecmp(mode_str, "random")) {
 503     bp->random_p = 1;
 504     bp->mode = MESH + (random() % (STELLATED2 - MESH + 1));
 505   } else if (!strcasecmp(mode_str, "mesh")) {
 506     bp->mode = MESH;
 507   } else if (!strcasecmp(mode_str, "solid")) {
 508     bp->mode = SOLID;
 509   } else if (!strcasecmp(mode_str, "stellated")) {
 510     bp->mode = STELLATED;
 511   } else if (!strcasecmp(mode_str, "stellated2")) {
 512     bp->mode = STELLATED2;
 513   } else if (!strcasecmp(mode_str, "wire")) {
 514     bp->mode = WIRE;
 515     MI_IS_WIREFRAME(mi) = wire = 1;
 516   } else {
 517     fprintf (stderr, "%s: unknown mode: %s\n", progname, mode_str);
 518     exit (1);
 519   }
 520
 521
 522   {
 523     static GLfloat cspec[4] = {1.0, 1.0, 1.0, 1.0};
 524     static const GLfloat shiny = 128.0;
 525
 526     static GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0};
 527     static GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};
 528     static GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
 529     static GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};
 530
 531     glLightfv(GL_LIGHT0, GL_POSITION, pos);
 532     glLightfv(GL_LIGHT0, GL_AMBIENT,  amb);
 533     glLightfv(GL_LIGHT0, GL_DIFFUSE,  dif);
 534     glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
 535
 536     glMaterialfv (GL_FRONT, GL_SPECULAR,  cspec);
 537     glMateriali  (GL_FRONT, GL_SHININESS, shiny);
 538
 539     glLineWidth (3);
 540   }
 541
 542   if (! wire)
 543     {
 544       glEnable (GL_DEPTH_TEST);
 545       glEnable (GL_BLEND);
 546       glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 547     }
 548
 549   /* Actually this looks pretty good in -wire with lighting! */
 550   glEnable (GL_LIGHTING);
 551   glEnable (GL_LIGHT0);
 552
 553   if (! bp->rot)
 554   {
 555     double spin_speed   = 0.25  * speed;
 556     double wander_speed = 0.01 * speed;
 557     double spin_accel   = 0.2;
 558
 559     bp->rot = make_rotator (do_spin ? spin_speed : 0,
 560                             do_spin ? spin_speed : 0,
 561                             do_spin ? spin_speed : 0,
 562                             spin_accel,
 563                             do_wander ? wander_speed : 0,
 564                             True);
 565     bp->trackball = gltrackball_init (True);
 566   }
 567
 568   if (MI_COUNT(mi) < 1) MI_COUNT(mi) = 1;
 569
 570   bp->ncolors = 1024;
 571   if (! bp->colors)
 572     bp->colors = (XColor *) calloc(bp->ncolors, sizeof(XColor));
 573   make_smooth_colormap (0, 0, 0,
 574                         bp->colors, &bp->ncolors,
 575                         False, 0, False);
 576   bp->ccolor = 0;
 577   bp->depth = 1;        /* start 1 up from the icosahedron */
 578   bp->delta = 0.003;
 579
 580 #if 0
 581   bp->thickness = 1;
 582   bp->thickdelta = 0.0007;
 583 #else
 584   bp->thickness = 0.1;
 585   bp->thickdelta = 0;
 586 #endif
 587 }
 588
 589
 590 ENTRYPOINT Bool
 591 geodesic_handle_event (ModeInfo *mi, XEvent *event)
 592 {
 593   geodesic_configuration *bp = &bps[MI_SCREEN(mi)];
 594
 595   if (gltrackball_event_handler (event, bp->trackball,
 596                                  MI_WIDTH (mi), MI_HEIGHT (mi),
 597                                  &bp->button_down_p))
 598     return True;
 599   else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
 600     {
 601       mode_str = "random";
 602       init_geodesic (mi);
 603       return True;
 604     }
 605
 606   return False;
 607 }
 608
 609
 610 ENTRYPOINT void
 611 draw_geodesic (ModeInfo *mi)
 612 {
 613   int wire = MI_IS_WIREFRAME(mi);
 614   geodesic_configuration *bp = &bps[MI_SCREEN(mi)];
 615   Display *dpy = MI_DISPLAY(mi);
 616   Window window = MI_WINDOW(mi);
 617
 618   if (!bp->glx_context)
 619     return;
 620
 621   glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
 622
 623   if (! wire)
 624     glShadeModel(GL_SMOOTH);
 625
 626   glEnable(GL_DEPTH_TEST);
 627   glEnable(GL_NORMALIZE);
 628   glEnable(GL_CULL_FACE);
 629
 630   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 631
 632   glPushMatrix ();
 633
 634   {
 635     double x, y, z;
 636     get_position (bp->rot, &x, &y, &z, !bp->button_down_p);
 637     glTranslatef((x - 0.5) * 8,
 638                  (y - 0.5) * 8,
 639                  (z - 0.5) * 15);
 640
 641     gltrackball_rotate (bp->trackball);
 642
 643     get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p);
 644     glRotatef (x * 360, 1.0, 0.0, 0.0);
 645     glRotatef (y * 360, 0.0, 1.0, 0.0);
 646     glRotatef (z * 360, 0.0, 0.0, 1.0);
 647   }
 648
 649   bp->color1[0] = bp->colors[bp->ccolor].red    / 65536.0;
 650   bp->color1[1] = bp->colors[bp->ccolor].green  / 65536.0;
 651   bp->color1[2] = bp->colors[bp->ccolor].blue   / 65536.0;
 652   bp->color1[3] = 1;
 653
 654   bp->color2[0] = bp->colors[bp->ccolor2].red   / 65536.0;
 655   bp->color2[1] = bp->colors[bp->ccolor2].green / 65536.0;
 656   bp->color2[2] = bp->colors[bp->ccolor2].blue  / 65536.0;
 657   bp->color2[3] = 1;
 658
 659   bp->ccolor  = (bp->ccolor + 1) % bp->ncolors;
 660   bp->ccolor2 = (bp->ccolor + bp->ncolors / 2) % bp->ncolors;
 661
 662   mi->polygon_count = 0;
 663
 664   glScalef (10, 10, 10);
 665
 666   {
 667     GLfloat r = bp->depth - floor(bp->depth);
 668     GLfloat alpha, morph1, morph2;
 669     int d1, d2;
 670
 671     /* Two ranges: first for fading in the new segments.
 672        Second for morphing the segments into position.
 673      */
 674     GLfloat range = 0.15;
 675     GLfloat min1 = (0.5 - range) / 2;
 676     GLfloat max1 = 0.5 - min1;
 677     GLfloat min2 = 0.5 + min1;
 678     GLfloat max2 = 0.5 + max1;
 679
 680     if (r < min1)                       /* old alone */
 681       {
 682         d1 = d2 = floor (bp->depth);
 683         morph1 = morph2 = 1;
 684         alpha = 1;
 685       }
 686     else if (r < max1 &&                /* fade to new flat */
 687              (bp->mode == MESH ||
 688               bp->mode == STELLATED ||
 689               bp->mode == STELLATED2))
 690       {
 691         d1 = floor (bp->depth);
 692         d2 = ceil (bp->depth);
 693         morph1 = 1;
 694         morph2 = 0;
 695         alpha = (r - min1) / (max1 - min1);
 696
 697         if (bp->mode == STELLATED || bp->mode == STELLATED2)
 698           {
 699             morph1 = 1 - alpha;            /* de-stellate while fading out */
 700             morph1 = 2 * (morph1 - 0.5);   /* do it faster */
 701             if (morph1 < 0) morph1 = 0;
 702           }
 703       }
 704     else if (r < min2)                  /* new flat */
 705       {
 706         d1 = d2 = ceil (bp->depth);
 707         morph1 = morph2 = 0;
 708         alpha = 1;
 709       }
 710     else if (r < max2)                  /* morph */
 711       {
 712         d1 = d2 = ceil (bp->depth);
 713         morph1 = morph2 = (r - min2) / (max2 - min2);
 714         alpha = 1;
 715       }
 716     else                                /* new alone */
 717       {
 718         d1 = d2 = ceil (bp->depth);
 719         morph1 = morph2 = 1;
 720         alpha = 1;
 721       }
 722
 723     mi->recursion_depth = d2 + r;
 724
 725     if (bp->mode == STELLATED2)
 726       {
 727         morph1 = -morph1;
 728         morph2 = -morph2;
 729       }
 730
 731     if (d1 != d2)
 732       {
 733         if (alpha > 0.5)   /* always draw the more transparent one first */
 734           {
 735             int s1; GLfloat s2;
 736             s1 = d1; d1 = d2; d2 = s1;
 737             s2 = morph1; morph1 = morph2; morph2 = s2;
 738             alpha = 1 - alpha;
 739           }
 740         bp->color1[3] = 1 - alpha;
 741         bp->color2[3] = 1 - alpha;
 742
 743         if (! wire)
 744           glDisable (GL_POLYGON_OFFSET_FILL);
 745
 746         bp->morph_ratio = morph1;
 747         make_geodesic (mi, d1);
 748
 749         /* Make the less-transparent object take precedence */
 750         if (!wire)
 751           {
 752             glEnable (GL_POLYGON_OFFSET_FILL);
 753             glPolygonOffset (1.0, 1.0);
 754           }
 755       }
 756
 757     bp->color1[3] = alpha;
 758     bp->color2[3] = alpha;
 759
 760     bp->morph_ratio = morph2;
 761     make_geodesic (mi, d2);
 762   }
 763
 764   glPopMatrix ();
 765
 766   if (mi->fps_p) do_fps (mi);
 767   glFinish();
 768
 769   glXSwapBuffers(dpy, window);
 770
 771
 772   if (! bp->button_down_p)
 773     {
 774       bp->depth += speed * bp->delta;
 775       bp->thickness += speed * bp->thickdelta;
 776
 777       if (bp->depth > MI_COUNT(mi)-1)
 778         {
 779           bp->depth = MI_COUNT(mi)-1;
 780           bp->delta = -fabs (bp->delta);
 781         }
 782       else if (bp->depth < 0)
 783         {
 784           bp->depth = 0;
 785           bp->delta = fabs (bp->delta);
 786
 787           /* Randomize the mode again when we hit the bottom state.
 788              #### I wish this did a fade instead of a jump-cut.
 789            */
 790           if (bp->random_p)
 791             bp->mode = MESH + (random() % (STELLATED2 - MESH + 1));
 792         }
 793
 794       if (bp->thickness > 1)
 795         {
 796           bp->thickness = 1;
 797           bp->thickdelta = -fabs (bp->thickdelta);
 798         }
 799       else if (bp->thickness < 0)
 800         {
 801           bp->thickness = 0;
 802           bp->thickdelta = fabs (bp->thickdelta);
 803         }
 804     }
 805 }
 806
 807 XSCREENSAVER_MODULE ("Geodesic", geodesic)
 808
 809 #endif /* USE_GL */