[xscreensaver] / hacks / glx / glmatrix.c

/* glmatrix, Copyright (c) 2003 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 *
 * GLMatrix -- simulate the text scrolls from the movie "The Matrix".
 *
 * This program does a 3D rendering of the dropping characters that
 * appeared in the title sequences of the movies.  See also `xmatrix'
 * for a simulation of what the computer monitors actually *in* the
 * movie did.
 */

#include <X11/Intrinsic.h>

extern XtAppContext app;

#define PROGCLASS       "GLMatrix"
#define HACK_INIT       init_matrix
#define HACK_DRAW       draw_matrix
#define HACK_RESHAPE    reshape_matrix
#define HACK_HANDLE_EVENT matrix_handle_event
#define EVENT_MASK      PointerMotionMask
#define matrix_opts     xlockmore_opts

#define DEF_SPEED       "1.0"
#define DEF_DENSITY     "20"
#define DEF_FOG         "True"
#define DEF_WAVES       "True"
#define DEF_ROTATE      "True"
#define DEF_TEXTURE     "True"
#define DEF_MODE        "Matrix"

#define DEFAULTS        "*delay:        30000         \n" \
                        "*showFPS:      False         \n" \
                        "*wireframe:    False         \n" \
                        "*mode:       " DEF_MODE    " \n" \
                        "*speed:      " DEF_SPEED   " \n" \
                        "*density:    " DEF_DENSITY " \n" \
                        "*fog:        " DEF_FOG     " \n" \
                        "*waves:      " DEF_WAVES   " \n" \
                        "*texture:    " DEF_TEXTURE " \n" \
                        "*rotate:     " DEF_ROTATE  " \n" \

#undef countof
#define countof(x) (sizeof((x))/sizeof((*x)))

#undef BELLRAND
#define BELLRAND(n) ((frand((n)) + frand((n)) + frand((n))) / 3)

#include "xlockmore.h"
#include "xpm-ximage.h"
#include <ctype.h>

#include "../images/matrix3.xpm"

#ifdef USE_GL /* whole file */

#include <GL/glu.h>


#include "gllist.h"


#define CHAR_COLS 16
#define CHAR_ROWS 13
static int real_char_rows;

static int matrix_encoding[] = { 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
                                 192, 193, 194, 195, 196, 197, 198, 199,
                                 200, 201, 202, 203, 204, 205, 206, 207 };
static int decimal_encoding[]  = { 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 };
static int hex_encoding[]      = { 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
                                   33, 34, 35, 36, 37, 38 };
static int binary_encoding[] = { 16, 17 };
static int dna_encoding[]    = { 33, 35, 39, 52 };
#if 0
static unsigned char char_map[256] = {
    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  /*   0 */
    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  /*  16 */
    0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,  /*  32 */
   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,  /*  48 */
   32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,  /*  64 */
   48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,  /*  80 */
   64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,  /*  96 */
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,  /* 112 */
    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  /* 128 */
    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  /* 144 */
   96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,  /* 160 */
  112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,  /* 176 */
  128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,  /* 192 */
  144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,  /* 208 */
  160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,  /* 224 */
  176,177,178,195,180,181,182,183,184,185,186,187,188,189,190,191   /* 240 */
};
#endif /* 0 */

#define CURSOR_GLYPH 97

/* #define DEBUG */

#define GRID_SIZE  70     /* width and height of the arena */
#define GRID_DEPTH 35     /* depth of the arena */
#define WAVE_SIZE  22     /* periodicity of color (brightness) waves */
#define SPLASH_RATIO 0.7  /* ratio of GRID_DEPTH where chars hit the screen */

static struct { GLfloat x, y; } nice_views[] = {
  {  0,     0 },
  {  0,   -20 },     /* this is a list of viewer rotations that look nice. */
  {  0,    20 },     /* every now and then we switch to a new one.         */
  { 25,     0 },     /* (but we only use the first one at start-up.)       */
  {-25,     0 },
  { 25,    20 },
  {-25,    20 },
  { 25,   -20 },
  {-25,   -20 },

