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