wmMatrix/matrix.c

   1 /* xscreensaver, Copyright (c) 1999 Jamie Zawinski <jwz@jwz.org>
   2  *
   3  * Permission to use, copy, modify, distribute, and sell this software and its
   4  * documentation for any purpose is hereby granted without fee, provided that
   5  * the above copyright notice appear in all copies and that both that
   6  * copyright notice and this permission notice appear in supporting
   7  * documentation.  No representations are made about the suitability of this
   8  * software for any purpose.  It is provided "as is" without express or
   9  * implied warranty.
  10  *
  11  * Matrix -- simulate the text scrolls from the movie "The Matrix".
  12  *
  13  * The movie people distribute their own Windows/Mac screensaver that does
  14  * a similar thing, so I wrote one for Unix.  However, that version (the
  15  * Windows/Mac version at http://www.whatisthematrix.com/) doesn't match my
  16  * memory of what the screens in the movie looked like, so my `xmatrix'
  17  * does things differently.
  18  */
  19
  20 #include <stdio.h>
  21 #include "images/small.xpm"
  22 #include "images/medium.xpm"
  23 #include "images/large.xpm"
  24 #include "images/matrix.xbm"
  25 /*
  26 #define CHAR_HEIGHT 4
  27 */
  28
  29 #include "matrix.h"
  30 /*
  31 #include "resources.h"
  32 */
  33
  34 extern GC              NormalGC;
  35 extern GC              EraseGC;
  36 extern Pixel           back_pix, fore_pix;
  37 extern int             PixmapSize;
  38 int                    CHAR_HEIGHT;
  39
  40
  41
  42
  43
  44 static void load_images (m_state *state) {
  45
  46   if (state->xgwa.depth > 1) {
  47
  48       XpmAttributes xpmattrs;
  49       int result;
  50
  51       xpmattrs.valuemask  = 0;
  52       xpmattrs.valuemask |= XpmCloseness;
  53       xpmattrs.closeness  = 40000;
  54       xpmattrs.valuemask |= XpmVisual;
  55       xpmattrs.visual     = state->xgwa.visual;
  56       xpmattrs.valuemask |= XpmDepth;
  57       xpmattrs.depth      = state->xgwa.depth;
  58       xpmattrs.valuemask |= XpmColormap;
  59       xpmattrs.colormap   = state->xgwa.colormap;
  60
  61       if (PixmapSize == 1){
  62
  63           CHAR_HEIGHT = 4;
  64           result = XpmCreatePixmapFromData (state->dpy, state->window, small,
  65                                         &state->images, 0 /* mask */,
  66                                         &xpmattrs);
  67       } else if (PixmapSize == 2){
  68
  69           CHAR_HEIGHT = 6;
  70           result = XpmCreatePixmapFromData (state->dpy, state->window, medium,
  71                                         &state->images, 0 /* mask */,
  72                                         &xpmattrs);
  73       } else {
  74
  75           CHAR_HEIGHT = 8;
  76           result = XpmCreatePixmapFromData (state->dpy, state->window, large,
  77                                         &state->images, 0 /* mask */,
  78                                         &xpmattrs);
  79       }
  80
  81       if (!state->images || (result != XpmSuccess && result != XpmColorError))
  82         state->images = 0;
  83
  84       state->image_width = xpmattrs.width;
  85       state->image_height = xpmattrs.height;
  86       state->nglyphs = state->image_height / CHAR_HEIGHT;
  87
  88     } else {
  89
  90       state->image_width = matrix_width;
  91       state->image_height = matrix_height;
  92       state->nglyphs = state->image_height / CHAR_HEIGHT;
  93
  94       state->images = XCreatePixmapFromBitmapData (state->dpy, state->window,
  95                                      (char *) matrix_bits,
  96                                      state->image_width, state->image_height,
  97                                      back_pix, fore_pix, state->xgwa.depth);
  98     }
  99
 100 }
 101
 102
 103 m_state *init_matrix( Display *dpy, Window window ) {
 104
 105   m_state *state = (m_state *) calloc (sizeof(*state), 1);
 106
 107
 108   state->dpy = dpy;
 109   state->window = window;
 110
 111   XGetWindowAttributes (dpy, window, &state->xgwa);
 112   load_images (state);
 113
 114   state->draw_gc  = NormalGC;
 115   state->erase_gc = EraseGC;
 116
 117   state->char_width = state->image_width / 2;
 118   state->char_height = CHAR_HEIGHT;
 119
 120   state->grid_width  = state->xgwa.width  / state->char_width;
 121   state->grid_height = state->xgwa.height / state->char_height;
 122   state->grid_width++;
 123   state->grid_height++;
 124
 125   state->cells = (m_cell *)calloc (sizeof(m_cell), state->grid_width * state->grid_height);
 126   state->feeders = (m_feeder *)calloc (sizeof(m_feeder), state->grid_width);
 127
 128   state->density = 40;
 129
 130   state->insert_top_p = False;
 131   state->insert_bottom_p = True;
 132
 133
 134   return state;
 135
 136 }
 137
 138
 139 static void insert_glyph (m_state *state, int glyph, int x, int y) {
 140
 141   Bool bottom_feeder_p = (y >= 0);
 142   m_cell *from, *to;
 143
 144   if (y >= state->grid_height) return;
 145
 146   if (bottom_feeder_p) {
 147
 148       to = &state->cells[state->grid_width * y + x];
 149
 150   } else {
 151
 152       for (y = state->grid_height-1; y > 0; y--) {
 153
 154           from = &state->cells[state->grid_width * (y-1) + x];
 155           to   = &state->cells[state->grid_width * y     + x];
 156           *to = *from;
 157           to->changed = True;
 158
 159     }
 160     to = &state->cells[x];
 161
 162   }
 163
 164   to->glyph = glyph;
 165   to->changed = True;
 166
 167   if (!to->glyph) ;
 168   else if (bottom_feeder_p) to->glow = 1 + (random() % 2);
 169   else to->glow = 0;
 170
 171 }
 172
 173
 174 static void feed_matrix (m_state *state) {
 175
 176     int x;
 177
 178
 179     /*
 180      *  Update according to current feeders.
 181      */
 182     for (x = 0; x < state->grid_width; x++) {
 183
 184         m_feeder *f = &state->feeders[x];
 185
 186         if (f->throttle) {              /* this is a delay tick, synced to frame. */
 187
 188             f->throttle--;
 189
 190         } else if (f->remaining > 0) {  /* how many items are in the pipe */
 191
 192             int g = (random() % state->nglyphs) + 1;
 193             insert_glyph (state, g, x, f->y);
 194             f->remaining--;
 195             if (f->y >= 0)  f->y++; /* bottom_feeder_p */
 196
 197         } else {        /* if pipe is empty, insert spaces */
 198
 199             insert_glyph (state, 0, x, f->y);
 200             if (f->y >= 0) f->y++;   /* bottom_feeder_p */
 201
 202         }
 203
 204         if ((random() % 10) == 0) {  /* randomly change throttle speed */
 205
 206             f->throttle = ((random() % 5) + (random() % 5));
 207
 208         }
 209
 210     }
 211
 212 }
 213
 214 static int densitizer (m_state *state) {
 215
 216   /* Horrid kludge that converts percentages (density of screen coverage)
 217      to the parameter that actually controls this.  I got this mapping
 218      empirically, on a 1024x768 screen.  Sue me. */
 219   if      (state->density < 10) return 85;
 220   else if (state->density < 15) return 60;
 221   else if (state->density < 20) return 45;
 222   else if (state->density < 25) return 25;
 223   else if (state->density < 30) return 20;
 224   else if (state->density < 35) return 15;
 225   else if (state->density < 45) return 10;
 226   else if (state->density < 50) return 8;
 227   else if (state->density < 55) return 7;
 228   else if (state->density < 65) return 5;
 229   else if (state->density < 80) return 3;
 230   else if (state->density < 90) return 2;
 231   else return 1;
 232
 233 }
 234
 235
 236 static void hack_matrix (m_state *state) {
 237
 238   int x;
 239
 240   /* Glow some characters. */
 241   if (!state->insert_bottom_p) {
 242
 243       int i = random() % (state->grid_width / 2);
 244       while (--i > 0) {
 245
 246           int x = random() % state->grid_width;
 247           int y = random() % state->grid_height;
 248           m_cell *cell = &state->cells[state->grid_width * y + x];
 249           if (cell->glyph && cell->glow == 0) {
 250
 251               cell->glow = random() % 10;
 252               cell->changed = True;
 253           }
 254
 255       }
 256   }
 257
 258   /* Change some of the feeders. */
 259   for (x = 0; x < state->grid_width; x++) {
 260
 261       m_feeder *f = &state->feeders[x];
 262       Bool bottom_feeder_p;
 263
 264       if (f->remaining > 0)     /* never change if pipe isn't empty */
 265         continue;
 266
 267       if ((random() % densitizer(state)) != 0) /* then change N% of the time */
 268         continue;
 269
 270       f->remaining = 3 + (random() % state->grid_height);
 271       f->throttle = ((random() % 5) + (random() % 5));
 272
 273       if ((random() % 4) != 0)
 274         f->remaining = 0;
 275
 276       if (state->insert_top_p && state->insert_bottom_p)
 277         bottom_feeder_p = (random() & 1);
 278       else
 279         bottom_feeder_p = state->insert_bottom_p;
 280
 281       if (bottom_feeder_p)
 282         f->y = random() % (state->grid_height / 2);
 283       else
 284         f->y = -1;
 285     }
 286 }
 287
 288
 289 void draw_matrix (m_state *state, int d) {
 290
 291     int x, y;
 292     int count = 0;
 293
 294     state->density = d;
 295     feed_matrix( state );
 296     hack_matrix( state );
 297
 298     for (y = 0; y < state->grid_height; y++) {
 299         for (x = 0; x < state->grid_width; x++) {
 300
 301             m_cell *cell = &state->cells[state->grid_width * y + x];
 302
 303             if ( cell->glyph ) count++;
 304
 305             if ( !cell->changed ) continue;
 306
 307             if ( cell->glyph == 0 ) {
 308
 309                 XFillRectangle( state->dpy, state->window, state->erase_gc,
 310                                 x * state->char_width, y * state->char_height,
 311                                 state->char_width, state->char_height );
 312             } else {
 313
 314                 XCopyArea( state->dpy, state->images, state->window, state->draw_gc,
 315                                 (cell->glow ? state->char_width : 0), (cell->glyph - 1) * state->char_height,
 316                                 state->char_width, state->char_height, x * state->char_width, y * state->char_height );
 317
 318             }
 319
 320             cell->changed = False;
 321
 322             if (cell->glow > 0) {
 323
 324                 cell->glow--;
 325                 cell->changed = True;
 326
 327             }
 328
 329         }
 330     }
 331
 332
 333 #if 0
 334   {
 335     static int i = 0;
 336     static int ndens = 0;
 337     static int tdens = 0;
 338     i++;
 339     if (i > 50)
 340       {
 341         int dens = (100.0 *
 342                     (((double)count) /
 343                      ((double) (state->grid_width * state->grid_height))));
 344         tdens += dens;
 345         ndens++;
 346         printf ("density: %d%% (%d%%)\n", dens, (tdens / ndens));
 347         i = 0;
 348       }
 349   }
 350 #endif
 351
 352 }
 353