  { 10,     0 },
  {-10,     0 },
  {  0,     0 },  /* prefer these */
  {  0,     0 },
  {  0,     0 },
  {  0,     0 },
  {  0,     0 },
};


typedef struct {
  GLfloat x, y, z;        /* position of strip */
  GLfloat dx, dy, dz;     /* velocity of strip */

  Bool erasing_p;         /* Whether this strip is on its way out. */

  int spinner_glyph;      /* the bottommost glyph -- the feeder */
  GLfloat spinner_y;      /* where on the strip the bottom glyph is */
  GLfloat spinner_speed;  /* how fast the bottom glyph drops */

  int glyphs[GRID_SIZE];  /* the other glyphs on the strip, which will be
                             revealed by the dropping spinner.
                             0 means no glyph; negative means "spinner".
                             If non-zero, real value is abs(G)-1. */

  int spin_speed;         /* Rotate all spinners every this-many frames */
  int spin_tick;          /* frame counter */

  int wave_position;      /* Waves of brightness wash down the strip. */
  int wave_speed;         /* every this-many frames. */
  int wave_tick;          /* frame counter. */

} strip;


typedef struct {
  GLXContext *glx_context;
  Bool button_down_p;
  GLuint texture;
  int nstrips;
  strip *strips;
  int *glyph_map;
  int nglyphs;
  GLfloat tex_char_width, tex_char_height;

  /* auto-tracking direction of view */
  int last_view, target_view;
  GLfloat view_x, view_y;
  int view_steps, view_tick;
  Bool auto_tracking_p;

} matrix_configuration;

static matrix_configuration *mps = NULL;

static GLfloat brightness_ramp[WAVE_SIZE];

static GLfloat speed;
static GLfloat density;
static Bool do_fog;
static Bool do_waves;
static Bool do_rotate;
static Bool do_texture;
static char *mode_str;

static XrmOptionDescRec opts[] = {
  { "-speed",       ".speed",     XrmoptionSepArg, 0 },
  { "-density",     ".density",   XrmoptionSepArg, 0 },
  { "-mode",        ".mode",      XrmoptionSepArg, 0 },
  { "-binary",      ".mode",      XrmoptionNoArg, "binary"      },
  { "-hexadecimal", ".mode",      XrmoptionNoArg, "hexadecimal" },
  { "-decimal",     ".mode",      XrmoptionNoArg, "decimal"     },
  { "-dna",         ".mode",      XrmoptionNoArg, "dna"         },
  { "-fog",         ".fog",       XrmoptionNoArg, "True"  },
  { "+fog",         ".fog",       XrmoptionNoArg, "False" },
  { "-waves",       ".waves",     XrmoptionNoArg, "True"  },
  { "+waves",       ".waves",     XrmoptionNoArg, "False" },
  { "-rotate",      ".rotate",    XrmoptionNoArg, "True"  },
  { "+rotate",      ".rotate",    XrmoptionNoArg, "False" },
  {"-texture",      ".texture",   XrmoptionNoArg, "True"  },
  {"+texture",      ".texture",   XrmoptionNoArg, "False" },
};

static argtype vars[] = {
  {(caddr_t *) &mode_str,   "mode",       "Mode",    DEF_MODE,      t_String},
  {(caddr_t *) &speed,      "speed",      "Speed",   DEF_SPEED,     t_Float},
  {(caddr_t *) &density,    "density",    "Density", DEF_DENSITY,   t_Float},
  {(caddr_t *) &do_fog,     "fog",        "Fog",     DEF_FOG,       t_Bool},
  {(caddr_t *) &do_waves,   "waves",      "Waves",   DEF_WAVES,     t_Bool},
  {(caddr_t *) &do_rotate,  "rotate",     "Rotate",  DEF_ROTATE,    t_Bool},
  {(caddr_t *) &do_texture, "texture",    "Texture", DEF_TEXTURE,   t_Bool},
};

ModeSpecOpt matrix_opts = {countof(opts), opts, countof(vars), vars, NULL};


/* Re-randomize the state of one strip.
 */
