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

   1 /* photopile, Copyright (c) 2008-2009 Jens Kilian <jjk@acm.org>
   2  * Based on carousel, Copyright (c) 2005-2008 Jamie Zawinski <jwz@jwz.org>
   3  * Loads a sequence of images and shuffles them into a pile.
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and its
   6  * documentation for any purpose is hereby granted without fee, provided that
   7  * the above copyright notice appear in all copies and that both that
   8  * copyright notice and this permission notice appear in supporting
   9  * documentation.  No representations are made about the suitability of this
  10  * software for any purpose.  It is provided "as is" without express or
  11  * implied warranty.
  12  */
  13
  14 #define DEF_FONT "-*-helvetica-bold-r-normal-*-240-*"
  15 #define DEFAULTS  "*count:           7         \n" \
  16                   "*delay:           10000     \n" \
  17                   "*wireframe:       False     \n" \
  18                   "*showFPS:         False     \n" \
  19                   "*fpsSolid:        True      \n" \
  20                   "*useSHM:          True      \n" \
  21                   "*font:          " DEF_FONT "\n" \
  22                   "*desktopGrabber:  xscreensaver-getimage -no-desktop %s\n" \
  23                   "*grabDesktopImages:   False \n" \
  24                   "*chooseRandomImages:  True  \n"
  25
  26 # define refresh_photopile 0
  27 # define release_photopile 0
  28 # define photopile_handle_event 0
  29
  30 #undef countof
  31 #define countof(x) (sizeof((x))/sizeof((*x)))
  32
  33 #ifndef HAVE_COCOA
  34 # include <X11/Intrinsic.h>     /* for XrmDatabase in -debug mode */
  35 #endif
  36 #include <math.h>
  37
  38 #include "xlockmore.h"
  39 #include "grab-ximage.h"
  40 #include "texfont.h"
  41 #include "dropshadow.h"
  42
  43 #ifdef USE_GL
  44
  45 # define DEF_SCALE          "0.4"
  46 # define DEF_MAX_TILT       "50"
  47 # define DEF_SPEED          "1.0"
  48 # define DEF_DURATION       "5"
  49 # define DEF_MIPMAP         "True"
  50 # define DEF_TITLES         "False"
  51 # define DEF_POLAROID       "True"
  52 # define DEF_CLIP           "True"
  53 # define DEF_SHADOWS        "True"
  54 # define DEF_DEBUG          "False"
  55
  56 #define BELLRAND(n) ((frand((n)) + frand((n)) + frand((n))) / 3)
  57
  58 typedef struct {
  59   GLfloat x, y;                 /* position on screen */
  60   GLfloat angle;                /* rotation angle */
  61
  62 } position;
  63
  64 typedef struct {
  65   Bool loaded_p;                /* true if image can be drawn */
  66
  67   char *title;                  /* the filename of this image */
  68   int w, h;                     /* size in pixels of the image */
  69   int tw, th;                   /* size in pixels of the texture */
  70   XRectangle geom;              /* where in the image the bits are */
  71
  72   position pos[4];              /* control points for calculating position */
  73
  74   GLuint texid;                 /* GL texture ID */
  75
  76 } image;
  77
  78
  79 typedef enum { EARLY, IN, NORMAL, LOADING, SHUFFLE } fade_mode;
  80 static int fade_ticks = 60;
  81
  82 typedef struct {
  83   ModeInfo *mi;
  84   GLXContext *glx_context;
  85
  86   image *frames;                /* pointer to array of images */
  87   int nframe;                   /* image being (resp. next to be) loaded */
  88
  89   GLuint shadow;
  90   texture_font_data *texfont;
  91   int loading_sw, loading_sh;
  92
  93   time_t last_time, now;
  94   int draw_tick;
  95   fade_mode mode;
  96   int mode_tick;
  97
  98 } photopile_state;
  99
 100 static photopile_state *sss = NULL;
 101
 102
 103 /* Command-line arguments
 104  */
 105 static GLfloat scale;        /* Scale factor for loading images. */
 106 static GLfloat max_tilt;     /* Maximum angle from vertical. */
 107 static GLfloat speed;        /* Animation speed scale factor. */
 108 static int duration;         /* Reload images after this long. */
 109 static Bool mipmap_p;        /* Use mipmaps instead of single textures. */
 110 static Bool titles_p;        /* Display image titles. */
 111 static Bool polaroid_p;      /* Use instant-film look for images. */
 112 static Bool clip_p;          /* Clip images instead of scaling for -polaroid. */static Bool shadows_p;       /* Draw drop shadows. */
 113 static Bool debug_p;         /* Be loud and do weird things. */
 114
 115
 116 static XrmOptionDescRec opts[] = {
 117   {"-scale",        ".scale",         XrmoptionSepArg, 0 },
 118   {"-maxTilt",      ".maxTilt",       XrmoptionSepArg, 0 },
 119   {"-speed",        ".speed",         XrmoptionSepArg, 0 },
 120   {"-duration",     ".duration",      XrmoptionSepArg, 0 },
 121   {"-mipmaps",      ".mipmap",        XrmoptionNoArg, "True"  },
 122   {"-no-mipmaps",   ".mipmap",        XrmoptionNoArg, "False" },
 123   {"-titles",       ".titles",        XrmoptionNoArg, "True"  },
 124   {"-no-titles",    ".titles",        XrmoptionNoArg, "False" },
 125   {"-polaroid",     ".polaroid",      XrmoptionNoArg, "True"  },
 126   {"-no-polaroid",  ".polaroid",      XrmoptionNoArg, "False" },
 127   {"-clip",         ".clip",          XrmoptionNoArg, "True"  },
 128   {"-no-clip",      ".clip",          XrmoptionNoArg, "False" },
 129   {"-shadows",      ".shadows",       XrmoptionNoArg, "True"  },
 130   {"-no-shadows",   ".shadows",       XrmoptionNoArg, "False" },
 131   {"-debug",        ".debug",         XrmoptionNoArg, "True"  },
 132   {"-font",         ".font",          XrmoptionSepArg, 0 },
 133 };
 134
 135 static argtype vars[] = {
 136   { &scale,         "scale",        "Scale",        DEF_SCALE,       t_Float},
 137   { &max_tilt,      "maxTilt",      "MaxTilt",      DEF_MAX_TILT,    t_Float},
 138   { &speed,         "speed",        "Speed",        DEF_SPEED,       t_Float},
 139   { &duration,      "duration",     "Duration",     DEF_DURATION,    t_Int},
 140   { &mipmap_p,      "mipmap",       "Mipmap",       DEF_MIPMAP,      t_Bool},
 141   { &titles_p,      "titles",       "Titles",       DEF_TITLES,      t_Bool},
 142   { &polaroid_p,    "polaroid",     "Polaroid",     DEF_POLAROID,    t_Bool},
 143   { &clip_p,        "clip",         "Clip",         DEF_CLIP,        t_Bool},
 144   { &shadows_p,     "shadows",      "Shadows",      DEF_SHADOWS,     t_Bool},
 145   { &debug_p,       "debug",        "Debug",        DEF_DEBUG,       t_Bool},
 146 };
 147
 148 ENTRYPOINT ModeSpecOpt photopile_opts = {countof(opts), opts, countof(vars), vars, NULL};
 149
 150
 151 /* Functions to interpolate between image positions.
 152  */
 153 static position
 154 add_pos(position p, position q)
 155 {
 156   p.x += q.x;
 157   p.y += q.y;
 158   p.angle += q.angle;
 159   return p;
 160 }
 161
 162 static position
 163 scale_pos(GLfloat t, position p)
 164 {
 165   p.x *= t;
 166   p.y *= t;
 167   p.angle *= t;
 168   return p;
 169 }
 170
 171 static position
 172 linear_combination(GLfloat t, position p, position q)
 173 {
 174   return add_pos(scale_pos(1.0 - t, p), scale_pos(t, q));
 175 }
 176
 177 static position
 178 interpolate(GLfloat t, position p[4])
 179 {
 180   /* de Casteljau's algorithm, 4 control points */
 181   position p10 = linear_combination(t, p[0], p[1]);
 182   position p11 = linear_combination(t, p[1], p[2]);
 183   position p12 = linear_combination(t, p[2], p[3]);
 184
 185   position p20 = linear_combination(t, p10, p11);
 186   position p21 = linear_combination(t, p11, p12);
 187
 188   return linear_combination(t, p20, p21);
 189 }
 190
 191 static position
 192 offset_pos(position p, GLfloat th, GLfloat r)
 193 {
 194   p.x += cos(th) * r;
 195   p.y += sin(th) * r;
 196   p.angle = (frand(2.0) - 1.0) * max_tilt;
 197   return p;
 198 }
 199
 200 /* Calculate new positions for all images.
 201  */
 202 static void
 203 set_new_positions(photopile_state *ss)
 204 {
 205   ModeInfo *mi = ss->mi;
 206   int i;
 207
 208   for (i = 0; i < MI_COUNT(mi)+1; ++i)
 209     {
 210       image *frame = ss->frames + i;
 211       GLfloat d = sqrt(frame->w*frame->w + frame->h*frame->h);
 212       GLfloat leave = frand(M_PI * 2.0);
 213       GLfloat enter = frand(M_PI * 2.0);
 214
 215       /* start position */
 216       frame->pos[0] = frame->pos[3];
 217
 218       /* end position */
 219       frame->pos[3].x = BELLRAND(MI_WIDTH(mi));
 220       frame->pos[3].y = BELLRAND(MI_HEIGHT(mi));
 221       frame->pos[3].angle = (frand(2.0) - 1.0) * max_tilt;
 222
 223       /* intermediate points */
 224       frame->pos[1] = offset_pos(frame->pos[0], leave, d * (0.5 + frand(1.0)));
 225       frame->pos[2] = offset_pos(frame->pos[3], enter, d * (0.5 + frand(1.0)));
 226     }
 227 }
 228
 229 /* Callback that tells us that the texture has been loaded.
 230  */
 231 static void
 232 image_loaded_cb (const char *filename, XRectangle *geom,
 233                  int image_width, int image_height,
 234                  int texture_width, int texture_height,
 235                  void *closure)
 236 {
 237   photopile_state *ss = (photopile_state *) closure;
 238   ModeInfo *mi = ss->mi;
 239   int wire = MI_IS_WIREFRAME(mi);
 240   image *frame = ss->frames + ss->nframe;
 241
 242   if (wire)
 243     {
 244       if (random() % 2)
 245         {
 246           frame->w = (int)(MI_WIDTH(mi)  * scale) - 1;
 247           frame->h = (int)(MI_HEIGHT(mi) * scale) - 1;
 248         }
 249       else
 250         {
 251           frame->w = (int)(MI_HEIGHT(mi) * scale) - 1;
 252           frame->h = (int)(MI_WIDTH(mi)  * scale) - 1;
 253         }
 254       if (frame->w <= 10) frame->w = 10;
 255       if (frame->h <= 10) frame->h = 10;
 256       frame->geom.width  = frame->w;
 257       frame->geom.height = frame->h;
 258       goto DONE;
 259     }
 260
 261   if (image_width == 0 || image_height == 0)
 262     exit (1);
 263
 264   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 265   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
 266                    mipmap_p ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
 267
 268   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 269   glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 270
 271   frame->w  = image_width;
 272   frame->h  = image_height;
 273   frame->tw = texture_width;
 274   frame->th = texture_height;
 275   frame->geom = *geom;
 276
 277   if (frame->title)
 278     free (frame->title);
 279   frame->title = (filename ? strdup (filename) : 0);
 280
 281   if (frame->title)   /* strip filename to part after last /. */
 282     {
 283       char *s = strrchr (frame->title, '/');
 284       if (s) strcpy (frame->title, s+1);
 285     }
 286
 287   if (debug_p)
 288     fprintf (stderr, "%s:   loaded %4d x %-4d  %4d x %-4d  \"%s\"\n",
 289              progname,
 290              frame->geom.width,
 291              frame->geom.height,
 292              frame->tw, frame->th,
 293              (frame->title ? frame->title : "(null)"));
 294
 295  DONE:
 296   frame->loaded_p = True;
 297 }
 298
 299
 300 /* Load a new file.
 301  */
 302 static void
 303 load_image (ModeInfo *mi)
 304 {
 305   photopile_state *ss = &sss[MI_SCREEN(mi)];
 306   int wire = MI_IS_WIREFRAME(mi);
 307   image *frame = ss->frames + ss->nframe;
 308
 309   if (debug_p && !wire && frame->w != 0)
 310     fprintf (stderr, "%s:  dropped %4d x %-4d  %4d x %-4d  \"%s\"\n",
 311              progname,
 312              frame->geom.width,
 313              frame->geom.height,
 314              frame->tw, frame->th,
 315              (frame->title ? frame->title : "(null)"));
 316
 317   frame->loaded_p = False;
 318
 319   if (wire)
 320     image_loaded_cb (0, 0, 0, 0, 0, 0, ss);
 321   else
 322     {
 323       int w = MI_WIDTH(mi);
 324       int h = MI_HEIGHT(mi);
 325       int size = (int)((w > h ? w : h) * scale);
 326       if (size <= 10) size = 10;
 327       load_texture_async (mi->xgwa.screen, mi->window, *ss->glx_context,
 328                           size, size,
 329                           mipmap_p, frame->texid,
 330                           image_loaded_cb, ss);
 331     }
 332 }
 333
 334
 335 static void
 336 loading_msg (ModeInfo *mi)
 337 {
 338   photopile_state *ss = &sss[MI_SCREEN(mi)];
 339   int wire = MI_IS_WIREFRAME(mi);
 340   const char text[] = "Loading...";
 341
 342   if (wire) return;
 343
 344   if (ss->loading_sw == 0)    /* only do this once */
 345     ss->loading_sw = texture_string_width (ss->texfont, text, &ss->loading_sh);
 346
 347   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 348
 349   glMatrixMode(GL_PROJECTION);
 350   glPushMatrix();
 351   glLoadIdentity();
 352
 353   glMatrixMode(GL_MODELVIEW);
 354   glPushMatrix();
 355   glLoadIdentity();
 356   gluOrtho2D(0, MI_WIDTH(mi), 0, MI_HEIGHT(mi));
 357
 358   glTranslatef ((MI_WIDTH(mi)  - ss->loading_sw) / 2,
 359                 (MI_HEIGHT(mi) - ss->loading_sh) / 2,
 360                 0);
 361   glColor3f (1, 1, 0);
 362   glEnable (GL_TEXTURE_2D);
 363   glDisable (GL_DEPTH_TEST);
 364   print_texture_string (ss->texfont, text);
 365   glEnable (GL_DEPTH_TEST);
 366   glPopMatrix();
 367
 368   glMatrixMode(GL_PROJECTION);
 369   glPopMatrix();
 370
 371   glMatrixMode(GL_MODELVIEW);
 372
 373   glFinish();
 374   glXSwapBuffers (MI_DISPLAY (mi), MI_WINDOW(mi));
 375 }
 376
 377
 378 static Bool
 379 loading_initial_image (ModeInfo *mi)
 380 {
 381   photopile_state *ss = &sss[MI_SCREEN(mi)];
 382
 383   if (ss->frames[ss->nframe].loaded_p)
 384     {
 385       /* The initial image has been fully loaded, start fading it in. */
 386       int i;
 387
 388       for (i = 0; i < ss->nframe; ++i)
 389         {
 390           ss->frames[i].pos[3].x = MI_WIDTH(mi) * 0.5;
 391           ss->frames[i].pos[3].y = MI_HEIGHT(mi) * 0.5;
 392           ss->frames[i].pos[3].angle = 0.0;
 393         }
 394       set_new_positions(ss);
 395
 396       ss->mode = SHUFFLE;
 397       ss->mode_tick = fade_ticks / speed;
 398     }
 399   else
 400     {
 401       loading_msg(mi);
 402     }
 403
 404   return (ss->mode == EARLY);
 405 }
 406
 407
 408 ENTRYPOINT void
 409 reshape_photopile (ModeInfo *mi, int width, int height)
 410 {
 411   glViewport (0, 0, (GLint) width, (GLint) height);
 412
 413   glMatrixMode(GL_PROJECTION);
 414   glLoadIdentity();
 415
 416   glMatrixMode(GL_MODELVIEW);
 417   glLoadIdentity();
 418   gluOrtho2D(0, MI_WIDTH(mi), 0, MI_HEIGHT(mi));
 419
 420   glClear(GL_COLOR_BUFFER_BIT);
 421 }
 422
 423
 424 /* Kludge to add "-v" to invocation of "xscreensaver-getimage" in -debug mode
 425  */
 426 static void
 427 hack_resources (Display *dpy)
 428 {
 429 # ifndef HAVE_COCOA
 430   char *res = "desktopGrabber";
 431   char *val = get_string_resource (dpy, res, "DesktopGrabber");
 432   char buf1[255];
 433   char buf2[255];
 434   XrmValue value;
 435   XrmDatabase db = XtDatabase (dpy);
 436   sprintf (buf1, "%.100s.%.100s", progname, res);
 437   sprintf (buf2, "%.200s -v", val);
 438   value.addr = buf2;
 439   value.size = strlen(buf2);
 440   XrmPutResource (&db, buf1, "String", &value);
 441 # endif /* !HAVE_COCOA */
 442 }
 443
 444
 445 ENTRYPOINT void
 446 init_photopile (ModeInfo *mi)
 447 {
 448   int screen = MI_SCREEN(mi);
 449   photopile_state *ss;
 450   int wire = MI_IS_WIREFRAME(mi);
 451
 452   if (sss == NULL) {
 453     if ((sss = (photopile_state *)
 454          calloc (MI_NUM_SCREENS(mi), sizeof(photopile_state))) == NULL)
 455       return;
 456   }
 457   ss = &sss[screen];
 458   ss->mi = mi;
 459
 460   if ((ss->glx_context = init_GL(mi)) != NULL) {
 461     reshape_photopile (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
 462   } else {
 463     MI_CLEARWINDOW(mi);
 464   }
 465
 466   glDisable (GL_LIGHTING);
 467   glEnable (GL_DEPTH_TEST);
 468   glDisable (GL_CULL_FACE);
 469
 470   if (! wire)
 471     {
 472       glShadeModel (GL_SMOOTH);
 473       glEnable (GL_LINE_SMOOTH);
 474       glHint (GL_LINE_SMOOTH_HINT, GL_NICEST);
 475       glEnable (GL_BLEND);
 476       glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 477     }
 478
 479   ss->shadow = init_drop_shadow();
 480   ss->texfont = load_texture_font (MI_DISPLAY(mi), "font");
 481
 482   if (debug_p)
 483     hack_resources (MI_DISPLAY (mi));
 484
 485   ss->frames = (image *)calloc (MI_COUNT(mi) + 1, sizeof(image));
 486   ss->nframe = 0;
 487   if (!wire)
 488     {
 489       int i;
 490       for (i = 0; i < MI_COUNT(mi) + 1; ++i)
 491         {
 492           glGenTextures (1, &(ss->frames[i].texid));
 493           if (ss->frames[i].texid <= 0) abort();
 494         }
 495     }
 496
 497   ss->mode = EARLY;
 498   load_image(mi); /* start loading the first image */
 499 }
 500
 501
 502 static void
 503 draw_image (ModeInfo *mi, int i, GLfloat t, GLfloat s, GLfloat z)
 504 {
 505   int wire = MI_IS_WIREFRAME(mi);
 506   photopile_state *ss = &sss[MI_SCREEN(mi)];
 507   image *frame = ss->frames + i;
 508
 509   position pos = interpolate(t, frame->pos);
 510   GLfloat w = frame->geom.width * 0.5;
 511   GLfloat h = frame->geom.height * 0.5;
 512   GLfloat z1 = z - 0.25 / (MI_COUNT(mi) + 1);
 513   GLfloat z2 = z - 0.5  / (MI_COUNT(mi) + 1);
 514   GLfloat w1 = w;
 515   GLfloat h1 = h;
 516   GLfloat h2 = h;
 517
 518   if (polaroid_p)
 519     {
 520       GLfloat minSize = MIN(w, h);
 521       GLfloat maxSize = MAX(w, h);
 522
 523       /* Clip or scale image to fit in the frame.
 524        */
 525       if (clip_p)
 526         {
 527           w = h = minSize;
 528         }
 529       else
 530         {
 531           GLfloat scale = minSize / maxSize;
 532           w *= scale;
 533           h *= scale;
 534         }
 535
 536       w1 = minSize * 1.16;      /* enlarge frame border */
 537       h1 = minSize * 1.5;
 538       h2 = w1;
 539       s /= 1.5;                 /* compensate for border size */
 540     }
 541
 542   glPushMatrix();
 543
 544   /* Position and scale this image.
 545    */
 546   glTranslatef (pos.x, pos.y, 0);
 547   glRotatef (pos.angle, 0, 0, 1);
 548   glScalef (s, s, 1);
 549
 550   /* Draw the drop shadow. */
 551   if (shadows_p && !wire)
 552     {
 553       glColor3f (0, 0, 0);
 554       draw_drop_shadow(ss->shadow, -w1, -h1, z2, 2.0 * w1, h1 + h2, 20.0);
 555     }
 556
 557   /* Draw the retro instant-film frame.
 558    */
 559   if (polaroid_p)
 560     {
 561       if (! wire)
 562         {
 563           glColor3f (1, 1, 1);
 564           glBegin (GL_QUADS);
 565           glVertex3f (-w1, -h1, z2);
 566           glVertex3f ( w1, -h1, z2);
 567           glVertex3f ( w1,  h2, z2);
 568           glVertex3f (-w1,  h2, z2);
 569           glEnd();
 570         }
 571
 572       glLineWidth (2.0);
 573       glColor3f (0.5, 0.5, 0.5);
 574       glBegin (GL_LINE_LOOP);
 575       glVertex3f (-w1, -h1, z);
 576       glVertex3f ( w1, -h1, z);
 577       glVertex3f ( w1,  h2, z);
 578       glVertex3f (-w1,  h2, z);
 579       glEnd();
 580     }
 581
 582   /* Draw the image quad.
 583    */
 584   if (! wire)
 585     {
 586       GLfloat texw = w / frame->tw;
 587       GLfloat texh = h / frame->th;
 588       GLfloat texx = (frame->geom.x + 0.5 * frame->geom.width)  / frame->tw;
 589       GLfloat texy = (frame->geom.y + 0.5 * frame->geom.height) / frame->th;
 590
 591       glBindTexture (GL_TEXTURE_2D, frame->texid);
 592       glEnable (GL_TEXTURE_2D);
 593       glColor3f (1, 1, 1);
 594       glBegin (GL_QUADS);
 595       glTexCoord2f (texx - texw, texy + texh); glVertex3f (-w, -h, z1);
 596       glTexCoord2f (texx + texw, texy + texh); glVertex3f ( w, -h, z1);
 597       glTexCoord2f (texx + texw, texy - texh); glVertex3f ( w,  h, z1);
 598       glTexCoord2f (texx - texw, texy - texh); glVertex3f (-w,  h, z1);
 599       glEnd();
 600       glDisable (GL_TEXTURE_2D);
 601     }
 602
 603   /* Draw a box around it.
 604    */
 605   glLineWidth (2.0);
 606   glColor3f (0.5, 0.5, 0.5);
 607   glBegin (GL_LINE_LOOP);
 608   glVertex3f (-w, -h, z);
 609   glVertex3f ( w, -h, z);
 610   glVertex3f ( w,  h, z);
 611   glVertex3f (-w,  h, z);
 612   glEnd();
 613
 614   /* Draw a title under the image.
 615    */
 616   if (titles_p)
 617     {
 618       int sw, sh;
 619       GLfloat scale = 0.6;
 620       char *title = frame->title ? frame->title : "(untitled)";
 621       sw = texture_string_width (ss->texfont, title, &sh);
 622
 623       glTranslatef (-sw*scale*0.5, -h - sh*scale, z);
 624       glScalef (scale, scale, 1);
 625
 626       if (wire || !polaroid_p)
 627         {
 628           glColor3f (1, 1, 1);
 629         }
 630       else
 631         {
 632           glColor3f (0, 0, 0);
 633         }
 634
 635       if (!wire)
 636         {
 637           glEnable (GL_TEXTURE_2D);
 638           print_texture_string (ss->texfont, title);
 639           glDisable (GL_TEXTURE_2D);
 640         }
 641       else
 642         {
 643           glBegin (GL_LINE_LOOP);
 644           glVertex3f (0,  0,  0);
 645           glVertex3f (sw, 0,  0);
 646           glVertex3f (sw, sh, 0);
 647           glVertex3f (0,  sh, 0);
 648           glEnd();
 649         }
 650     }
 651
 652   glPopMatrix();
 653 }
 654
 655
 656 ENTRYPOINT void
 657 draw_photopile (ModeInfo *mi)
 658 {
 659   photopile_state *ss = &sss[MI_SCREEN(mi)];
 660   int i;
 661
 662   if (!ss->glx_context)
 663     return;
 664
 665   glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(ss->glx_context));
 666
 667   if (ss->mode == EARLY)
 668     if (loading_initial_image (mi))
 669       return;
 670
 671   /* Only check the wall clock every 10 frames */
 672   if (ss->now == 0 || ss->draw_tick++ > 10)
 673     {
 674       ss->now = time((time_t *) 0);
 675       if (ss->last_time == 0) ss->last_time = ss->now;
 676       ss->draw_tick = 0;
 677     }
 678
 679   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 680   {
 681     GLfloat t;
 682
 683     /* Handle state transitions. */
 684     switch (ss->mode)
 685       {
 686       case IN:
 687         if (--ss->mode_tick <= 0)
 688           {
 689             ss->mode = NORMAL;
 690             ss->last_time = time((time_t *) 0);
 691           }
 692         break;
 693       case NORMAL:
 694         if (ss->now - ss->last_time > duration)
 695           {
 696             ss->mode = LOADING;
 697             load_image(mi);
 698           }
 699         break;
 700       case LOADING:
 701         if (ss->frames[ss->nframe].loaded_p)
 702           {
 703             set_new_positions(ss);
 704             ss->mode = SHUFFLE;
 705             ss->mode_tick = fade_ticks / speed;
 706           }
 707         break;
 708       case SHUFFLE:
 709         if (--ss->mode_tick <= 0)
 710           {
 711             ss->nframe = (ss->nframe+1) % (MI_COUNT(mi)+1);
 712
 713             ss->mode = NORMAL;
 714             ss->last_time = time((time_t *) 0);
 715           }
 716         break;
 717       default:
 718         abort();
 719       }
 720
 721     t = 1.0 - ss->mode_tick / (fade_ticks / speed);
 722     t = 0.5 * (1.0 - cos(M_PI * t));
 723
 724     /* Draw the images. */
 725     for (i = 0; i < MI_COUNT(mi) + (ss->mode == SHUFFLE); ++i)
 726       {
 727         int j = (ss->nframe + i + 1) % (MI_COUNT(mi) + 1);
 728
 729         if (ss->frames[j].loaded_p)
 730           {
 731             GLfloat s = 1.0;
 732             GLfloat z = (GLfloat)i / (MI_COUNT(mi) + 1);
 733
 734             switch (ss->mode)
 735               {
 736               case IN:
 737                 s *= t;
 738                 break;
 739               case NORMAL:
 740               case LOADING:
 741                 t = 1.0;
 742                 break;
 743               case SHUFFLE:
 744                 if (i == MI_COUNT(mi))
 745                   {
 746                     s *= t;
 747                   }
 748                 else if (i == 0)
 749                   {
 750                     s *= 1.0 - t;
 751                   }
 752                 break;
 753               default:
 754                 abort();
 755               }
 756
 757             draw_image(mi, j, t, s, z);
 758           }
 759       }
 760   }
 761
 762   if (mi->fps_p) do_fps (mi);
 763   glFinish();
 764   glXSwapBuffers (MI_DISPLAY (mi), MI_WINDOW(mi));
 765 }
 766
 767 XSCREENSAVER_MODULE ("Photopile", photopile)
 768
 769 #endif /* USE_GL */