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

   1 /*
   2  * flipscreen3d - takes snapshots of the screen and flips it around
   3  *
   4  * version 1.0 - Oct 24, 2001
   5  *
   6  * Copyright (C) 2001 Ben Buxton (bb@cactii.net)
   7  *
   8  * Permission to use, copy, modify, distribute, and sell this software and its
   9  * documentation for any purpose is hereby granted without fee, provided that
  10  * the above copyright notice appear in all copies and that both that
  11  * copyright notice and this permission notice appear in supporting
  12  * documentation.  No representations are made about the suitability of this
  13  * software for any purpose.  It is provided "as is" without express or
  14  * implied warranty.
  15  */
  16
  17 #ifdef STANDALONE
  18 #define DEFAULTS "*delay:     20000 \n" \
  19                  "*showFPS:   False \n" \
  20                  "*wireframe: False \n" \
  21                  "*useSHM:    True  \n" \
  22                  "*suppressRotationAnimation: True\n" \
  23
  24 # define refresh_screenflip 0
  25 # define release_screenflip 0
  26 # include "xlockmore.h"                         /* from the xscreensaver distribution */
  27 # include "gltrackball.h"
  28 #else  /* !STANDALONE */
  29 # include "xlock.h"                                     /* from the xlockmore distribution */
  30 #endif /* !STANDALONE */
  31
  32 /* lifted from lament.c */
  33 #define RAND(n) ((long) ((random() & 0x7fffffff) % ((long) (n))))
  34 #define RANDSIGN() ((random() & 1) ? 1 : -1)
  35
  36
  37 #ifdef USE_GL
  38
  39 /* Should be in <GL/glext.h> */
  40 # ifndef  GL_TEXTURE_MAX_ANISOTROPY_EXT
  41 #  define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
  42 # endif
  43 # ifndef  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
  44 #  define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
  45 # endif
  46
  47 #define DEF_ROTATE "True"
  48 static int rotate;
  49
  50 #define QW 12
  51 #define QH 12
  52
  53 #undef countof
  54 #define countof(x) (sizeof((x))/sizeof((*x)))
  55
  56
  57 static XrmOptionDescRec opts[] = {
  58   {"+rotate", ".screenflip.rotate", XrmoptionNoArg, "false" },
  59   {"-rotate", ".screenflip.rotate", XrmoptionNoArg, "true" },
  60 };
  61
  62
  63 static argtype vars[] = {
  64   {&rotate, "rotate", "Rotate", DEF_ROTATE, t_Bool},
  65 };
  66
  67
  68
  69 ENTRYPOINT ModeSpecOpt screenflip_opts = {countof(opts), opts, countof(vars), vars, NULL};
  70
  71
  72 #ifdef USE_MODULES
  73 ModStruct   screenflip_description =
  74 {"screenflip", "init_screenflip", "draw_screenflip", NULL,
  75  "draw_screenflip", "init_screenflip", NULL, &screenflip_opts,
  76  1000, 1, 2, 1, 4, 1.0, "",
  77  "Screenflips", 0, NULL};
  78
  79 #endif
  80
  81
  82 typedef struct {
  83   GLXContext *glx_context;
  84   Window window;
  85
  86   int winw, winh;
  87   int tw, th; /* texture width, height */
  88   GLfloat min_tx, min_ty;
  89   GLfloat max_tx, max_ty;
  90   GLfloat qx, qy, qw, qh; /* the quad we'll draw */
  91
  92   int regrab;
  93   int fadetime; /* fade before regrab */
  94
  95   trackball_state *trackball;
  96   Bool button_down_p;
  97
  98   GLfloat show_colors[4];
  99   GLfloat stretch_val_x, stretch_val_y;
 100   GLfloat stretch_val_dx, stretch_val_dy;
 101
 102   GLfloat curx, cury, curz;
 103
 104   GLfloat rx, ry, rz;
 105   GLfloat rot, drot, odrot, ddrot, orot;
 106   float theta, rho, dtheta, drho, gamma, dgamma;
 107
 108   GLuint texid;
 109   Bool mipmap_p;
 110   Bool waiting_for_image_p;
 111   Bool first_image_p;
 112
 113   GLfloat anisotropic;
 114
 115 } Screenflip;
 116
 117 static Screenflip *screenflip = NULL;
 118
 119 #include "grab-ximage.h"
 120
 121 static const GLfloat viewer[] = {0.0, 0.0, 15.0};
 122
 123
 124 static void getSnapshot (ModeInfo *);
 125
 126
 127 ENTRYPOINT Bool
 128 screenflip_handle_event (ModeInfo *mi, XEvent *event)
 129 {
 130   Screenflip *c = &screenflip[MI_SCREEN(mi)];
 131
 132   if (gltrackball_event_handler (event, c->trackball,
 133                                  MI_WIDTH (mi), MI_HEIGHT (mi),
 134                                  &c->button_down_p))
 135     return True;
 136   else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
 137     {
 138       if (!c->waiting_for_image_p)
 139         {
 140           getSnapshot (mi);
 141           return True;
 142         }
 143     }
 144
 145   return False;
 146 }
 147
 148
 149 /* draw the texture mapped quad (actually two back to back)*/
 150 static void showscreen(Screenflip *c, int frozen, int wire)
 151 {
 152   GLfloat x, y, w, h;
 153
 154   if (c->fadetime) {
 155 /*    r -= 0.02; g -= 0.02; b -= 0.02; */
 156     c->show_colors[3] -= 0.02;
 157     if (c->show_colors[3] < 0) {
 158       c->regrab = 1;
 159       c->fadetime = 0;
 160     }
 161   } else if (c->show_colors[3] < 0) {
 162     c->show_colors[0] = c->show_colors[1] =
 163       c->show_colors[2] = c->show_colors[3] = 1;
 164     c->stretch_val_x = c->stretch_val_y =
 165       c->stretch_val_dx = c->stretch_val_dy = 0;
 166   }
 167   if (c->stretch_val_dx == 0 && !frozen && !(random() % 25))
 168     c->stretch_val_dx = (float)(random() % 100) / 5000;
 169   if (c->stretch_val_dy == 0 && !frozen && !(random() % 25))
 170     c->stretch_val_dy = (float)(random() % 100) / 5000;
 171
 172   x = c->qx;
 173   y = c->qy;
 174   w = c->qx+c->qw;
 175   h = c->qy-c->qh;
 176
 177   if (!frozen) {
 178      w *= sin (c->stretch_val_x) + 1;
 179      x *= sin (c->stretch_val_x) + 1;
 180      if (!c->button_down_p) {
 181      if (!c->fadetime) c->stretch_val_x += c->stretch_val_dx;
 182      if (c->stretch_val_x > 2*M_PI && !(random() % 5))
 183        c->stretch_val_dx = (float)(random() % 100) / 5000;
 184      else
 185        c->stretch_val_x -= 2*M_PI;
 186      }
 187
 188      if (!c->button_down_p && !c->fadetime) c->stretch_val_y += c->stretch_val_dy;
 189      h *= sin (c->stretch_val_y) / 2 + 1;
 190      y *= sin (c->stretch_val_y) / 2 + 1;
 191      if (!c->button_down_p) {
 192      if (c->stretch_val_y > 2*M_PI && !(random() % 5))
 193        c->stretch_val_dy = (float)(random() % 100) / 5000;
 194      else
 195        c->stretch_val_y -= 2*M_PI;
 196      }
 197   }
 198
 199   glColor4f(c->show_colors[0], c->show_colors[1],
 200             c->show_colors[2], c->show_colors[3]);
 201
 202   if (!wire)
 203     {
 204       glEnable(GL_TEXTURE_2D);
 205       glEnable(GL_BLEND);
 206       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 207       glDepthMask(GL_FALSE);
 208     }
 209
 210   glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
 211
 212   glNormal3f(0, 0, 1);
 213   glTexCoord2f(c->max_tx, c->max_ty); glVertex3f(w, h, 0);
 214   glTexCoord2f(c->max_tx, c->min_ty); glVertex3f(w, y, 0);
 215   glTexCoord2f(c->min_tx, c->min_ty); glVertex3f(x, y, 0);
 216   glTexCoord2f(c->min_tx, c->max_ty); glVertex3f(x, h, 0);
 217
 218   glNormal3f(0, 0, -1);
 219   glTexCoord2f(c->min_tx, c->min_ty); glVertex3f(x, y, -0.05);
 220   glTexCoord2f(c->max_tx, c->min_ty); glVertex3f(w, y, -0.05);
 221   glTexCoord2f(c->max_tx, c->max_ty); glVertex3f(w, h, -0.05);
 222   glTexCoord2f(c->min_tx, c->max_ty); glVertex3f(x, h, -0.05);
 223   glEnd();
 224
 225
 226   glDisable(GL_TEXTURE_2D);
 227   glDepthMask(GL_TRUE);
 228
 229   glBegin(GL_LINE_LOOP);
 230    glVertex3f(x, y, 0);
 231    glVertex3f(x, h, 0);
 232    glVertex3f(w, h, 0);
 233    glVertex3f(w, y, 0);
 234  glEnd();
 235   glDisable(GL_BLEND);
 236
 237 }
 238
 239 /* This function is responsible for 'zooming back' the square after
 240  * a new chunk has been grabbed with getSnapshot(), and positioning
 241  * it suitably on the screen. Once positioned (where we begin to rotate),
 242  * it just does a glTranslatef() and returns 1
 243  */
 244
 245 static int inposition(Screenflip *c)
 246 {
 247   GLfloat wx;
 248   GLfloat wy;
 249   wx = 0 - (c->qw/2);
 250   wy = (c->qh/2);
 251
 252   if (c->curx == 0) c->curx = c->qx;
 253   if (c->cury == 0) c->cury = c->qy;
 254   if (c->regrab) {
 255      c->curz = 0;
 256      c->curx = c->qx;
 257      c->cury = c->qy;
 258      c->regrab = 0;
 259   }
 260   if (c->curz > -10 || c->curx > wx + 0.1 || c->curx < wx - 0.1 ||
 261          c->cury > wy + 0.1 || c->cury < wy - 0.1) {
 262     if (c->curz > -10)
 263       c->curz -= 0.05;
 264     if (c->curx > wx) {
 265        c->qx -= 0.02;
 266        c->curx -= 0.02;
 267     }
 268     if (c->curx < wx) {
 269        c->qx += 0.02;
 270        c->curx += 0.02;
 271     }
 272     if (c->cury > wy) {
 273        c->qy -= 0.02;
 274        c->cury -= 0.02;
 275     }
 276     if (c->cury < wy) {
 277        c->qy += 0.02;
 278        c->cury += 0.02;
 279     }
 280     glTranslatef(0, 0, c->curz);
 281     return 0;
 282   }
 283   glTranslatef(0, 0, c->curz);
 284   return 1;
 285
 286 }
 287
 288 #if 0
 289 static void drawgrid(void)
 290 {
 291   int i;
 292
 293   glColor3f(0, 0.7, 0);
 294   glBegin(GL_LINES);
 295   for (i = 0 ; i <= 50; i+=2) {
 296       glVertex3f( -25, -15, i-70);
 297       glVertex3f( 25, -15, i-70);
 298       glVertex3f( i-25, -15, -70);
 299       glVertex3f( i-25, -15, -20);
 300   }
 301   glEnd();
 302 }
 303 #endif
 304
 305
 306 static void display(Screenflip *c, int wire)
 307 {
 308   int frozen;
 309 /*  GLfloat rot = current_device_rotation();*/
 310
 311   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 312   glLoadIdentity();
 313   gluLookAt(viewer[0], viewer[1], viewer[2], 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
 314   glPushMatrix();
 315
 316 /*
 317   glRotatef(rot, 0, 0, 1);
 318   if ((rot >  45 && rot <  135) ||
 319       (rot < -45 && rot > -135))
 320     {
 321       GLfloat s = c->winw / (GLfloat) c->winh;
 322       glScalef (s, 1/s, 1);
 323     }
 324 */
 325
 326   if (inposition(c)) {
 327     frozen = 0;
 328     glTranslatef(5 * sin(c->theta), 5 * sin(c->rho), 10 * cos(c->gamma) - 10);
 329 /* randomly change the speed */
 330     if (!c->button_down_p && !(random() % 300)) {
 331       if (random() % 2)
 332         c->drho = 1/60 - (float)(random() % 100)/3000;
 333       if (random() % 2)
 334         c->dtheta = 1/60 - (float)(random() % 100)/3000;
 335       if (random() % 2)
 336         c->dgamma = 1/60 - (float)(random() % 100)/3000;
 337     }
 338 /*    glRotatef(-rot, 0, 0, 1);*/
 339     gltrackball_rotate (c->trackball);
 340 /*    glRotatef(rot, 0, 0, 1);*/
 341     if (rotate) glRotatef(c->rot, c->rx, c->ry, c->rz);
 342 /* update variables with each frame */
 343     if(!c->button_down_p && !c->fadetime) {
 344       c->theta += c->dtheta;
 345       c->rho += c->drho;
 346       c->gamma += c->dgamma;
 347       c->rot += c->drot;
 348       c->drot += c->ddrot;
 349     }
 350 /* dont let our rotation speed get too high */
 351     if (c->drot > 5 && c->ddrot > 0)
 352         c->ddrot = 0 - (GLfloat)(random() % 100) / 1000;
 353     else if (c->drot < -5 && c->ddrot < 0)
 354         c->ddrot = (GLfloat)(random() % 100) / 1000;
 355   } else { /* reset some paramaters */
 356     c->ddrot = 0.05 - (GLfloat)(random() % 100) / 1000;
 357     c->theta = c->rho = c->gamma = 0;
 358     c->rot = 0;
 359     frozen = 1;
 360   }
 361   if (!c->button_down_p && !c->fadetime && (c->rot >= 360 || c->rot <= -360) && !(random() % 7)) { /* rotate  change */
 362     c->rx = (GLfloat)(random() % 100) / 100;
 363     c->ry = (GLfloat)(random() % 100) / 100;
 364     c->rz = (GLfloat)(random() % 100) / 100;
 365   }
 366   if (c->odrot * c->drot < 0 && c->tw < c->winw && !(random() % 10)) {
 367     c->fadetime = 1;                /* randomly fade and get new snapshot */
 368   }
 369   c->orot = c->rot;
 370   c->odrot = c->drot;
 371   if (c->rot > 360 || c->rot < -360) /* dont overflow rotation! */
 372     c->rot -= c->rot;
 373   showscreen(c, frozen, wire);
 374   glPopMatrix();
 375   glFlush();
 376 }
 377
 378 ENTRYPOINT void reshape_screenflip(ModeInfo *mi, int width, int height)
 379 {
 380  Screenflip *c = &screenflip[MI_SCREEN(mi)];
 381  glViewport(0,0,(GLint)width, (GLint) height);
 382  glMatrixMode(GL_PROJECTION);
 383  glLoadIdentity();
 384  gluPerspective(45, 1, 2.0, 85);
 385  glMatrixMode(GL_MODELVIEW);
 386  c->winw = width;
 387  c->winh = height;
 388 }
 389
 390 static void
 391 image_loaded_cb (const char *filename, XRectangle *geometry,
 392                  int image_width, int image_height,
 393                  int texture_width, int texture_height,
 394                  void *closure)
 395 {
 396   Screenflip *c = (Screenflip *) closure;
 397
 398   c->tw = texture_width;
 399   c->th = texture_height;
 400   c->min_tx = (GLfloat) geometry->x / c->tw;
 401   c->min_ty = (GLfloat) geometry->y / c->th;
 402   c->max_tx = (GLfloat) (geometry->x + geometry->width)  / c->tw;
 403   c->max_ty = (GLfloat) (geometry->y + geometry->height) / c->th;
 404
 405   c->qx = -QW/2 + ((GLfloat) geometry->x * QW / image_width);
 406   c->qy =  QH/2 - ((GLfloat) geometry->y * QH / image_height);
 407   c->qw =  QW   * ((GLfloat) geometry->width  / image_width);
 408   c->qh =  QH   * ((GLfloat) geometry->height / image_height);
 409
 410   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 411   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 412                    (c->mipmap_p ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR));
 413
 414   if (c->anisotropic >= 1.0)
 415     glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT,
 416                      c->anisotropic);
 417
 418   c->waiting_for_image_p = False;
 419   c->first_image_p = False;
 420 }
 421
 422
 423 static void getSnapshot (ModeInfo *modeinfo)
 424 {
 425   Screenflip *c = &screenflip[MI_SCREEN(modeinfo)];
 426
 427   if (MI_IS_WIREFRAME(modeinfo))
 428     return;
 429
 430   c->waiting_for_image_p = True;
 431   c->mipmap_p = True;
 432   load_texture_async (modeinfo->xgwa.screen, modeinfo->window,
 433                       *c->glx_context, 0, 0, c->mipmap_p, c->texid,
 434                       image_loaded_cb, c);
 435 }
 436
 437 ENTRYPOINT void init_screenflip(ModeInfo *mi)
 438 {
 439   int screen = MI_SCREEN(mi);
 440   Screenflip *c;
 441
 442  MI_INIT(mi, screenflip, NULL);
 443  c = &screenflip[screen];
 444  c->window = MI_WINDOW(mi);
 445
 446  c->trackball = gltrackball_init (False);
 447
 448  if ((c->glx_context = init_GL(mi)) != NULL) {
 449       reshape_screenflip(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 450  } else {
 451      MI_CLEARWINDOW(mi);
 452  }
 453  c->winh = MI_WIN_HEIGHT(mi);
 454  c->winw = MI_WIN_WIDTH(mi);
 455  c->qw = QW;
 456  c->qh = QH;
 457  c->qx = -6;
 458  c->qy = 6;
 459
 460  c->rx = c->ry = 1;
 461  c->odrot = 1;
 462
 463  c->show_colors[0] = c->show_colors[1] =
 464    c->show_colors[2] = c->show_colors[3] = 1;
 465
 466  if (! MI_IS_WIREFRAME(mi))
 467    {
 468      glShadeModel(GL_SMOOTH);
 469      glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
 470      glEnable(GL_DEPTH_TEST);
 471      glEnable(GL_CULL_FACE);
 472      glCullFace(GL_BACK);
 473      glDisable(GL_LIGHTING);
 474    }
 475
 476  if (strstr ((char *) glGetString(GL_EXTENSIONS),
 477              "GL_EXT_texture_filter_anisotropic"))
 478    glGetFloatv (GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &c->anisotropic);
 479  else
 480    c->anisotropic = 0.0;
 481
 482  glGenTextures(1, &c->texid);
 483
 484  c->first_image_p = True;
 485  getSnapshot(mi);
 486 }
 487
 488 ENTRYPOINT void draw_screenflip(ModeInfo *mi)
 489 {
 490   Screenflip *c = &screenflip[MI_SCREEN(mi)];
 491   Window w = MI_WINDOW(mi);
 492   Display *disp = MI_DISPLAY(mi);
 493
 494   if (!c->glx_context)
 495       return;
 496
 497   /* Wait for the first image; for subsequent images, load them in the
 498      background while animating. */
 499   if (c->waiting_for_image_p && c->first_image_p)
 500     return;
 501
 502   glXMakeCurrent(disp, w, *(c->glx_context));
 503
 504   glBindTexture(GL_TEXTURE_2D, c->texid);
 505
 506   if (c->regrab)
 507     getSnapshot(mi);
 508
 509   display(c, MI_IS_WIREFRAME(mi));
 510
 511   if(mi->fps_p) do_fps(mi);
 512   glFinish();
 513   glXSwapBuffers(disp, w);
 514 }
 515
 516 XSCREENSAVER_MODULE_2 ("FlipScreen3D", flipscreen3d, screenflip)
 517
 518 #endif