git.hungrycats.org Git - xscreensaver/blob - hacks/mountain.c

   1 /* -*- Mode: C; tab-width: 4 -*- */
   2 /* mountain -- square grid mountains */
   3
   4 #if 0
   5 static const char sccsid[] = "@(#)mountain.c    5.00 2000/11/01 xlockmore";
   6 #endif
   7
   8 /*-
   9  * Copyright (c) 1995 Pascal Pensa <pensa@aurora.unice.fr>
  10  *
  11  * Permission to use, copy, modify, and distribute this software and its
  12  * documentation for any purpose and without fee is hereby granted,
  13  * provided that the above copyright notice appear in all copies and that
  14  * both that copyright notice and this permission notice appear in
  15  * supporting documentation.
  16  *
  17  * This file is provided AS IS with no warranties of any kind.  The author
  18  * shall have no liability with respect to the infringement of copyrights,
  19  * trade secrets or any patents by this file or any part thereof.  In no
  20  * event will the author be liable for any lost revenue or profits or
  21  * other special, indirect and consequential damages.
  22  *
  23  * Revision History:
  24  * 01-Nov-2000: Allocation checks
  25  * 10-May-1997: Compatible with xscreensaver
  26  * 1995: Written
  27  */
  28
  29 #ifdef STANDALONE
  30 # define MODE_mountain
  31 #define DEFAULTS        "*delay: 20000 \n" \
  32                                         "*count: 30 \n" \
  33                                         "*cycles: 4000 \n" \
  34                                         "*ncolors: 64 \n" \
  35                                         "*fpsSolid: true \n" \
  36
  37 # define SMOOTH_COLORS
  38 # define release_mountain 0
  39 # include "xlockmore.h"         /* in xscreensaver distribution */
  40 #else /* STANDALONE */
  41 # include "xlock.h"             /* in xlockmore distribution */
  42 #endif /* STANDALONE */
  43
  44 #ifdef MODE_mountain
  45
  46 ENTRYPOINT ModeSpecOpt mountain_opts =
  47 {0, (XrmOptionDescRec *) NULL, 0, (argtype *) NULL, (OptionStruct *) NULL};
  48
  49 #ifdef USE_MODULES
  50 ModStruct   mountain_description =
  51 {"mountain", "init_mountain", "draw_mountain", (char *) NULL,
  52  "refresh_mountain", "init_mountain", (char *) NULL, &mountain_opts,
  53  1000, 30, 4000, 1, 64, 1.0, "",
  54  "Shows Papo's mountain range", 0, NULL};
  55
  56 #endif
  57
  58 /* ~ 5000 Max mountain height (1000 - 10000) */
  59 #define MAXHEIGHT  (3 * (mp->width + mp->height))
  60
  61 #define WORLDWIDTH 50           /* World size x * y */
  62
  63 #define RANGE_RAND(min,max) ((min) + NRAND((max) - (min)))
  64
  65 typedef struct {
  66         int         pixelmode;
  67         int         width;
  68         int         height;
  69         int         x, y;
  70         int         offset;
  71         int         stage;
  72         int         h[WORLDWIDTH][WORLDWIDTH];
  73         long        time;       /* up time */
  74         Bool        wireframe;
  75         Bool        joke;
  76         GC          stippledGC;
  77 } mountainstruct;
  78
  79 static mountainstruct *mountains = (mountainstruct *) NULL;
  80
  81 static void
  82 spread(int  (*m)[50], int x, int y)
  83 {
  84         int         x2, y2;
  85         int         h = m[x][y];
  86
  87         for (y2 = y - 1; y2 <= y + 1; y2++)
  88                 for (x2 = x - 1; x2 <= x + 1; x2++)
  89                         if (x2 >= 0 && y2 >= 0 && x2 < WORLDWIDTH && y2 < WORLDWIDTH)
  90                                 m[x2][y2] = (m[x2][y2] + h) / 2;
  91 }
  92
  93 static void
  94 drawamountain(ModeInfo * mi)
  95 {
  96         Display    *display = MI_DISPLAY(mi);
  97         Window      window = MI_WINDOW(mi);
  98         GC          gc = MI_GC(mi);
  99         mountainstruct *mp = &mountains[MI_SCREEN(mi)];
 100         int         x2, y2, x3, y3, y4, y5, c = 0;
 101         XPoint      p[5];
 102
 103         if (MI_NPIXELS(mi) > 2) {
 104                 c = (mp->h[mp->x][mp->y] + mp->h[mp->x + 1][mp->y] +
 105                   mp->h[mp->x][mp->y + 1] + mp->h[mp->x + 1][mp->y + 1]) / 4;
 106                 c = (c / 10 + mp->offset) % MI_NPIXELS(mi);
 107         }
 108         x2 = mp->x * (2 * mp->width) / (3 * WORLDWIDTH);
 109         y2 = mp->y * (2 * mp->height) / (3 * WORLDWIDTH);
 110         p[0].x = (x2 - y2 / 2) + (mp->width / 4);
 111         p[0].y = (y2 - mp->h[mp->x][mp->y]) + mp->height / 4;
 112
 113         x3 = (mp->x + 1) * (2 * mp->width) / (3 * WORLDWIDTH);
 114         y3 = mp->y * (2 * mp->height) / (3 * WORLDWIDTH);
 115         p[1].x = (x3 - y3 / 2) + (mp->width / 4);
 116         p[1].y = (y3 - mp->h[mp->x + 1][mp->y]) + mp->height / 4;
 117
 118         y4 = (mp->y + 1) * (2 * mp->height) / (3 * WORLDWIDTH);
 119         p[2].x = (x3 - y4 / 2) + (mp->width / 4);
 120         p[2].y = (y4 - mp->h[mp->x + 1][mp->y + 1]) + mp->height / 4;
 121
 122         y5 = (mp->y + 1) * (2 * mp->height) / (3 * WORLDWIDTH);
 123         p[3].x = (x2 - y5 / 2) + (mp->width / 4);
 124         p[3].y = (y5 - mp->h[mp->x][mp->y + 1]) + mp->height / 4;
 125
 126         p[4].x = p[0].x;
 127         p[4].y = p[0].y;
 128
 129         if (MI_NPIXELS(mi) > 2)
 130                 XSetForeground(display, gc, MI_PIXEL(mi, c));
 131         else
 132                 XSetForeground(display, gc, MI_WHITE_PIXEL(mi));
 133
 134         if (mp->joke) {
 135                 if ((Bool) (LRAND() & 1))
 136                         XDrawLines(display, window, gc, p, 5, CoordModeOrigin);
 137                 else {
 138                         XFillPolygon(display, window, gc, p, 4, Complex, CoordModeOrigin);
 139                         if (!mp->pixelmode) {
 140                                 XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
 141                                 XDrawLines(display, window, gc, p, 5, CoordModeOrigin);
 142                         }
 143                 }
 144         } else {
 145                 if (mp->wireframe) {
 146                         XDrawLines(display, window, gc, p, 5, CoordModeOrigin);
 147                 } else {
 148                         XFillPolygon(display, window, gc, p, 4, Complex, CoordModeOrigin);
 149
 150                         if (!mp->pixelmode) {
 151                                 XSetForeground(display, gc, MI_BLACK_PIXEL(mi));
 152                                 XDrawLines(display, window, gc, p, 5, CoordModeOrigin);
 153                         }
 154                 }
 155         }
 156         mp->x++;
 157         if (mp->x == WORLDWIDTH - 1) {
 158                 mp->y++;
 159                 mp->x = 0;
 160         }
 161         if (mp->y == WORLDWIDTH - 1)
 162                 mp->stage++;
 163 }
 164
 165 static void free_mountain (ModeInfo * mi);
 166
 167 ENTRYPOINT void
 168 init_mountain (ModeInfo * mi)
 169 {
 170         int         i, j, x, y;
 171         XGCValues   gcv;
 172         mountainstruct *mp;
 173
 174         MI_INIT (mi, mountains, free_mountain);
 175         mp = &mountains[MI_SCREEN(mi)];
 176
 177         mp->width = MI_WIDTH(mi);
 178         mp->height = MI_HEIGHT(mi);
 179         mp->pixelmode = (mp->width + mp->height < 200);
 180         mp->stage = 0;
 181         mp->time = 0;
 182         mp->x = mp->y = 0;
 183         if (MI_IS_FULLRANDOM(mi)) {
 184                 mp->joke = (Bool) (NRAND(10) == 0);
 185                 mp->wireframe = (Bool) (LRAND() & 1);
 186         } else {
 187                 mp->joke = False;
 188                 mp->wireframe = MI_IS_WIREFRAME(mi);
 189         }
 190
 191         if (mp->stippledGC == None) {
 192                 gcv.foreground = MI_WHITE_PIXEL(mi);
 193                 gcv.background = MI_BLACK_PIXEL(mi);
 194                 if ((mp->stippledGC = XCreateGC(MI_DISPLAY(mi), MI_WINDOW(mi),
 195                                           GCForeground | GCBackground, &gcv)) == None)
 196                         return;
 197         }
 198         MI_CLEARWINDOW(mi);
 199
 200         for (y = 0; y < (int) WORLDWIDTH; y++)
 201                 for (x = 0; x < (int) WORLDWIDTH; x++)
 202                         mp->h[x][y] = 0;
 203
 204         j = MI_COUNT(mi);
 205         if (j < 0)
 206                 j = NRAND(-j) + 1;
 207         for (i = 0; i < j; i++)
 208                 mp->h[RANGE_RAND(1, WORLDWIDTH - 1)][RANGE_RAND(1, WORLDWIDTH - 1)] =
 209                         NRAND(MAXHEIGHT);
 210
 211         for (y = 0; y < WORLDWIDTH; y++)
 212                 for (x = 0; x < WORLDWIDTH; x++)
 213                         spread(mp->h, x, y);
 214
 215         for (y = 0; y < WORLDWIDTH; y++)
 216                 for (x = 0; x < WORLDWIDTH; x++) {
 217                         mp->h[x][y] = mp->h[x][y] + NRAND(10) - 5;
 218                         if (mp->h[x][y] < 10)
 219                                 mp->h[x][y] = 0;
 220                 }
 221
 222         if (MI_NPIXELS(mi) > 2)
 223                 mp->offset = NRAND(MI_NPIXELS(mi));
 224         else
 225                 mp->offset = 0;
 226 }
 227
 228 ENTRYPOINT void
 229 draw_mountain (ModeInfo * mi)
 230 {
 231         mountainstruct *mp;
 232
 233         if (mountains == NULL)
 234                         return;
 235         mp = &mountains[MI_SCREEN(mi)];
 236         if (mp->stippledGC == NULL)
 237                         return;
 238
 239         MI_IS_DRAWN(mi) = True;
 240
 241         switch (mp->stage) {
 242                 case 0:
 243                         drawamountain(mi);
 244                         break;
 245                 case 1:
 246                         if (++mp->time > MI_CYCLES(mi))
 247                                 mp->stage++;
 248                         break;
 249                 case 2:
 250                         init_mountain(mi);
 251                         break;
 252         }
 253 }
 254
 255 ENTRYPOINT void
 256 reshape_mountain(ModeInfo * mi, int width, int height)
 257 {
 258   XClearWindow (MI_DISPLAY (mi), MI_WINDOW(mi));
 259   init_mountain (mi);
 260 }
 261
 262
 263 static void
 264 free_mountain (ModeInfo * mi)
 265 {
 266         mountainstruct *mp = &mountains[MI_SCREEN(mi)];
 267
 268         if (mp->stippledGC)
 269                 XFreeGC(MI_DISPLAY(mi), mp->stippledGC);
 270 }
 271
 272 ENTRYPOINT void
 273 refresh_mountain(ModeInfo * mi)
 274 {
 275         mountainstruct *mp;
 276
 277         if (mountains == NULL)
 278                         return;
 279         mp = &mountains[MI_SCREEN(mi)];
 280
 281         MI_CLEARWINDOW(mi);
 282         mp->x = 0;
 283         mp->y = 0;
 284 }
 285
 286 ENTRYPOINT Bool
 287 mountain_handle_event (ModeInfo *mi, XEvent *event)
 288 {
 289   if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
 290     {
 291       init_mountain (mi);
 292       return True;
 293     }
 294   return False;
 295 }
 296
 297 XSCREENSAVER_MODULE ("Mountain", mountain)
 298
 299 #endif /* MODE_mountain */