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

   1 /* geodesic, Copyright (c) 2013 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 Bool
 477 geodesic_handle_event (ModeInfo *mi, XEvent *event)
 478 {
 479   geodesic_configuration *bp = &bps[MI_SCREEN(mi)];
 480
 481   if (event->xany.type == ButtonPress &&
 482       event->xbutton.button == Button1)
 483     {
 484       bp->button_down_p = True;
 485       gltrackball_start (bp->trackball,
 486                          event->xbutton.x, event->xbutton.y,
 487                          MI_WIDTH (mi), MI_HEIGHT (mi));
 488       return True;
 489     }
 490   else if (event->xany.type == ButtonRelease &&
 491            event->xbutton.button == Button1)
 492     {
 493       bp->button_down_p = False;
 494       return True;
 495     }
 496   else if (event->xany.type == ButtonPress &&
 497            (event->xbutton.button == Button4 ||
 498             event->xbutton.button == Button5 ||
 499             event->xbutton.button == Button6 ||
 500             event->xbutton.button == Button7))
 501     {
 502       gltrackball_mousewheel (bp->trackball, event->xbutton.button, 3,
 503                               !!event->xbutton.state);
 504       return True;
 505     }
 506   else if (event->xany.type == MotionNotify &&
 507            bp->button_down_p)
 508     {
 509       gltrackball_track (bp->trackball,
 510                          event->xmotion.x, event->xmotion.y,
 511                          MI_WIDTH (mi), MI_HEIGHT (mi));
 512       return True;
 513     }
 514
 515   return False;
 516 }
 517
 518
 519 ENTRYPOINT void
 520 init_geodesic (ModeInfo *mi)
 521 {
 522   geodesic_configuration *bp;
 523   int wire = MI_IS_WIREFRAME(mi);
 524
 525   if (!bps) {
 526     bps = (geodesic_configuration *)
 527       calloc (MI_NUM_SCREENS(mi), sizeof (geodesic_configuration));
 528     if (!bps) {
 529       fprintf(stderr, "%s: out of memory\n", progname);
 530       exit(1);
 531     }
 532   }
 533
 534   bp = &bps[MI_SCREEN(mi)];
 535
 536   bp->glx_context = init_GL(mi);
 537
 538   reshape_geodesic (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 539
 540   /* This comes first because it sets wire. */
 541   if (!mode_str || !*mode_str)
 542     mode_str = DEF_MODE;
 543   if (!strcasecmp(mode_str, "random")) {
 544     bp->random_p = 1;
 545     bp->mode = MESH + (random() % (STELLATED2 - MESH + 1));
 546   } else if (!strcasecmp(mode_str, "mesh")) {
 547     bp->mode = MESH;
 548   } else if (!strcasecmp(mode_str, "solid")) {
 549     bp->mode = SOLID;
 550   } else if (!strcasecmp(mode_str, "stellated")) {
 551     bp->mode = STELLATED;
 552   } else if (!strcasecmp(mode_str, "stellated2")) {
 553     bp->mode = STELLATED2;
 554   } else if (!strcasecmp(mode_str, "wire")) {
 555     bp->mode = WIRE;
 556     MI_IS_WIREFRAME(mi) = wire = 1;
 557   } else {
 558     fprintf (stderr, "%s: unknown mode: %s\n", progname, mode_str);
 559     exit (1);
 560   }
 561
 562
 563   {
 564     static GLfloat cspec[4] = {1.0, 1.0, 1.0, 1.0};
 565     static const GLfloat shiny = 128.0;
 566
 567     static GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0};
 568     static GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};
 569     static GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
 570     static GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};
 571
 572     glLightfv(GL_LIGHT0, GL_POSITION, pos);
 573     glLightfv(GL_LIGHT0, GL_AMBIENT,  amb);
 574     glLightfv(GL_LIGHT0, GL_DIFFUSE,  dif);
 575     glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
 576
 577     glMaterialfv (GL_FRONT, GL_SPECULAR,  cspec);
 578     glMateriali  (GL_FRONT, GL_SHININESS, shiny);
 579
 580     glLineWidth (3);
 581   }
 582
 583   if (! wire)
 584     {
 585       glEnable (GL_DEPTH_TEST);
 586       glEnable (GL_BLEND);
 587       glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 588     }
 589
 590   /* Actually this looks pretty good in -wire with lighting! */
 591   glEnable (GL_LIGHTING);
 592   glEnable (GL_LIGHT0);
 593
 594   {
 595     double spin_speed   = 0.25  * speed;
 596     double wander_speed = 0.01 * speed;
 597     double spin_accel   = 0.2;
 598
 599     bp->rot = make_rotator (do_spin ? spin_speed : 0,
 600                             do_spin ? spin_speed : 0,
 601                             do_spin ? spin_speed : 0,
 602                             spin_accel,
 603                             do_wander ? wander_speed : 0,
 604                             True);
 605     bp->trackball = gltrackball_init ();
 606   }
 607
 608   if (MI_COUNT(mi) < 1) MI_COUNT(mi) = 1;
 609
 610   bp->ncolors = 1024;
 611   bp->colors = (XColor *) calloc(bp->ncolors, sizeof(XColor));
 612   make_smooth_colormap (0, 0, 0,
 613                         bp->colors, &bp->ncolors,
 614                         False, 0, False);
 615   bp->ccolor = 0;
 616   bp->depth = 1;        /* start 1 up from the icosahedron */
 617   bp->delta = 0.003;
 618
 619 #if 0
 620   bp->thickness = 1;
 621   bp->thickdelta = 0.0007;
 622 #else
 623   bp->thickness = 0.1;
 624   bp->thickdelta = 0;
 625 #endif
 626 }
 627
 628
 629 ENTRYPOINT void
 630 draw_geodesic (ModeInfo *mi)
 631 {
 632   int wire = MI_IS_WIREFRAME(mi);
 633   geodesic_configuration *bp = &bps[MI_SCREEN(mi)];
 634   Display *dpy = MI_DISPLAY(mi);
 635   Window window = MI_WINDOW(mi);
 636
 637   if (!bp->glx_context)
 638     return;
 639
 640   glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bp->glx_context));
 641
 642   if (! wire)
 643     glShadeModel(GL_SMOOTH);
 644
 645   glEnable(GL_DEPTH_TEST);
 646   glEnable(GL_NORMALIZE);
 647   glEnable(GL_CULL_FACE);
 648
 649   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 650
 651   glPushMatrix ();
 652
 653   {
 654     double x, y, z;
 655     get_position (bp->rot, &x, &y, &z, !bp->button_down_p);
 656     glTranslatef((x - 0.5) * 8,
 657                  (y - 0.5) * 8,
 658                  (z - 0.5) * 15);
 659
 660     /* Do it twice because we don't track the device's orientation. */
 661     glRotatef( current_device_rotation(), 0, 0, 1);
 662     gltrackball_rotate (bp->trackball);
 663     glRotatef(-current_device_rotation(), 0, 0, 1);
 664
 665     get_rotation (bp->rot, &x, &y, &z, !bp->button_down_p);
 666     glRotatef (x * 360, 1.0, 0.0, 0.0);
 667     glRotatef (y * 360, 0.0, 1.0, 0.0);
 668     glRotatef (z * 360, 0.0, 0.0, 1.0);
 669   }
 670
 671   bp->color1[0] = bp->colors[bp->ccolor].red    / 65536.0;
 672   bp->color1[1] = bp->colors[bp->ccolor].green  / 65536.0;
 673   bp->color1[2] = bp->colors[bp->ccolor].blue   / 65536.0;
 674   bp->color1[3] = 1;
 675
 676   bp->color2[0] = bp->colors[bp->ccolor2].red   / 65536.0;
 677   bp->color2[1] = bp->colors[bp->ccolor2].green / 65536.0;
 678   bp->color2[2] = bp->colors[bp->ccolor2].blue  / 65536.0;
 679   bp->color2[3] = 1;
 680
 681   bp->ccolor  = (bp->ccolor + 1) % bp->ncolors;
 682   bp->ccolor2 = (bp->ccolor + bp->ncolors / 2) % bp->ncolors;
 683
 684   mi->polygon_count = 0;
 685
 686   glScalef (10, 10, 10);
 687
 688   {
 689     GLfloat r = bp->depth - floor(bp->depth);
 690     GLfloat alpha, morph1, morph2;
 691     int d1, d2;
 692
 693     /* Two ranges: first for fading in the new segments.
 694        Second for morphing the segments into position.
 695      */
 696     GLfloat range = 0.15;
 697     GLfloat min1 = (0.5 - range) / 2;
 698     GLfloat max1 = 0.5 - min1;
 699     GLfloat min2 = 0.5 + min1;
 700     GLfloat max2 = 0.5 + max1;
 701
 702     if (r < min1)                       /* old alone */
 703       {
 704         d1 = d2 = floor (bp->depth);
 705         morph1 = morph2 = 1;
 706         alpha = 1;
 707       }
 708     else if (r < max1 &&                /* fade to new flat */
 709              (bp->mode == MESH ||
 710               bp->mode == STELLATED ||
 711               bp->mode == STELLATED2))
 712       {
 713         d1 = floor (bp->depth);
 714         d2 = ceil (bp->depth);
 715         morph1 = 1;
 716         morph2 = 0;
 717         alpha = (r - min1) / (max1 - min1);
 718
 719         if (bp->mode == STELLATED || bp->mode == STELLATED2)
 720           {
 721             morph1 = 1 - alpha;            /* de-stellate while fading out */
 722             morph1 = 2 * (morph1 - 0.5);   /* do it faster */
 723             if (morph1 < 0) morph1 = 0;
 724           }
 725       }
 726     else if (r < min2)                  /* new flat */
 727       {
 728         d1 = d2 = ceil (bp->depth);
 729         morph1 = morph2 = 0;
 730         alpha = 1;
 731       }
 732     else if (r < max2)                  /* morph */
 733       {
 734         d1 = d2 = ceil (bp->depth);
 735         morph1 = morph2 = (r - min2) / (max2 - min2);
 736         alpha = 1;
 737       }
 738     else                                /* new alone */
 739       {
 740         d1 = d2 = ceil (bp->depth);
 741         morph1 = morph2 = 1;
 742         alpha = 1;
 743       }
 744
 745     mi->recursion_depth = d2 + r;
 746
 747     if (bp->mode == STELLATED2)
 748       {
 749         morph1 = -morph1;
 750         morph2 = -morph2;
 751       }
 752
 753     if (d1 != d2)
 754       {
 755         if (alpha > 0.5)   /* always draw the more transparent one first */
 756           {
 757             int s1; GLfloat s2;
 758             s1 = d1; d1 = d2; d2 = s1;
 759             s2 = morph1; morph1 = morph2; morph2 = s2;
 760             alpha = 1 - alpha;
 761           }
 762         bp->color1[3] = 1 - alpha;
 763         bp->color2[3] = 1 - alpha;
 764
 765         if (! wire)
 766           glDisable (GL_POLYGON_OFFSET_FILL);
 767
 768         bp->morph_ratio = morph1;
 769         make_geodesic (mi, d1);
 770
 771         /* Make the less-transparent object take precedence */
 772         if (!wire)
 773           {
 774             glEnable (GL_POLYGON_OFFSET_FILL);
 775             glPolygonOffset (1.0, 1.0);
 776           }
 777       }
 778
 779     bp->color1[3] = alpha;
 780     bp->color2[3] = alpha;
 781
 782     bp->morph_ratio = morph2;
 783     make_geodesic (mi, d2);
 784   }
 785
 786   glPopMatrix ();
 787
 788   if (mi->fps_p) do_fps (mi);
 789   glFinish();
 790
 791   glXSwapBuffers(dpy, window);
 792
 793
 794   if (! bp->button_down_p)
 795     {
 796       bp->depth += speed * bp->delta;
 797       bp->thickness += speed * bp->thickdelta;
 798
 799       if (bp->depth > MI_COUNT(mi)-1)
 800         {
 801           bp->depth = MI_COUNT(mi)-1;
 802           bp->delta = -fabs (bp->delta);
 803         }
 804       else if (bp->depth < 0)
 805         {
 806           bp->depth = 0;
 807           bp->delta = fabs (bp->delta);
 808
 809           /* Randomize the mode again when we hit the bottom state.
 810              #### I wish this did a fade instead of a jump-cut.
 811            */
 812           if (bp->random_p)
 813             bp->mode = MESH + (random() % (STELLATED2 - MESH + 1));
 814         }
 815
 816       if (bp->thickness > 1)
 817         {
 818           bp->thickness = 1;
 819           bp->thickdelta = -fabs (bp->thickdelta);
 820         }
 821       else if (bp->thickness < 0)
 822         {
 823           bp->thickness = 0;
 824           bp->thickdelta = fabs (bp->thickdelta);
 825         }
 826     }
 827 }
 828
 829 XSCREENSAVER_MODULE ("Geodesic", geodesic)
 830
 831 #endif /* USE_GL */