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