static void
reset_strip (ModeInfo *mi, strip *s)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];
  int i;

  memset (s, 0, sizeof(*s));
  s->x = (GLfloat) (frand(GRID_SIZE) - (GRID_SIZE/2));
  s->y = (GLfloat) (GRID_SIZE/2 + BELLRAND(0.5));      /* shift top slightly */
  s->z = (GLfloat) (GRID_DEPTH * 0.2) - frand (GRID_DEPTH * 0.7);
  s->spinner_y = 0;

  s->dx = 0;
/*  s->dx = ((BELLRAND(0.01) - 0.005) * speed); */
  s->dy = 0;
  s->dz = (BELLRAND(0.02) * speed);

  s->spinner_speed = (BELLRAND(0.3) * speed);

  s->spin_speed = (int) BELLRAND(2.0 / speed) + 1;
  s->spin_tick  = 0;

  s->wave_position = 0;
  s->wave_speed = (int) BELLRAND(3.0 / speed) + 1;
  s->wave_tick  = 0;

  for (i = 0; i < GRID_SIZE; i++)
    {
      int draw_p = (random() % 7);
      int spin_p = (draw_p && !(random() % 20));
      int g = (draw_p
               ? mp->glyph_map[(random() % mp->nglyphs)] + 1
               : 0);
      if (spin_p) g = -g;
      s->glyphs[i] = g;
    }
  s->spinner_glyph = - (mp->glyph_map[(random() % mp->nglyphs)] + 1);
}


/* Animate the strip one step.  Reset if it has reached the bottom.
 */
static void
tick_strip (ModeInfo *mi, strip *s)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];
  int i;

  if (mp->button_down_p)
    return;

  s->x += s->dx;
  s->y += s->dy;
  s->z += s->dz;

  if (s->z > GRID_DEPTH * SPLASH_RATIO)  /* splashed into screen */
    {
      reset_strip (mi, s);
      return;
    }

  s->spinner_y += s->spinner_speed;
  if (s->spinner_y >= GRID_SIZE)
    {
      if (s->erasing_p)
        {
          reset_strip (mi, s);
          return;
        }
      else
        {
          s->erasing_p = True;
          s->spinner_y = 0;
          s->spinner_speed /= 2;  /* erase it slower than we drew it */
        }
    }

  /* Spin the spinners. */
  s->spin_tick++;
  if (s->spin_tick > s->spin_speed)
    {
      s->spin_tick = 0;
      s->spinner_glyph = - (mp->glyph_map[(random() % mp->nglyphs)] + 1);
      for (i = 0; i < GRID_SIZE; i++)
        if (s->glyphs[i] < 0)
          {
            s->glyphs[i] = -(mp->glyph_map[(random() % mp->nglyphs)] + 1);
            if (! (random() % 800))  /* sometimes they stop spinning */
              s->glyphs[i] = -s->glyphs[i];
          }
    }

  /* Move the color (brightness) wave. */
  s->wave_tick++;
  if (s->wave_tick > s->wave_speed)
    {
      s->wave_tick = 0;
      s->wave_position++;
      if (s->wave_position >= WAVE_SIZE)
        s->wave_position = 0;
    }
}


/* Draw a single character at the given position and brightness.
 */
