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

   1 /* hypertorus --- Shows a hypertorus that rotates in 4d */
   2
   3 #if 0
   4 static const char sccsid[] = "@(#)hypertorus.c  1.2 05/09/28 xlockmore";
   5 #endif
   6
   7 /* Copyright (c) 2003-2007 Carsten Steger <carsten@mirsanmir.org>. */
   8
   9 /*
  10  * Permission to use, copy, modify, and distribute this software and its
  11  * documentation for any purpose and without fee is hereby granted,
  12  * provided that the above copyright notice appear in all copies and that
  13  * both that copyright notice and this permission notice appear in
  14  * supporting documentation.
  15  *
  16  * This file is provided AS IS with no warranties of any kind.  The author
  17  * shall have no liability with respect to the infringement of copyrights,
  18  * trade secrets or any patents by this file or any part thereof.  In no
  19  * event will the author be liable for any lost revenue or profits or
  20  * other special, indirect and consequential damages.
  21  *
  22  * REVISION HISTORY:
  23  * C. Steger - 03/05/18: Initial version
  24  * C. Steger - 05/09/28: Added the spirals appearance mode
  25  *                       and trackball support
  26  * C. Steger - 07/01/23: Improved 4d trackball support
  27  */
  28
  29 /*
  30  * This program shows the Clifford torus as it rotates in 4d.  The Clifford
  31  * torus is a torus lies on the "surface" of the hypersphere in 4d.  The
  32  * program projects the 4d torus to 3d using either a perspective or an
  33  * orthographic projection.  Of the two alternatives, the perspecitve
  34  * projection looks much more appealing.  In orthographic projections the
  35  * torus degenerates into a doubly covered cylinder for some angles.  The
  36  * projected 3d torus can then be projected to the screen either perspectively
  37  * or orthographically.  There are three display modes for the torus: mesh
  38  * (wireframe), solid, or transparent.  Furthermore, the appearance of the
  39  * torus can be as a solid object or as a set of see-through bands or
  40  * see-through spirals.  Finally, the colors with with the torus is drawn can
  41  * be set to either two-sided or to colorwheel.  In the first case, the torus
  42  * is drawn with red on the outside and green on the inside.  This mode
  43  * enables you to see that the torus turns inside-out as it rotates in 4d.
  44  * The second mode draws the torus in a fully saturated color wheel.  This
  45  * gives a very nice effect when combined with the see-through bands or
  46  * see-through spirals mode.  The rotation speed for each of the six planes
  47  * around which the torus rotates can be chosen.  This program is very much
  48  * inspired by Thomas Banchoff's book "Beyond the Third Dimension: Geometry,
  49  * Computer Graphics, and Higher Dimensions", Scientific American Library,
  50  * 1990.
  51  */
  52
  53 #ifndef M_PI
  54 #define M_PI 3.14159265358979323846
  55 #endif
  56
  57 #define DISP_WIREFRAME             0
  58 #define DISP_WIREFRAME_STR        "0"
  59 #define DISP_SURFACE               1
  60 #define DISP_SURFACE_STR          "1"
  61 #define DISP_TRANSPARENT           2
  62 #define DISP_TRANSPARENT_STR      "2"
  63
  64 #define APPEARANCE_SOLID           0
  65 #define APPEARANCE_SOLID_STR      "0"
  66 #define APPEARANCE_BANDS           1
  67 #define APPEARANCE_BANDS_STR      "1"
  68 #define APPEARANCE_SPIRALS         2
  69 #define APPEARANCE_SPIRALS_STR    "2"
  70 #define APPEARANCE_SPIRALS_1       3
  71 #define APPEARANCE_SPIRALS_1_STR  "3"
  72 #define APPEARANCE_SPIRALS_2       4
  73 #define APPEARANCE_SPIRALS_2_STR  "4"
  74 #define APPEARANCE_SPIRALS_4       5
  75 #define APPEARANCE_SPIRALS_4_STR  "5"
  76 #define APPEARANCE_SPIRALS_8       6
  77 #define APPEARANCE_SPIRALS_8_STR  "6"
  78 #define APPEARANCE_SPIRALS_16      7
  79 #define APPEARANCE_SPIRALS_16_STR "7"
  80
  81 #define COLORS_TWOSIDED            0
  82 #define COLORS_TWOSIDED_STR       "0"
  83 #define COLORS_COLORWHEEL          1
  84 #define COLORS_COLORWHEEL_STR     "1"
  85
  86 #define DISP_3D_PERSPECTIVE        0
  87 #define DISP_3D_PERSPECTIVE_STR   "0"
  88 #define DISP_3D_ORTHOGRAPHIC       1
  89 #define DISP_3D_ORTHOGRAPHIC_STR  "1"
  90
  91 #define DISP_4D_PERSPECTIVE        0
  92 #define DISP_4D_PERSPECTIVE_STR   "0"
  93 #define DISP_4D_ORTHOGRAPHIC       1
  94 #define DISP_4D_ORTHOGRAPHIC_STR  "1"
  95
  96 #define DALPHA                     1.1
  97 #define DALPHA_STR                "1.1"
  98 #define DBETA                      1.3
  99 #define DBETA_STR                 "1.3"
 100 #define DDELTA                     1.5
 101 #define DDELTA_STR                "1.5"
 102 #define DZETA                      1.7
 103 #define DZETA_STR                 "1.7"
 104 #define DETA                       1.9
 105 #define DETA_STR                  "1.9"
 106 #define DTHETA                     2.1
 107 #define DTHETA_STR                "2.1"
 108
 109 #define DEF_DISPLAY_MODE           DISP_TRANSPARENT_STR
 110 #define DEF_APPEARANCE             APPEARANCE_BANDS_STR
 111 #define DEF_COLORS                 COLORS_COLORWHEEL_STR
 112 #define DEF_3D_PROJECTION          DISP_3D_PERSPECTIVE_STR
 113 #define DEF_4D_PROJECTION          DISP_4D_PERSPECTIVE_STR
 114 #define DEF_DALPHA                 DALPHA_STR
 115 #define DEF_DBETA                  DBETA_STR
 116 #define DEF_DDELTA                 DDELTA_STR
 117 #define DEF_DZETA                  DZETA_STR
 118 #define DEF_DETA                   DETA_STR
 119 #define DEF_DTHETA                 DTHETA_STR
 120
 121 #ifdef STANDALONE
 122 # define DEFAULTS           "*delay:      25000 \n" \
 123                             "*showFPS:    False \n" \
 124
 125 # define refresh_hypertorus 0
 126 # include "xlockmore.h"         /* from the xscreensaver distribution */
 127 #else  /* !STANDALONE */
 128 # include "xlock.h"             /* from the xlockmore distribution */
 129 #endif /* !STANDALONE */
 130
 131 #ifdef USE_GL
 132
 133 #include <X11/keysym.h>
 134
 135 #include "gltrackball.h"
 136
 137
 138 #ifdef USE_MODULES
 139 ModStruct   hypertorus_description =
 140 {"hypertorus", "init_hypertorus", "draw_hypertorus", "release_hypertorus",
 141  "draw_hypertorus", "change_hypertorus", NULL, &hypertorus_opts,
 142  25000, 1, 1, 1, 1.0, 4, "",
 143  "Shows a hypertorus rotating in 4d", 0, NULL};
 144
 145 #endif
 146
 147
 148 static int display_mode;
 149 static int appearance;
 150 static int num_spirals;
 151 static int colors;
 152 static int projection_3d;
 153 static int projection_4d;
 154 static float speed_wx;
 155 static float speed_wy;
 156 static float speed_wz;
 157 static float speed_xy;
 158 static float speed_xz;
 159 static float speed_yz;
 160
 161 static const float offset4d[4] = {  0.0,  0.0,  0.0,  2.0 };
 162 static const float offset3d[4] = {  0.0,  0.0, -2.0,  0.0 };
 163
 164
 165 static XrmOptionDescRec opts[] =
 166 {
 167   {"-mode",            ".hypertorus.displayMode",  XrmoptionSepArg, 0 },
 168   {"-wireframe",       ".hypertorus.displayMode",  XrmoptionNoArg,
 169                        DISP_WIREFRAME_STR },
 170   {"-surface",         ".hypertorus.displayMode",  XrmoptionNoArg,
 171                        DISP_SURFACE_STR },
 172   {"-transparent",     ".hypertorus.displayMode",  XrmoptionNoArg,
 173                        DISP_TRANSPARENT_STR },
 174
 175   {"-appearance",      ".hypertorus.appearance",   XrmoptionSepArg, 0 },
 176   {"-solid",           ".hypertorus.appearance",   XrmoptionNoArg,
 177                        APPEARANCE_SOLID_STR },
 178   {"-bands",           ".hypertorus.appearance",   XrmoptionNoArg,
 179                        APPEARANCE_BANDS_STR },
 180   {"-spirals-1",       ".hypertorus.appearance",   XrmoptionNoArg,
 181                        APPEARANCE_SPIRALS_1_STR },
 182   {"-spirals-2",       ".hypertorus.appearance",   XrmoptionNoArg,
 183                        APPEARANCE_SPIRALS_2_STR },
 184   {"-spirals-4",       ".hypertorus.appearance",   XrmoptionNoArg,
 185                        APPEARANCE_SPIRALS_4_STR },
 186   {"-spirals-8",       ".hypertorus.appearance",   XrmoptionNoArg,
 187                        APPEARANCE_SPIRALS_8_STR },
 188   {"-spirals-16",      ".hypertorus.appearance",   XrmoptionNoArg,
 189                        APPEARANCE_SPIRALS_16_STR },
 190   {"-twosided",        ".hypertorus.colors",       XrmoptionNoArg,
 191                        COLORS_TWOSIDED_STR },
 192   {"-colorwheel",      ".hypertorus.colors",       XrmoptionNoArg,
 193                        COLORS_COLORWHEEL_STR },
 194   {"-perspective-3d",  ".hypertorus.projection3d", XrmoptionNoArg,
 195                        DISP_3D_PERSPECTIVE_STR },
 196   {"-orthographic-3d", ".hypertorus.projection3d", XrmoptionNoArg,
 197                        DISP_3D_ORTHOGRAPHIC_STR },
 198   {"-perspective-4d",  ".hypertorus.projection4d", XrmoptionNoArg,
 199                        DISP_4D_PERSPECTIVE_STR },
 200   {"-orthographic-4d", ".hypertorus.projection4d", XrmoptionNoArg,
 201                        DISP_4D_ORTHOGRAPHIC_STR },
 202   {"-speed-wx",        ".hypertorus.speedwx",      XrmoptionSepArg, 0 },
 203   {"-speed-wy",        ".hypertorus.speedwy",      XrmoptionSepArg, 0 },
 204   {"-speed-wz",        ".hypertorus.speedwz",      XrmoptionSepArg, 0 },
 205   {"-speed-xy",        ".hypertorus.speedxy",      XrmoptionSepArg, 0 },
 206   {"-speed-xz",        ".hypertorus.speedxz",      XrmoptionSepArg, 0 },
 207   {"-speed-yz",        ".hypertorus.speedyz",      XrmoptionSepArg, 0 }
 208 };
 209
 210 static argtype vars[] =
 211 {
 212   { &display_mode,  "displayMode",  "DisplayMode",
 213     DEF_DISPLAY_MODE,  t_Int },
 214   { &appearance,    "appearance",   "Appearance",
 215     DEF_APPEARANCE,    t_Int },
 216   { &colors,        "colors",       "Colors",
 217     DEF_COLORS,        t_Int },
 218   { &projection_3d, "projection3d", "Projection3d",
 219     DEF_3D_PROJECTION, t_Int },
 220   { &projection_4d, "projection4d", "Projection4d",
 221     DEF_4D_PROJECTION, t_Int },
 222   { &speed_wx,      "speedwx",      "Speedwx",
 223     DEF_DALPHA,        t_Float},
 224   { &speed_wy,      "speedwy",      "Speedwy",
 225     DEF_DBETA,         t_Float},
 226   { &speed_wz,      "speedwz",      "Speedwz",
 227     DEF_DDELTA,        t_Float},
 228   { &speed_xy,      "speedxy",      "Speedxy",
 229     DEF_DZETA,         t_Float},
 230   { &speed_xz,      "speedxz",      "Speedxz",
 231     DEF_DETA,          t_Float},
 232   { &speed_yz,      "speedyz",      "Speedyz",
 233     DEF_DTHETA,        t_Float}
 234 };
 235
 236 static OptionStruct desc[] =
 237 {
 238   { "-wireframe",       "display the torus as a wireframe mesh" },
 239   { "-surface",         "display the torus as a solid surface" },
 240   { "-transparent",     "display the torus as a transparent surface" },
 241   { "-solid",           "display the torus as a solid object" },
 242   { "-bands",           "display the torus as see-through bands" },
 243   { "-spirals-{1,2,4,8,16}", "display the torus as see-through spirals" },
 244   { "-twosided",        "display the torus with two colors" },
 245   { "-colorwheel",      "display the torus with a smooth color wheel" },
 246   { "-perspective-3d",  "project the torus perspectively from 3d to 2d" },
 247   { "-orthographic-3d", "project the torus orthographically from 3d to 2d" },
 248   { "-perspective-4d",  "project the torus perspectively from 4d to 3d" },
 249   { "-orthographic-4d", "project the torus orthographically from 4d to 3d" },
 250   { "-speed-wx <arg>",  "rotation speed around the wx plane" },
 251   { "-speed-wy <arg>",  "rotation speed around the wy plane" },
 252   { "-speed-wz <arg>",  "rotation speed around the wz plane" },
 253   { "-speed-xy <arg>",  "rotation speed around the xy plane" },
 254   { "-speed-xz <arg>",  "rotation speed around the xz plane" },
 255   { "-speed-yz <arg>",  "rotation speed around the yz plane" }
 256 };
 257
 258 ENTRYPOINT ModeSpecOpt hypertorus_opts =
 259 {sizeof opts / sizeof opts[0], opts, sizeof vars / sizeof vars[0], vars, desc};
 260
 261
 262 typedef struct {
 263   GLint      WindH, WindW;
 264   GLXContext *glx_context;
 265   /* 4D rotation angles */
 266   float alpha, beta, delta, zeta, eta, theta;
 267   /* Aspect ratio of the current window */
 268   float aspect;
 269   /* Trackball states */
 270   trackball_state *trackballs[2];
 271   int current_trackball;
 272   Bool button_pressed;
 273
 274   float speed_scale;
 275
 276 } hypertorusstruct;
 277
 278 static hypertorusstruct *hyper = (hypertorusstruct *) NULL;
 279
 280
 281 /* Add a rotation around the wx-plane to the matrix m. */
 282 static void rotatewx(float m[4][4], float phi)
 283 {
 284   float c, s, u, v;
 285   int i;
 286
 287   phi *= M_PI/180.0;
 288   c = cos(phi);
 289   s = sin(phi);
 290   for (i=0; i<4; i++)
 291   {
 292     u = m[i][1];
 293     v = m[i][2];
 294     m[i][1] = c*u+s*v;
 295     m[i][2] = -s*u+c*v;
 296   }
 297 }
 298
 299
 300 /* Add a rotation around the wy-plane to the matrix m. */
 301 static void rotatewy(float m[4][4], float phi)
 302 {
 303   float c, s, u, v;
 304   int i;
 305
 306   phi *= M_PI/180.0;
 307   c = cos(phi);
 308   s = sin(phi);
 309   for (i=0; i<4; i++)
 310   {
 311     u = m[i][0];
 312     v = m[i][2];
 313     m[i][0] = c*u-s*v;
 314     m[i][2] = s*u+c*v;
 315   }
 316 }
 317
 318
 319 /* Add a rotation around the wz-plane to the matrix m. */
 320 static void rotatewz(float m[4][4], float phi)
 321 {
 322   float c, s, u, v;
 323   int i;
 324
 325   phi *= M_PI/180.0;
 326   c = cos(phi);
 327   s = sin(phi);
 328   for (i=0; i<4; i++)
 329   {
 330     u = m[i][0];
 331     v = m[i][1];
 332     m[i][0] = c*u+s*v;
 333     m[i][1] = -s*u+c*v;
 334   }
 335 }
 336
 337
 338 /* Add a rotation around the xy-plane to the matrix m. */
 339 static void rotatexy(float m[4][4], float phi)
 340 {
 341   float c, s, u, v;
 342   int i;
 343
 344   phi *= M_PI/180.0;
 345   c = cos(phi);
 346   s = sin(phi);
 347   for (i=0; i<4; i++)
 348   {
 349     u = m[i][2];
 350     v = m[i][3];
 351     m[i][2] = c*u+s*v;
 352     m[i][3] = -s*u+c*v;
 353   }
 354 }
 355
 356
 357 /* Add a rotation around the xz-plane to the matrix m. */
 358 static void rotatexz(float m[4][4], float phi)
 359 {
 360   float c, s, u, v;
 361   int i;
 362
 363   phi *= M_PI/180.0;
 364   c = cos(phi);
 365   s = sin(phi);
 366   for (i=0; i<4; i++)
 367   {
 368     u = m[i][1];
 369     v = m[i][3];
 370     m[i][1] = c*u-s*v;
 371     m[i][3] = s*u+c*v;
 372   }
 373 }
 374
 375
 376 /* Add a rotation around the yz-plane to the matrix m. */
 377 static void rotateyz(float m[4][4], float phi)
 378 {
 379   float c, s, u, v;
 380   int i;
 381
 382   phi *= M_PI/180.0;
 383   c = cos(phi);
 384   s = sin(phi);
 385   for (i=0; i<4; i++)
 386   {
 387     u = m[i][0];
 388     v = m[i][3];
 389     m[i][0] = c*u-s*v;
 390     m[i][3] = s*u+c*v;
 391   }
 392 }
 393
 394
 395 /* Compute the rotation matrix m from the rotation angles. */
 396 static void rotateall(float al, float be, float de, float ze, float et,
 397                       float th, float m[4][4])
 398 {
 399   int i, j;
 400
 401   for (i=0; i<4; i++)
 402     for (j=0; j<4; j++)
 403       m[i][j] = (i==j);
 404   rotatewx(m,al);
 405   rotatewy(m,be);
 406   rotatewz(m,de);
 407   rotatexz(m,et);
 408   rotatexy(m,ze);
 409   rotateyz(m,th);
 410 }
 411
 412
 413 /* Multiply two rotation matrices: o=m*n. */
 414 static void mult_rotmat(float m[4][4], float n[4][4], float o[4][4])
 415 {
 416   int i, j, k;
 417
 418   for (i=0; i<4; i++)
 419   {
 420     for (j=0; j<4; j++)
 421     {
 422       o[i][j] = 0.0;
 423       for (k=0; k<4; k++)
 424         o[i][j] += m[i][k]*n[k][j];
 425     }
 426   }
 427 }
 428
 429
 430 /* Compute a 4D rotation matrix from two unit quaternions. */
 431 static void quats_to_rotmat(float p[4], float q[4], float m[4][4])
 432 {
 433   double al, be, de, ze, et, th;
 434   double r00, r01, r02, r12, r22;
 435
 436   r00 = 1.0-2.0*(p[1]*p[1]+p[2]*p[2]);
 437   r01 = 2.0*(p[0]*p[1]+p[2]*p[3]);
 438   r02 = 2.0*(p[2]*p[0]-p[1]*p[3]);
 439   r12 = 2.0*(p[1]*p[2]+p[0]*p[3]);
 440   r22 = 1.0-2.0*(p[1]*p[1]+p[0]*p[0]);
 441
 442   al = atan2(-r12,r22)*180.0/M_PI;
 443   be = atan2(r02,sqrt(r00*r00+r01*r01))*180.0/M_PI;
 444   de = atan2(-r01,r00)*180.0/M_PI;
 445
 446   r00 = 1.0-2.0*(q[1]*q[1]+q[2]*q[2]);
 447   r01 = 2.0*(q[0]*q[1]+q[2]*q[3]);
 448   r02 = 2.0*(q[2]*q[0]-q[1]*q[3]);
 449   r12 = 2.0*(q[1]*q[2]+q[0]*q[3]);
 450   r22 = 1.0-2.0*(q[1]*q[1]+q[0]*q[0]);
 451
 452   et = atan2(-r12,r22)*180.0/M_PI;
 453   th = atan2(r02,sqrt(r00*r00+r01*r01))*180.0/M_PI;
 454   ze = atan2(-r01,r00)*180.0/M_PI;
 455
 456   rotateall(al,be,de,ze,et,-th,m);
 457 }
 458
 459
 460 /* Compute a fully saturated and bright color based on an angle. */
 461 static void color(double angle)
 462 {
 463   int s;
 464   double t;
 465   float color[4];
 466
 467   if (colors != COLORS_COLORWHEEL)
 468     return;
 469
 470   if (angle >= 0.0)
 471     angle = fmod(angle,2*M_PI);
 472   else
 473     angle = fmod(angle,-2*M_PI);
 474   s = floor(angle/(M_PI/3));
 475   t = angle/(M_PI/3)-s;
 476   if (s >= 6)
 477     s = 0;
 478   switch (s)
 479   {
 480     case 0:
 481       color[0] = 1.0;
 482       color[1] = t;
 483       color[2] = 0.0;
 484       break;
 485     case 1:
 486       color[0] = 1.0-t;
 487       color[1] = 1.0;
 488       color[2] = 0.0;
 489       break;
 490     case 2:
 491       color[0] = 0.0;
 492       color[1] = 1.0;
 493       color[2] = t;
 494       break;
 495     case 3:
 496       color[0] = 0.0;
 497       color[1] = 1.0-t;
 498       color[2] = 1.0;
 499       break;
 500     case 4:
 501       color[0] = t;
 502       color[1] = 0.0;
 503       color[2] = 1.0;
 504       break;
 505     case 5:
 506       color[0] = 1.0;
 507       color[1] = 0.0;
 508       color[2] = 1.0-t;
 509       break;
 510   }
 511   if (display_mode == DISP_TRANSPARENT)
 512     color[3] = 0.7;
 513   else
 514     color[3] = 1.0;
 515   glColor3fv(color);
 516   glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,color);
 517 }
 518
 519
 520 /* Draw a hypertorus projected into 3D.  Note that the spirals appearance
 521    will only work correctly if numu and numv are set to 64 or any higher
 522    power of 2.  Similarly, the banded appearance will only work correctly
 523    if numu and numv are divisible by 4. */
 524 static void hypertorus(ModeInfo *mi, double umin, double umax, double vmin,
 525                        double vmax, int numu, int numv)
 526 {
 527   static const GLfloat mat_diff_red[]         = { 1.0, 0.0, 0.0, 1.0 };
 528   static const GLfloat mat_diff_green[]       = { 0.0, 1.0, 0.0, 1.0 };
 529   static const GLfloat mat_diff_trans_red[]   = { 1.0, 0.0, 0.0, 0.7 };
 530   static const GLfloat mat_diff_trans_green[] = { 0.0, 1.0, 0.0, 0.7 };
 531   float p[3], pu[3], pv[3], n[3], mat[4][4];
 532   int i, j, k, l, m, b, skew;
 533   double u, v, ur, vr;
 534   double cu, su, cv, sv;
 535   double xx[4], xxu[4], xxv[4], x[4], xu[4], xv[4];
 536   double r, s, t;
 537   float q1[4], q2[4], r1[4][4], r2[4][4];
 538   hypertorusstruct *hp = &hyper[MI_SCREEN(mi)];
 539
 540   rotateall(hp->alpha,hp->beta,hp->delta,hp->zeta,hp->eta,hp->theta,r1);
 541
 542   gltrackball_get_quaternion(hp->trackballs[0],q1);
 543   gltrackball_get_quaternion(hp->trackballs[1],q2);
 544   quats_to_rotmat(q1,q2,r2);
 545
 546   mult_rotmat(r2,r1,mat);
 547
 548   if (colors != COLORS_COLORWHEEL)
 549   {
 550     glColor3fv(mat_diff_red);
 551     if (display_mode == DISP_TRANSPARENT)
 552     {
 553       glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_red);
 554       glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_trans_green);
 555     }
 556     else
 557     {
 558       glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,mat_diff_red);
 559       glMaterialfv(GL_BACK,GL_AMBIENT_AND_DIFFUSE,mat_diff_green);
 560     }
 561   }
 562
 563   skew = num_spirals;
 564   ur = umax-umin;
 565   vr = vmax-vmin;
 566   for (i=0; i<numu; i++)
 567   {
 568     if ((appearance == APPEARANCE_BANDS ||
 569          appearance == APPEARANCE_SPIRALS) && ((i & 3) >= 2))
 570       continue;
 571     if (display_mode == DISP_WIREFRAME)
 572       glBegin(GL_QUAD_STRIP);
 573     else
 574       glBegin(GL_TRIANGLE_STRIP);
 575     for (j=0; j<=numv; j++)
 576     {
 577       for (k=0; k<=1; k++)
 578       {
 579         l = (i+k);
 580         m = j;
 581         u = ur*l/numu+umin;
 582         v = vr*m/numv+vmin;
 583         if (appearance == APPEARANCE_SPIRALS)
 584         {
 585           u += 4.0*skew/numv*v;
 586           b = ((i/4)&(skew-1))*(numu/(4*skew));
 587           color(ur*4*b/numu+umin);
 588         }
 589         else
 590         {
 591           color(u);
 592         }
 593         cu = cos(u);
 594         su = sin(u);
 595         cv = cos(v);
 596         sv = sin(v);
 597         xx[0] = cu;
 598         xx[1] = su;
 599         xx[2] = cv;
 600         xx[3] = sv;
 601         xxu[0] = -su;
 602         xxu[1] = cu;
 603         xxu[2] = 0.0;
 604         xxu[3] = 0.0;
 605         xxv[0] = 0.0;
 606         xxv[1] = 0.0;
 607         xxv[2] = -sv;
 608         xxv[3] = cv;
 609         for (l=0; l<4; l++)
 610         {
 611           r = 0.0;
 612           s = 0.0;
 613           t = 0.0;
 614           for (m=0; m<4; m++)
 615           {
 616             r += mat[l][m]*xx[m];
 617             s += mat[l][m]*xxu[m];
 618             t += mat[l][m]*xxv[m];
 619           }
 620           x[l] = r;
 621           xu[l] = s;
 622           xv[l] = t;
 623         }
 624         if (projection_4d == DISP_4D_ORTHOGRAPHIC)
 625         {
 626           for (l=0; l<3; l++)
 627           {
 628             p[l] = (x[l]+offset4d[l])/1.5+offset3d[l];
 629             pu[l] = xu[l];
 630             pv[l] = xv[l];
 631           }
 632         }
 633         else
 634         {
 635           s = x[3]+offset4d[3];
 636           t = s*s;
 637           for (l=0; l<3; l++)
 638           {
 639             r = x[l]+offset4d[l];
 640             p[l] = r/s+offset3d[l];
 641             pu[l] = (xu[l]*s-r*xu[3])/t;
 642             pv[l] = (xv[l]*s-r*xv[3])/t;
 643           }
 644         }
 645         n[0] = pu[1]*pv[2]-pu[2]*pv[1];
 646         n[1] = pu[2]*pv[0]-pu[0]*pv[2];
 647         n[2] = pu[0]*pv[1]-pu[1]*pv[0];
 648         t = sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);
 649         n[0] /= t;
 650         n[1] /= t;
 651         n[2] /= t;
 652         glNormal3fv(n);
 653         glVertex3fv(p);
 654       }
 655     }
 656     glEnd();
 657   }
 658 }
 659
 660
 661 static void init(ModeInfo *mi)
 662 {
 663   static const GLfloat light_ambient[]  = { 0.0, 0.0, 0.0, 1.0 };
 664   static const GLfloat light_diffuse[]  = { 1.0, 1.0, 1.0, 1.0 };
 665   static const GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
 666   static const GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
 667   static const GLfloat mat_specular[]   = { 1.0, 1.0, 1.0, 1.0 };
 668   hypertorusstruct *hp = &hyper[MI_SCREEN(mi)];
 669
 670   if (appearance >= APPEARANCE_SPIRALS_1)
 671   {
 672     num_spirals = 1<<(appearance-APPEARANCE_SPIRALS_1);
 673     appearance = APPEARANCE_SPIRALS;
 674   }
 675   else
 676   {
 677     num_spirals = 0;
 678   }
 679
 680   hp->alpha = 0.0;
 681   hp->beta = 0.0;
 682   hp->delta = 0.0;
 683   hp->zeta = 0.0;
 684   hp->eta = 0.0;
 685   hp->theta = 0.0;
 686
 687   glMatrixMode(GL_PROJECTION);
 688   glLoadIdentity();
 689   if (projection_3d == DISP_3D_PERSPECTIVE)
 690     gluPerspective(60.0,1.0,0.1,100.0);
 691   else
 692     glOrtho(-1.0,1.0,-1.0,1.0,0.1,100.0);;
 693   glMatrixMode(GL_MODELVIEW);
 694   glLoadIdentity();
 695
 696   if (display_mode == DISP_WIREFRAME)
 697   {
 698     glDisable(GL_DEPTH_TEST);
 699     glShadeModel(GL_FLAT);
 700     glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
 701     glDisable(GL_LIGHTING);
 702     glDisable(GL_LIGHT0);
 703     glDisable(GL_BLEND);
 704   }
 705   else if (display_mode == DISP_SURFACE)
 706   {
 707     glEnable(GL_DEPTH_TEST);
 708     glDepthFunc(GL_LESS);
 709     glShadeModel(GL_SMOOTH);
 710     glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
 711     glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
 712     glEnable(GL_LIGHTING);
 713     glEnable(GL_LIGHT0);
 714     glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
 715     glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
 716     glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular);
 717     glLightfv(GL_LIGHT0,GL_POSITION,light_position);
 718     glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
 719     glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0);
 720     glDepthMask(GL_TRUE);
 721     glDisable(GL_BLEND);
 722   }
 723   else if (display_mode == DISP_TRANSPARENT)
 724   {
 725     glDisable(GL_DEPTH_TEST);
 726     glShadeModel(GL_SMOOTH);
 727     glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
 728     glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
 729     glEnable(GL_LIGHTING);
 730     glEnable(GL_LIGHT0);
 731     glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
 732     glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
 733     glLightfv(GL_LIGHT0,GL_SPECULAR,light_specular);
 734     glLightfv(GL_LIGHT0,GL_POSITION,light_position);
 735     glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_specular);
 736     glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,50.0);
 737     glDepthMask(GL_FALSE);
 738     glEnable(GL_BLEND);
 739     glBlendFunc(GL_SRC_ALPHA,GL_ONE);
 740   }
 741   else
 742   {
 743     glDisable(GL_DEPTH_TEST);
 744     glShadeModel(GL_FLAT);
 745     glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
 746     glDisable(GL_LIGHTING);
 747     glDisable(GL_LIGHT0);
 748     glDisable(GL_BLEND);
 749   }
 750 }
 751
 752
 753 /* Redisplay the hypertorus. */
 754 static void display_hypertorus(ModeInfo *mi)
 755 {
 756   hypertorusstruct *hp = &hyper[MI_SCREEN(mi)];
 757
 758   if (!hp->button_pressed)
 759   {
 760     hp->alpha += speed_wx * hp->speed_scale;
 761     if (hp->alpha >= 360.0)
 762       hp->alpha -= 360.0;
 763     hp->beta += speed_wy * hp->speed_scale;
 764     if (hp->beta >= 360.0)
 765       hp->beta -= 360.0;
 766     hp->delta += speed_wz * hp->speed_scale;
 767     if (hp->delta >= 360.0)
 768       hp->delta -= 360.0;
 769     hp->zeta += speed_xy * hp->speed_scale;
 770     if (hp->zeta >= 360.0)
 771       hp->zeta -= 360.0;
 772     hp->eta += speed_xz * hp->speed_scale;
 773     if (hp->eta >= 360.0)
 774       hp->eta -= 360.0;
 775     hp->theta += speed_yz * hp->speed_scale;
 776     if (hp->theta >= 360.0)
 777       hp->theta -= 360.0;
 778   }
 779
 780   glMatrixMode(GL_PROJECTION);
 781   glLoadIdentity();
 782   if (projection_3d == DISP_3D_ORTHOGRAPHIC)
 783   {
 784     if (hp->aspect >= 1.0)
 785       glOrtho(-hp->aspect,hp->aspect,-1.0,1.0,0.1,100.0);
 786     else
 787       glOrtho(-1.0,1.0,-1.0/hp->aspect,1.0/hp->aspect,0.1,100.0);
 788   }
 789   else
 790   {
 791     gluPerspective(60.0,hp->aspect,0.1,100.0);
 792   }
 793   glMatrixMode(GL_MODELVIEW);
 794   glLoadIdentity();
 795
 796   hypertorus(mi,0.0,2.0*M_PI,0.0,2.0*M_PI,64,64);
 797 }
 798
 799
 800 ENTRYPOINT void reshape_hypertorus(ModeInfo *mi, int width, int height)
 801 {
 802   hypertorusstruct *hp = &hyper[MI_SCREEN(mi)];
 803
 804   hp->WindW = (GLint)width;
 805   hp->WindH = (GLint)height;
 806   glViewport(0,0,width,height);
 807   hp->aspect = (GLfloat)width/(GLfloat)height;
 808 }
 809
 810
 811 ENTRYPOINT Bool hypertorus_handle_event(ModeInfo *mi, XEvent *event)
 812 {
 813   Display *display = MI_DISPLAY(mi);
 814   hypertorusstruct *hp = &hyper[MI_SCREEN(mi)];
 815   KeySym  sym;
 816
 817   if (event->xany.type == ButtonPress &&
 818       event->xbutton.button == Button1)
 819   {
 820     hp->button_pressed = True;
 821     gltrackball_start(hp->trackballs[hp->current_trackball],
 822                       event->xbutton.x, event->xbutton.y,
 823                       MI_WIDTH(mi), MI_HEIGHT(mi));
 824     return True;
 825   }
 826   else if (event->xany.type == ButtonRelease &&
 827            event->xbutton.button == Button1)
 828   {
 829     hp->button_pressed = False;
 830     return True;
 831   }
 832   else if (event->xany.type == KeyPress)
 833   {
 834     sym = XKeycodeToKeysym(display,event->xkey.keycode,0);
 835     if (sym == XK_Shift_L || sym == XK_Shift_R)
 836     {
 837       hp->current_trackball = 1;
 838       if (hp->button_pressed)
 839         gltrackball_start(hp->trackballs[hp->current_trackball],
 840                           event->xbutton.x, event->xbutton.y,
 841                           MI_WIDTH(mi), MI_HEIGHT(mi));
 842       return True;
 843     }
 844   }
 845   else if (event->xany.type == KeyRelease)
 846   {
 847     sym = XKeycodeToKeysym(display,event->xkey.keycode,0);
 848     if (sym == XK_Shift_L || sym == XK_Shift_R)
 849     {
 850       hp->current_trackball = 0;
 851       if (hp->button_pressed)
 852         gltrackball_start(hp->trackballs[hp->current_trackball],
 853                           event->xbutton.x, event->xbutton.y,
 854                           MI_WIDTH(mi), MI_HEIGHT(mi));
 855       return True;
 856     }
 857   }
 858   else if (event->xany.type == MotionNotify && hp->button_pressed)
 859   {
 860     gltrackball_track(hp->trackballs[hp->current_trackball],
 861                       event->xmotion.x, event->xmotion.y,
 862                       MI_WIDTH(mi), MI_HEIGHT(mi));
 863     return True;
 864   }
 865
 866   return False;
 867 }
 868
 869
 870 /*
 871  *-----------------------------------------------------------------------------
 872  *-----------------------------------------------------------------------------
 873  *    Xlock hooks.
 874  *-----------------------------------------------------------------------------
 875  *-----------------------------------------------------------------------------
 876  */
 877
 878 /*
 879  *-----------------------------------------------------------------------------
 880  *    Initialize hypertorus.  Called each time the window changes.
 881  *-----------------------------------------------------------------------------
 882  */
 883
 884 ENTRYPOINT void init_hypertorus(ModeInfo *mi)
 885 {
 886   hypertorusstruct *hp;
 887
 888   if (hyper == NULL)
 889   {
 890     hyper = (hypertorusstruct *)calloc(MI_NUM_SCREENS(mi),
 891                                        sizeof(hypertorusstruct));
 892     if (hyper == NULL)
 893       return;
 894   }
 895   hp = &hyper[MI_SCREEN(mi)];
 896
 897
 898   hp->trackballs[0] = gltrackball_init();
 899   hp->trackballs[1] = gltrackball_init();
 900   hp->current_trackball = 0;
 901   hp->button_pressed = False;
 902
 903   /* make multiple screens rotate at slightly different rates. */
 904   hp->speed_scale = 0.9 + frand(0.3);
 905
 906   if ((hp->glx_context = init_GL(mi)) != NULL)
 907   {
 908     reshape_hypertorus(mi,MI_WIDTH(mi),MI_HEIGHT(mi));
 909     glDrawBuffer(GL_BACK);
 910     init(mi);
 911   }
 912   else
 913   {
 914     MI_CLEARWINDOW(mi);
 915   }
 916 }
 917
 918 /*
 919  *-----------------------------------------------------------------------------
 920  *    Called by the mainline code periodically to update the display.
 921  *-----------------------------------------------------------------------------
 922  */
 923 ENTRYPOINT void draw_hypertorus(ModeInfo *mi)
 924 {
 925   Display          *display = MI_DISPLAY(mi);
 926   Window           window = MI_WINDOW(mi);
 927   hypertorusstruct *hp;
 928
 929   if (hyper == NULL)
 930     return;
 931   hp = &hyper[MI_SCREEN(mi)];
 932
 933   MI_IS_DRAWN(mi) = True;
 934   if (!hp->glx_context)
 935     return;
 936
 937   glXMakeCurrent(display,window,*(hp->glx_context));
 938
 939   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 940   glLoadIdentity();
 941
 942   display_hypertorus(mi);
 943
 944   if (MI_IS_FPS(mi))
 945     do_fps (mi);
 946
 947   glFlush();
 948
 949   glXSwapBuffers(display,window);
 950 }
 951
 952
 953 /*
 954  *-----------------------------------------------------------------------------
 955  *    The display is being taken away from us.  Free up malloc'ed
 956  *      memory and X resources that we've alloc'ed.  Only called
 957  *      once, we must zap everything for every screen.
 958  *-----------------------------------------------------------------------------
 959  */
 960
 961 ENTRYPOINT void release_hypertorus(ModeInfo *mi)
 962 {
 963   if (hyper != NULL)
 964   {
 965     int screen;
 966
 967     for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++)
 968     {
 969       hypertorusstruct *hp = &hyper[screen];
 970
 971       if (hp->glx_context)
 972         hp->glx_context = (GLXContext *)NULL;
 973     }
 974     (void) free((void *)hyper);
 975     hyper = (hypertorusstruct *)NULL;
 976   }
 977   FreeAllGL(mi);
 978 }
 979
 980 #ifndef STANDALONE
 981 ENTRYPOINT void change_hypertorus(ModeInfo *mi)
 982 {
 983   hypertorusstruct *hp = &hyper[MI_SCREEN(mi)];
 984
 985   if (!hp->glx_context)
 986     return;
 987
 988   glXMakeCurrent(MI_DISPLAY(mi),MI_WINDOW(mi),*(hp->glx_context));
 989   init(mi);
 990 }
 991 #endif /* !STANDALONE */
 992
 993 XSCREENSAVER_MODULE ("Hypertorus", hypertorus)
 994
 995 #endif /* USE_GL */