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

   1 /* -*- Mode: C; tab-width: 4 -*- */
   2 /* Klein --- Klein Bottle, Moebius and other parametric surfaces
   3  * visualization */
   4
   5 /*
   6  * Revision History:
   7  * 2000: written by Andrey Mirtchovski <mirtchov@cpsc.ucalgary.ca
   8  *
   9  * 01-Mar-2003  mirtchov    modified as a xscreensaver hack
  10  *
  11  */
  12
  13 #ifdef STANDALONE
  14 # define DEFAULTS                                       "*delay:                20000   \n" \
  15                                                                         "*showFPS:      False   \n"
  16
  17 # define refresh_klein 0
  18 # include "xlockmore.h"         /* from the xscreensaver distribution */
  19 #else  /* !STANDALONE */
  20 # include "xlock.h"                     /* from the xlockmore distribution */
  21 #endif /* !STANDALONE */
  22
  23 #ifdef USE_GL
  24
  25 #define DEF_SPIN                                "True"
  26 #define DEF_WANDER                              "False"
  27 #define DEF_RANDOM                              "True"
  28 #define DEF_SPEED                               "150"
  29
  30 #include "rotator.h"
  31 #include "gltrackball.h"
  32
  33 #undef countof
  34 #define countof(x) (sizeof((x))/sizeof((*x)))
  35
  36 /* surfaces being drawn */
  37 enum {
  38         KLEIN = 0,
  39         DINI,
  40         ENNEPER,
  41         KUEN,
  42         MOEBIUS,
  43         SEASHELL,
  44         SWALLOWTAIL,
  45         BOHEM,
  46     SURFACE_LAST
  47 };
  48
  49 /* primitives to draw with
  50  * note that we skip the polygons and
  51  * triangle fans -- too slow
  52  *
  53  * also removed triangle_strip and quads --
  54  * just doesn't look good enough
  55  */
  56 enum {
  57         MY_POINTS = 0,
  58         MY_LINES,
  59         MY_LINE_LOOP,
  60         MY_PRIM_LAST
  61 };
  62
  63
  64 static Bool rand;
  65 static int render;
  66 static int speed;
  67 static Bool do_spin;
  68 static Bool do_wander;
  69
  70 static XrmOptionDescRec opts[] = {
  71   {"-speed",   ".speed",    XrmoptionSepArg, 0 },
  72   { "-spin",   ".spin",   XrmoptionNoArg, "True" },
  73   { "+spin",   ".spin",   XrmoptionNoArg, "False" },
  74   { "-wander", ".wander", XrmoptionNoArg, "True" },
  75   { "+wander", ".wander", XrmoptionNoArg, "False" },
  76   { "-random", ".rand", XrmoptionNoArg, "True" },
  77   { "+random", ".rand", XrmoptionNoArg, "False" },
  78 };
  79
  80 static argtype vars[] = {
  81   {&rand,      "rand",   "Random", DEF_RANDOM, t_Bool},
  82   {&do_spin,   "spin",   "Spin",   DEF_SPIN,   t_Bool},
  83   {&do_wander, "wander", "Wander", DEF_WANDER, t_Bool},
  84   {&speed,     "speed",  "Speed",  DEF_SPEED,  t_Int},
  85 };
  86
  87
  88 ENTRYPOINT ModeSpecOpt klein_opts = {countof(opts), opts, countof(vars), vars, NULL};
  89
  90
  91
  92 typedef struct{
  93   GLfloat x;
  94   GLfloat y;
  95   GLfloat z;
  96 } GL_VECTOR;
  97
  98 typedef struct {
  99         GLXContext *glx_context;
 100         Window      window;
 101         rotator    *rot;
 102         trackball_state *trackball;
 103         Bool              button_down_p;
 104
 105         int render;
 106         int surface;
 107
 108         float du, dv;
 109         float a, b, c;
 110
 111     float draw_step;
 112
 113 } kleinstruct;
 114
 115 static kleinstruct *klein = NULL;
 116
 117
 118 static void
 119 draw(ModeInfo *mi)
 120 {
 121         kleinstruct *kp = &klein[MI_SCREEN(mi)];
 122         double u, v;
 123         float coord[3];
 124
 125         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 126
 127         glEnable(GL_DEPTH_TEST);
 128         glEnable(GL_NORMALIZE);
 129         glEnable(GL_CULL_FACE);
 130
 131         glPushMatrix();
 132
 133         {
 134                 double x, y, z;
 135                 get_position (kp->rot, &x, &y, &z, !kp->button_down_p);
 136                 glTranslatef((x - 0.5) * 10,
 137                                                                  (y - 0.5) * 10,
 138                                                                  (z - 0.5) * 20);
 139
 140                 gltrackball_rotate (kp->trackball);
 141
 142                 get_rotation (kp->rot, &x, &y, &z, !kp->button_down_p);
 143                 glRotatef (x * 360, 1.0, 0.0, 0.0);
 144                 glRotatef (y * 360, 0.0, 1.0, 0.0);
 145                 glRotatef (z * 360, 0.0, 0.0, 1.0);
 146         }
 147
 148         glScalef( 4.0, 4.0, 4.0 );
 149
 150         glBegin(kp->render);
 151         switch(kp->surface) {
 152         case KLEIN:
 153                 for(u = -M_PI; u < M_PI; u+=kp->du){
 154                         for(v = -M_PI; v < M_PI; v+=kp->dv){
 155                                 coord[0] = cos(u)*(kp->a + sin(v)*cos(u/2) -
 156                                                         sin(2*v)*sin(u/2)/2);
 157                                 coord[1] = sin(u)*(kp->a + sin(v)*cos(u/2) -
 158                                                         sin(2*v)*sin(u/2)/2);
 159                                 coord[2] = sin(u/2)*sin(v) + cos(u/2)*sin(2*v)/2;
 160                                 glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 161                                 glVertex3fv(coord);
 162                         }
 163                 }
 164                 break;
 165                 case DINI:
 166                         for(u = -M_PI; u < M_PI; u+=kp->du){
 167                                 for(v = -M_PI; v < M_PI; v+=kp->dv){
 168                                         coord[0] = kp->a*cos(u)*sin(v);
 169                                         coord[1] = kp->a*sin(u)*sin(v);
 170                                         coord[2] = kp->a*(cos(v) + sin(tan((v/2))))+0.2*u;
 171                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 172                                         glVertex3fv(coord);
 173                                 }
 174                         }
 175                         break;
 176                 case ENNEPER:
 177                         for(u = -M_PI; u < M_PI; u+=kp->du){
 178                                 for(v = -M_PI; v < M_PI; v+=kp->dv){
 179                                         coord[0] = kp->a*(u-(u*u*u/3)+u*v*v);
 180                                         coord[1] = kp->b*(v-(v*v*v/3)+u*u*v);
 181                                         coord[2] = u*u-v*v;
 182                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 183                                         glVertex3fv(coord);
 184                                 }
 185                         }
 186                         break;
 187                 case KUEN:
 188                         for(u = -M_PI; u < M_PI; u+=kp->du){
 189                                 for(v = -M_PI; v < M_PI; v+=kp->dv){
 190                                         coord[0] = 2*(cos(u)+u*sin(u))*sin(v)/(1+u*u*sin(v)*sin(v));
 191                                         coord[1] = 2*(sin(u)-u*cos(u))*sin(v)/(1+u*u*sin(v)*sin(v));
 192                                         coord[2] = sin(tan(v/2))+2*cos(v)/(1+u*u*sin(v)*sin(v));
 193
 194                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 195                                         glVertex3fv(coord);
 196                                 }
 197                         }
 198                         break;
 199                 case MOEBIUS:
 200                         for(u = -M_PI; u < M_PI; u+=kp->du){
 201                                 for(v = -M_PI; v < M_PI; v+=kp->dv){
 202                                         coord[0] = cos(u)+v*cos(u/2)*cos(u);
 203                                         coord[1] = sin(u)+v*cos(u/2)*sin(u);
 204                                         coord[2] = v*sin(u/2);
 205                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 206                                         glVertex3fv(coord);
 207                                 }
 208                         }
 209                         break;
 210                 case SEASHELL:
 211                         for(u = 0; u < 2*M_PI; u+=kp->du){
 212                                 for(v = 0; v < 2*M_PI; v+=kp->dv){
 213                                         coord[0] = kp->a*(1-v/(2*M_PI))*cos(2*v)*(1+cos(u))+sin(kp->c+=0.00001)*cos(2*v);
 214                                         coord[1] = kp->a*(1-v/(2*M_PI))*sin(2*v)*(1+cos(u))+cos(kp->c+=0.00001)*sin(2*v);
 215                                         coord[2] = sin(kp->b+=0.00001)*v/(2*M_PI)+kp->a*(1-v/(2*M_PI))*sin(u);
 216                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 217                                         glVertex3fv(coord);
 218                                 }
 219                         }
 220                         break;
 221                 case SWALLOWTAIL:
 222                         for(u = -M_PI; u < M_PI; u+=kp->du){
 223                                 for(v = -M_PI; v < M_PI; v+=kp->dv){
 224                                         coord[0] = u*pow(v,2) + 3*pow(v,4);
 225                                         coord[1] = -2*u*v - 4*pow(v,3);
 226                                         coord[2] = u;
 227                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 228                                         glVertex3fv(coord);
 229                                 }
 230                         }
 231                         break;
 232                 case BOHEM:
 233                         for(u = -M_PI; u < M_PI; u+=kp->du){
 234                                 for(v = -M_PI; v < M_PI; v+=kp->dv){
 235                                         coord[0] = kp->a*cos(u);
 236                                         coord[1] = 1.5*cos(v) + kp->a*sin(u);
 237                                         coord[2] = sin(v);
 238                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 239                                         glVertex3fv(coord);
 240                                 }
 241                         }
 242                         break;
 243                 default:
 244                         for(u = -M_PI; u < M_PI; u+=kp->du){
 245                                 for(v = -M_PI; v < M_PI; v+=kp->dv){
 246                                         coord[0] = sin(u)*kp->a;
 247                                         coord[1] = cos(u)*kp->a;
 248                                         coord[2] = sin(u/2)*cos(v) + cos(u/2)*sin(v);
 249                                         glColor3f(coord[0]+0.7, coord[1]+0.7, coord[2]+0.7);
 250                                         glVertex3fv(coord);
 251                                 }
 252                         }
 253                         break;
 254         }
 255         glEnd();
 256         glPopMatrix();
 257
 258
 259         kp->a = sin(kp->draw_step+=0.01);
 260         kp->b = cos(kp->draw_step+=0.01);
 261 }
 262
 263
 264 /* new window size or exposure */
 265 ENTRYPOINT void
 266 reshape_klein(ModeInfo *mi, int width, int height)
 267 {
 268         GLfloat h = (GLfloat) height / (GLfloat) width;
 269
 270         glViewport(0, 0, (GLint) width, (GLint) height);
 271         glMatrixMode(GL_PROJECTION);
 272         glLoadIdentity();
 273         gluPerspective (30.0, 1/h, 1.0, 100.0);
 274
 275         glMatrixMode(GL_MODELVIEW);
 276         glLoadIdentity();
 277         gluLookAt( 0.0, 0.0, 30.0,
 278                          0.0, 0.0, 0.0,
 279                          0.0, 1.0, 0.0);
 280
 281         glClear(GL_COLOR_BUFFER_BIT);
 282 }
 283
 284
 285 ENTRYPOINT Bool
 286 klein_handle_event (ModeInfo *mi, XEvent *event)
 287 {
 288         kleinstruct *kp = &klein[MI_SCREEN(mi)];
 289
 290         if (event->xany.type == ButtonPress && event->xbutton.button == Button1) {
 291                         kp->button_down_p = True;
 292                         gltrackball_start (kp->trackball, event->xbutton.x, event->xbutton.y, MI_WIDTH (mi), MI_HEIGHT (mi));
 293                         return True;
 294         } else if (event->xany.type == ButtonRelease && event->xbutton.button == Button1) {
 295                         kp->button_down_p = False;
 296                         return True;
 297         } else if (event->xany.type == ButtonPress &&
 298                (event->xbutton.button == Button4 ||
 299                 event->xbutton.button == Button5 ||
 300                 event->xbutton.button == Button6 ||
 301                 event->xbutton.button == Button7)) {
 302       gltrackball_mousewheel (kp->trackball, event->xbutton.button, 10,
 303                               !!event->xbutton.state);
 304       return True;
 305     } else if (event->xany.type == MotionNotify && kp->button_down_p) {
 306                         gltrackball_track (kp->trackball, event->xmotion.x, event->xmotion.y, MI_WIDTH (mi), MI_HEIGHT (mi));
 307                         return True;
 308         }
 309
 310         return False;
 311 }
 312
 313
 314 ENTRYPOINT void
 315 init_klein(ModeInfo *mi)
 316 {
 317         int      screen = MI_SCREEN(mi);
 318         kleinstruct *kp;
 319
 320         if (klein == NULL) {
 321                 if ((klein = (kleinstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (kleinstruct))) == NULL)
 322                         return;
 323         }
 324         kp = &klein[screen];
 325
 326         kp->window = MI_WINDOW(mi);
 327
 328         {
 329                 double spin_speed        = 1.0;
 330                 double wander_speed = 0.03;
 331                 kp->rot = make_rotator (do_spin ? spin_speed : 0,
 332                                                 do_spin ? spin_speed : 0,
 333                                                 do_spin ? spin_speed : 0,
 334                                                 1.0,
 335                                                 do_wander ? wander_speed : 0,
 336                                                 True);
 337                 kp->trackball = gltrackball_init ();
 338         }
 339
 340         if(rand) {
 341                 render = random() % MY_PRIM_LAST;
 342                 kp->surface = random() % SURFACE_LAST;
 343         } else {
 344                 render = MY_LINE_LOOP;
 345                 kp->surface = KLEIN;
 346         }
 347
 348         switch (render) {
 349         case MY_POINTS: kp->render = GL_POINTS; break;
 350         case MY_LINES: kp->render = GL_LINES; break;
 351         case MY_LINE_LOOP: kp->render = GL_LINE_LOOP; break;
 352         default:
 353                         kp->render = GL_LINE_LOOP;
 354         }
 355 /*kp->render=GL_TRIANGLE_FAN;*/
 356 /*kp->render=GL_POLYGON;*/
 357
 358         kp->du = 0.07;
 359         kp->dv = 0.07;
 360         kp->a = kp->b = 1;
 361         kp->c = 0.1;
 362
 363
 364         if ((kp->glx_context = init_GL(mi)) != NULL) {
 365                 reshape_klein(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 366         } else {
 367                 MI_CLEARWINDOW(mi);
 368         }
 369 }
 370
 371 ENTRYPOINT void
 372 draw_klein(ModeInfo * mi)
 373 {
 374         kleinstruct *kp = &klein[MI_SCREEN(mi)];
 375         Display *display = MI_DISPLAY(mi);
 376         Window  window = MI_WINDOW(mi);
 377
 378         if (!kp->glx_context) return;
 379
 380         glDrawBuffer(GL_BACK);
 381
 382         glXMakeCurrent(display, window, *(kp->glx_context));
 383         draw(mi);
 384         if (mi->fps_p) do_fps (mi);
 385         glFinish();
 386         glXSwapBuffers(display, window);
 387 }
 388
 389 ENTRYPOINT void
 390 release_klein(ModeInfo * mi)
 391 {
 392         if (klein != NULL) {
 393                 int      screen;
 394
 395                 for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
 396                         kleinstruct *kp = &klein[screen];
 397
 398                         if (kp->glx_context) {
 399                                 /* Display lists MUST be freed while their glXContext is current. */
 400                                 glXMakeCurrent(MI_DISPLAY(mi), kp->window, *(kp->glx_context));
 401                         }
 402                 }
 403                 (void) free((void *) klein);
 404                 klein = NULL;
 405         }
 406         FreeAllGL(mi);
 407 }
 408
 409
 410 XSCREENSAVER_MODULE ("Klein", klein)
 411
 412 /*********************************************************/
 413
 414 #endif