static void
draw_glyph (ModeInfo *mi, int glyph,
            GLfloat x, GLfloat y, GLfloat z,
            GLfloat brightness)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];
  int wire = MI_IS_WIREFRAME(mi);
  GLfloat w = mp->tex_char_width;
  GLfloat h = mp->tex_char_height;
  GLfloat cx, cy;
  GLfloat S = 1;
  Bool spinner_p = (glyph < 0);

  if (glyph == 0) abort();
  if (glyph < 0) glyph = -glyph;

  if (spinner_p)
    brightness *= 1.5;

  if (!do_texture)
    {
      S  = 0.8;
      x += 0.1;
      y += 0.1;
    }
  else
    {
      int ccx = ((glyph - 1) % CHAR_COLS);
      int ccy = ((glyph - 1) / CHAR_COLS);

      cx = ccx * w;
      cy = (real_char_rows - ccy - 1) * h;

      if (do_fog)
        {
          GLfloat depth;
          depth = (z / GRID_DEPTH) + 0.5;  /* z ratio from back/front      */
          depth = 0.2 + (depth * 0.8);     /* scale to range [0.2 - 1.0]   */
          brightness *= depth;             /* so no row goes all black.    */
        }
    }

  {
    GLfloat r, g, b, a = 1;
    if (!do_texture && !spinner_p)
      r = b = 0, g = brightness;
    else
      r = g = b = brightness;

    /* If the glyph is very close to the screen (meaning it is very large,
       and is about to splash into the screen and vanish) then start fading
       it out, proportional to how close to the glass it is.
    */
    if (z > GRID_DEPTH/2)
      {
        GLfloat ratio = ((z - GRID_DEPTH/2) /
                         ((GRID_DEPTH * SPLASH_RATIO) - GRID_DEPTH/2));
        int i = ratio * WAVE_SIZE;

        if (i < 0) i = 0;
        else if (i >= WAVE_SIZE) i = WAVE_SIZE-1; 

        a = brightness_ramp[i];
#if 1
        /* I don't understand this -- if I change the alpha on the color of
           the quad, I'd expect that to make the quad more transparent.
           But instead, it seems to be making the transparent parts of the
           texture on the quad be *less* transparent!  So as we fade out,
           we fade towards a completely solid rectangle.  WTF?

           So, for now, instead of changing the alpha, just make the colors
           be darker.  This isn't quite right (it causes a large dark glyph
           to occlude the brighter glyphs behind it) but it's close...
         */
        r *= a;
        g *= a;
        b *= a;
        a = 1;
#endif
      }

    glColor4f (r,g,b,a);
  }

  glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
  glNormal3f (0, 0, 1);
  glTexCoord2f (cx,   cy);   glVertex3f (x,   y,   z);
  glTexCoord2f (cx+w, cy);   glVertex3f (x+S, y,   z);
  glTexCoord2f (cx+w, cy+h); glVertex3f (x+S, y+S, z);
  glTexCoord2f (cx,   cy+h); glVertex3f (x,   y+S, z);
  glEnd ();

  if (wire && spinner_p)
    {
      glBegin (GL_LINES);
      glVertex3f (x,   y,   z);
      glVertex3f (x+S, y+S, z);
      glVertex3f (x,   y+S, z);
      glVertex3f (x+S, y,   z);
      glEnd();
    }

  mi->polygon_count++;
}


/* Draw all the visible glyphs in the strip.
 */
static void
draw_strip (ModeInfo *mi, strip *s)
{
  int i;
  for (i = 0; i < GRID_SIZE; i++)
    {
      int g = s->glyphs[i];
      Bool below_p = (s->spinner_y >= i);

      if (s->erasing_p)
        below_p = !below_p;

      if (g && below_p)       /* don't draw cells below the spinner */
        {
          GLfloat brightness;
          if (!do_waves)
            brightness = 1.0;
          else
            {
              int j = WAVE_SIZE - ((i + (GRID_SIZE - s->wave_position))
                                   % WAVE_SIZE);
              brightness = brightness_ramp[j];
            }

          draw_glyph (mi, g, s->x, s->y - i, s->z, brightness);
        }
    }

  if (!s->erasing_p)
    draw_glyph (mi, s->spinner_glyph, s->x, s->y - s->spinner_y, s->z, 1.0);
}


/* qsort comparator for sorting strips by z position */
static int
cmp_strips (const void *aa, const void *bb)
{
  const strip *a = *(strip **) aa;
  const strip *b = *(strip **) bb;
  return ((int) (a->z * 10000) -
          (int) (b->z * 10000));
}


/* Auto-tracking
 */

static void
auto_track_init (ModeInfo *mi)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];
  mp->last_view = 0;
  mp->target_view = 0;
  mp->view_x = nice_views[mp->last_view].x;
  mp->view_y = nice_views[mp->last_view].y;
  mp->view_steps = 100;
  mp->view_tick = 0;
  mp->auto_tracking_p = False;
}


