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