static void
auto_track (ModeInfo *mi)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];

  if (! do_rotate)
    return;
  if (mp->button_down_p)
    return;

  /* if we're not moving, maybe start moving.  Otherwise, do nothing. */
  if (! mp->auto_tracking_p)
    {
      static int tick = 0;
      if (++tick < 20/speed) return;
      tick = 0;
      if (! (random() % 20))
        mp->auto_tracking_p = True;
      else
        return;
    }


  {
    GLfloat ox = nice_views[mp->last_view].x;
    GLfloat oy = nice_views[mp->last_view].y;
    GLfloat tx = nice_views[mp->target_view].x;
    GLfloat ty = nice_views[mp->target_view].y;

    /* move from A to B with sinusoidal deltas, so that it doesn't jerk
       to a stop. */
    GLfloat th = sin ((M_PI / 2) * (double) mp->view_tick / mp->view_steps);

    mp->view_x = (ox + ((tx - ox) * th));
    mp->view_y = (oy + ((ty - oy) * th));
    mp->view_tick++;

  if (mp->view_tick >= mp->view_steps)
    {
      mp->view_tick = 0;
      mp->view_steps = (350.0 / speed);
      mp->last_view = mp->target_view;
      mp->target_view = (random() % (countof(nice_views) - 1)) + 1;
      mp->auto_tracking_p = False;
    }
  }
}


/* Window management, etc
 */
void
reshape_matrix (ModeInfo *mi, int width, int height)
{
  GLfloat h = (GLfloat) height / (GLfloat) width;

  glViewport (0, 0, (GLint) width, (GLint) height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective (80.0, 1/h, 1.0, 100);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt( 0.0, 0.0, 25.0,
             0.0, 0.0, 0.0,
             0.0, 1.0, 0.0);

  glClear(GL_COLOR_BUFFER_BIT);
}


Bool
matrix_handle_event (ModeInfo *mi, XEvent *event)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];

  if (event->xany.type == ButtonPress &&
      event->xbutton.button & Button1)
    {
      mp->button_down_p = True;
      return True;
    }
  else if (event->xany.type == ButtonRelease &&
           event->xbutton.button & Button1)
    {
      mp->button_down_p = False;
      return True;
    }

  return False;
}


static Bool
bigendian (void)
{
  union { int i; char c[sizeof(int)]; } u;
  u.i = 1;
  return !u.c[0];
}


/* The image with the characters in it is 512x598, meaning that it needs to
   be copied into a 512x1024 texture.  But some machines can't handle textures
   that large...  And it turns out that we aren't using most of the characters
   in that image anyway, since this program doesn't do anything that makes use
   of the full range of Latin1 characters.  So... this function tosses out the
   last 32 of the Latin1 characters, resulting in a 512x506 image, which we
   can then stuff in a 512x512 texture.  Voila.

   If this hack ever grows into something that displays full Latin1 text,
   well then, Something Else Will Need To Be Done.
 */
static void
spank_image (XImage *xi)
{
  int ch = xi->height / CHAR_ROWS;
  int cut = 2;
  unsigned char *bits = (unsigned char *) xi->data;
  unsigned char *from, *to, *s, *end;
  int L = xi->bytes_per_line * ch;
  int i;

  /* Copy row 12 into 10 (which really means, copy 2 into 0,
     since texture data is upside down.).
  */
  to   = bits + (L * cut);
  from = bits;
  end  = from + L;
  s    = from;
  while (s < end)
    *to++ = *s++;

  /* Then, pull all the bits down by 2 rows.
   */
  to   = bits;
  from = bits + (L * cut);
  end  = bits + (L * CHAR_ROWS);
  s    = from;
  while (s < end)
    *to++ = *s++;

  /* And clear out the rest, for good measure.
   */
  from = bits + (L * (CHAR_ROWS - cut));
  end  = bits + (L * CHAR_ROWS);
  s    = from;
  while (s < end)
    *s++ = 0;

  xi->height -= (cut * ch);
  real_char_rows -= cut;

  /* Finally, pull the map indexes back to match the new bits.
   */
  for (i = 0; i < countof(matrix_encoding); i++)
    if (matrix_encoding[i] > (CHAR_COLS * (CHAR_ROWS - cut)))
      matrix_encoding[i] -= (cut * CHAR_COLS);
}


static void
load_textures (ModeInfo *mi, Bool flip_p)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];
  XImage *xi;
  int x, y;
  int cw, ch;
  int orig_w, orig_h;

  /* The Matrix XPM is 512x598 -- but GL texture sizes must be powers of 2.
     So we waste some padding rows to round up.
   */
  xi = xpm_to_ximage (mi->dpy, mi->xgwa.visual, mi->xgwa.colormap,
                      matrix3_xpm);
  orig_w = xi->width;
  orig_h = xi->height;
  real_char_rows = CHAR_ROWS;
  spank_image (xi);

  if (xi->height != 512 && xi->height != 1024)
    {
      xi->height = (xi->height < 512 ? 512 : 1024);
      xi->data = realloc (xi->data, xi->height * xi->bytes_per_line);
      if (!xi->data)
        {
          fprintf(stderr, "%s: out of memory\n", progname);
          exit(1);
        }
    }

  if (xi->width != 512) abort();
  if (xi->height != 512 && xi->height != 1024) abort();

  /* char size in pixels */
  cw = orig_w / CHAR_COLS;
  ch = orig_h / CHAR_ROWS;

  /* char size in ratio of final (padded) texture size */
  mp->tex_char_width  = (GLfloat) cw / xi->width;
  mp->tex_char_height = (GLfloat) ch / xi->height;

  /* Flip each character's bits horizontally -- we could also just do this
     by reversing the texture coordinates on the quads, but on some systems
     that slows things down a lot.
   */
  if (flip_p)
    {
      int xx, col;
      unsigned long buf[100];
      for (y = 0; y < xi->height; y++)
        for (col = 0, xx = 0; col < CHAR_COLS; col++, xx += cw)
          {
            for (x = 0; x < cw; x++)
              buf[x] = XGetPixel (xi, xx+x, y);
            for (x = 0; x < cw; x++)
              XPutPixel (xi, xx+x, y, buf[cw-x-1]);
          }
    }

  /* The pixmap is a color image with no transparency.  Set the texture's
     alpha to be the green channel, and set the green channel to be 100%.
   */
  {
    int rpos, gpos, bpos, apos;  /* bitfield positions */
    if (bigendian())
      rpos = 24, gpos = 16, bpos =  8, apos =  0;
    else
      rpos =  0, gpos =  8, bpos = 16, apos = 24;

    for (y = 0; y < xi->height; y++)
      for (x = 0; x < xi->width; x++)
        {
          unsigned long p = XGetPixel (xi, x, y);
          unsigned char r = (p >> rpos) & 0xFF;
          unsigned char g = (p >> gpos) & 0xFF;
          unsigned char b = (p >> bpos) & 0xFF;
          unsigned char a = ~g;
          g = 0xFF;
          p = (r << rpos) | (g << gpos) | (b << bpos) | (a << apos);
          XPutPixel (xi, x, y, p);
        }
  }

  /* Now load the texture into GL.
   */
  clear_gl_error();
  glGenTextures (1, &mp->texture);

  glPixelStorei (GL_UNPACK_ALIGNMENT, 4);
  glPixelStorei (GL_UNPACK_ROW_LENGTH, xi->width);
  glBindTexture (GL_TEXTURE_2D, mp->texture);
  check_gl_error ("texture init");
  glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, xi->width, xi->height, 0, GL_RGBA,
                GL_UNSIGNED_INT_8_8_8_8_REV, xi->data);
  {
    char buf[255];
    sprintf (buf, "creating %dx%d texture:", xi->width, xi->height);
    check_gl_error (buf);
  }

  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  /* I'd expect CLAMP to be the thing to do here, but oddly, we get a
     faint solid green border around the texture if it is *not* REPEAT!
  */
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
  check_gl_error ("texture param");

  xi->data = 0;  /* don't free the texture data */
  XDestroyImage (xi);
}


void 
init_matrix (ModeInfo *mi)
{
  matrix_configuration *mp;
  int wire = MI_IS_WIREFRAME(mi);
  Bool flip_p = 0;
  int i;

  if (wire)
    do_texture = False;

  if (!mps) {
    mps = (matrix_configuration *)
      calloc (MI_NUM_SCREENS(mi), sizeof (matrix_configuration));
    if (!mps) {
      fprintf(stderr, "%s: out of memory\n", progname);
      exit(1);
    }
  }

  mp = &mps[MI_SCREEN(mi)];
  mp->glx_context = init_GL(mi);

  if (!mode_str || !*mode_str || !strcasecmp(mode_str, "matrix"))
    {
      flip_p = 1;
      mp->glyph_map = matrix_encoding;
      mp->nglyphs   = countof(matrix_encoding);
    }
  else if (!strcasecmp (mode_str, "dna"))
    {
      flip_p = 0;
      mp->glyph_map = dna_encoding;
      mp->nglyphs   = countof(dna_encoding);
    }
  else if (!strcasecmp (mode_str, "bin") ||
           !strcasecmp (mode_str, "binary"))
    {
      flip_p = 0;
      mp->glyph_map = binary_encoding;
      mp->nglyphs   = countof(binary_encoding);
    }
  else if (!strcasecmp (mode_str, "hex") ||
           !strcasecmp (mode_str, "hexadecimal"))
    {
      flip_p = 0;
      mp->glyph_map = hex_encoding;
      mp->nglyphs   = countof(hex_encoding);
    }
  else if (!strcasecmp (mode_str, "dec") ||
           !strcasecmp (mode_str, "decimal"))
    {
      flip_p = 0;
      mp->glyph_map = decimal_encoding;
      mp->nglyphs   = countof(decimal_encoding);
    }
  else
    {
      fprintf (stderr,
           "%s: `mode' must be matrix, dna, binary, or hex: not `%s'\n",
               progname, mode_str);
      exit (1);
    }

  reshape_matrix (mi, MI_WIDTH(mi), MI_HEIGHT(mi));

  glShadeModel(GL_SMOOTH);

  glDisable(GL_DEPTH_TEST);
  glDisable(GL_CULL_FACE);
  glEnable(GL_NORMALIZE);

  if (do_texture)
    {
      load_textures (mi, flip_p);
      glEnable(GL_TEXTURE_2D);
      glEnable(GL_BLEND);
      glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA);
    }

  /* to scale coverage-percent to strips, this number looks about right... */
  mp->nstrips = (int) (density * 2.2);
  if      (mp->nstrips < 1)    mp->nstrips = 1;
  else if (mp->nstrips > 2000) mp->nstrips = 2000;


  mp->strips = calloc (mp->nstrips, sizeof(strip));
  for (i = 0; i < mp->nstrips; i++)
    {
      strip *s = &mp->strips[i];
      reset_strip (mi, s);

      /* If we start all strips from zero at once, then the first few seconds
         of the animation are much denser than normal.  So instead, set all
         the initial strips to erase-mode with random starting positions.
         As these die off at random speeds and are re-created, we'll get a
         more consistent density. */
      s->erasing_p = True;
      s->spinner_y = frand(GRID_SIZE);
      memset (s->glyphs, 0, sizeof(s->glyphs));  /* no visible glyphs */
    }

  /* Compute the brightness ramp.
   */
  for (i = 0; i < WAVE_SIZE; i++)
    {
      GLfloat j = ((WAVE_SIZE - i) / (GLfloat) (WAVE_SIZE - 1));
      j *= (M_PI / 2);       /* j ranges from 0.0 - PI/2  */
      j = sin (j);           /* j ranges from 0.0 - 1.0   */
      j = 0.2 + (j * 0.8);   /* j ranges from 0.2 - 1.0   */
      brightness_ramp[i] = j;
      /* printf("%2d %8.2f\n", i, j); */
    }


  auto_track_init (mi);
}


#ifdef DEBUG

static void
draw_grid (ModeInfo *mi)
{
  if (!MI_IS_WIREFRAME(mi))
    {
      glDisable(GL_TEXTURE_2D);
      glDisable(GL_BLEND);
    }
  glPushMatrix();
  glColor3f(1, 1, 1);
  glBegin(GL_LINES);
  glVertex3f(-GRID_SIZE, 0, 0); glVertex3f(GRID_SIZE, 0, 0);
  glVertex3f(0, -GRID_SIZE, 0); glVertex3f(0, GRID_SIZE, 0);
  glEnd();
  glBegin(GL_LINE_LOOP);
  glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2, 0);
  glVertex3f(-GRID_SIZE/2,  GRID_SIZE/2, 0);
  glVertex3f( GRID_SIZE/2,  GRID_SIZE/2, 0);
  glVertex3f( GRID_SIZE/2, -GRID_SIZE/2, 0);
  glEnd();
  glBegin(GL_LINE_LOOP);
  glVertex3f(-GRID_SIZE/2, GRID_SIZE/2, -GRID_DEPTH/2);
  glVertex3f(-GRID_SIZE/2, GRID_SIZE/2,  GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2, GRID_SIZE/2,  GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2, GRID_SIZE/2, -GRID_DEPTH/2);
  glEnd();
  glBegin(GL_LINE_LOOP);
  glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
  glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
  glEnd();
  glBegin(GL_LINES);
  glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
  glVertex3f(-GRID_SIZE/2,  GRID_SIZE/2, -GRID_DEPTH/2);
  glVertex3f(-GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
  glVertex3f(-GRID_SIZE/2,  GRID_SIZE/2,  GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2, -GRID_SIZE/2, -GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2,  GRID_SIZE/2, -GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2, -GRID_SIZE/2,  GRID_DEPTH/2);
  glVertex3f( GRID_SIZE/2,  GRID_SIZE/2,  GRID_DEPTH/2);
  glEnd();
  glPopMatrix();
  if (!MI_IS_WIREFRAME(mi))
    {
      glEnable(GL_TEXTURE_2D);
      glEnable(GL_BLEND);
    }
}
#endif /* DEBUG */


void
draw_matrix (ModeInfo *mi)
{
  matrix_configuration *mp = &mps[MI_SCREEN(mi)];
  Display *dpy = MI_DISPLAY(mi);
  Window window = MI_WINDOW(mi);
  int i;

  if (!mp->glx_context)
    return;

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix ();

  if (do_rotate)
    {
      glRotatef (mp->view_x, 1, 0, 0);
      glRotatef (mp->view_y, 0, 1, 0);
    }

#ifdef DEBUG
# if 0
  glScalef(0.5, 0.5, 0.5);
# endif
# if 0
  glRotatef(-30, 0, 1, 0); 
# endif
  draw_grid (mi);
#endif

  mi->polygon_count = 0;

  /* Render (and tick) each strip, starting at the back
     (draw the ones farthest from the camera first, to make
     the alpha transparency work out right.)
   */
  {
    strip **sorted = malloc (mp->nstrips * sizeof(*sorted));
    for (i = 0; i < mp->nstrips; i++)
      sorted[i] = &mp->strips[i];
    qsort (sorted, i, sizeof(*sorted), cmp_strips);

    for (i = 0; i < mp->nstrips; i++)
      {
        strip *s = sorted[i];
        tick_strip (mi, s);
        draw_strip (mi, s);
      }
    free (sorted);
  }

  auto_track (mi);

#if 0
  glBegin(GL_QUADS);
  glColor3f(1,1,1);
  glTexCoord2f (0,0);  glVertex3f(-15,-15,0);
  glTexCoord2f (0,1);  glVertex3f(-15,15,0);
  glTexCoord2f (1,1);  glVertex3f(15,15,0);
  glTexCoord2f (1,0);  glVertex3f(15,-15,0);
  glEnd();
#endif

  glPopMatrix ();

  if (mi->fps_p) do_fps (mi);
  glFinish();

  glXSwapBuffers(dpy, window);
}

#endif /* USE_GL */