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

   1 /* halftone, Copyright (c) 2002 by Peter Jaric <peter@jaric.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  * Description:
  12  * Draws the gravitational force in each point on the screen seen
  13  * through a halftone dot pattern. The force is calculated from a set
  14  * of moving mass points. View it from a distance for best effect.
  15  */
  16
  17 #include <math.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include "screenhack.h"
  21
  22 #define DEFAULT_DELAY          10000
  23 #define DEFAULT_SPACING        14
  24 #define DEFAULT_SIZE_FACTOR    1.5
  25 #define DEFAULT_COUNT          10
  26 #define DEFAULT_MIN_MASS       0.001
  27 #define DEFAULT_MAX_MASS       0.02
  28 #define DEFAULT_MIN_SPEED      0.001
  29 #define DEFAULT_MAX_SPEED      0.02
  30
  31
  32 typedef struct
  33 {
  34   /* halftone dots */
  35   double * dots;
  36   int dots_width;
  37   int dots_height;
  38   int spacing;
  39   int max_dot_size;
  40
  41   /* Moving gravity points */
  42   int gravity_point_count;
  43
  44   double* gravity_point_x;
  45   double* gravity_point_y;
  46   double* gravity_point_mass;
  47   double* gravity_point_x_inc;
  48   double* gravity_point_y_inc;
  49
  50   /* X stuff */
  51   Display *dpy;
  52   Window window;
  53   GC gc;
  54
  55   int ncolors;
  56   XColor *colors;
  57   int color0, color1;
  58   int color_tick, cycle_speed;
  59
  60   /* Off screen buffer */
  61   Pixmap buffer;
  62   GC buffer_gc;
  63   int buffer_width;
  64   int buffer_height;
  65
  66   int delay;
  67
  68 } halftone_screen;
  69
  70
  71 static void update_buffer(halftone_screen *halftone, XWindowAttributes * attrs)
  72 {
  73   if (halftone->buffer_width != attrs->width ||
  74       halftone->buffer_height != attrs->height)
  75   {
  76     XGCValues gc_values;
  77
  78     if (halftone->buffer_width != -1 &&
  79         halftone->buffer_height != -1)
  80     {
  81       if (halftone->buffer != halftone->window)
  82         XFreePixmap(halftone->dpy, halftone->buffer);
  83       XFreeGC(halftone->dpy, halftone->buffer_gc);
  84     }
  85
  86     halftone->buffer_width = attrs->width;
  87     halftone->buffer_height = attrs->height;
  88 #ifdef HAVE_COCOA       /* Don't second-guess Quartz's double-buffering */
  89     halftone->buffer = halftone->window;
  90 #else
  91     halftone->buffer = XCreatePixmap(halftone->dpy, halftone->window, halftone->buffer_width, halftone->buffer_height, attrs->depth);
  92 #endif
  93
  94     halftone->buffer_gc = XCreateGC(halftone->dpy, halftone->buffer, 0, &gc_values);
  95   }
  96 }
  97
  98 static void update_dot_attributes(halftone_screen *halftone, XWindowAttributes * attrs)
  99 {
 100   double dots_width = attrs->width / halftone->spacing + 1;
 101   double dots_height = attrs->height / halftone->spacing + 1;
 102
 103   if (halftone->dots == NULL ||
 104       (dots_width != halftone->dots_width ||
 105        dots_height != halftone->dots_height))
 106   {
 107     if (halftone->dots != NULL)
 108       free(halftone->dots);
 109
 110     halftone->dots_width = dots_width;
 111     halftone->dots_height = dots_height;
 112     halftone->dots = (double *) malloc(halftone->dots_width * halftone->dots_height * sizeof(double));
 113   }
 114 }
 115
 116 static void *
 117 halftone_init (Display *dpy, Window window)
 118 {
 119   int x, y, i;
 120   int count;
 121   int spacing;
 122   double factor;
 123   double min_mass;
 124   double max_mass;
 125   double min_speed;
 126   double max_speed;
 127   XGCValues gc_values;
 128   XWindowAttributes attrs;
 129   halftone_screen *halftone;
 130
 131   halftone = (halftone_screen *) calloc (1, sizeof(halftone_screen));
 132
 133   halftone->dpy = dpy;
 134   halftone->window = window;
 135
 136   halftone->delay = get_integer_resource (dpy, "delay", "Integer");
 137   halftone->delay = (halftone->delay < 0 ? DEFAULT_DELAY : halftone->delay);
 138
 139   halftone->gc = XCreateGC (halftone->dpy, halftone->window, 0, &gc_values);
 140
 141   halftone->buffer_width = -1;
 142   halftone->buffer_height = -1;
 143   halftone->dots = NULL;
 144
 145   /* Read command line arguments and set all settings. */
 146   count = get_integer_resource (dpy, "count", "Count");
 147   halftone->gravity_point_count = count < 1 ? DEFAULT_COUNT : count;
 148
 149   spacing = get_integer_resource (dpy, "spacing", "Integer");
 150   halftone->spacing = spacing < 1 ? DEFAULT_SPACING : spacing;
 151
 152   factor = get_float_resource (dpy, "sizeFactor", "Double");
 153   halftone->max_dot_size =
 154     (factor < 0 ? DEFAULT_SIZE_FACTOR : factor) * halftone->spacing;
 155
 156   min_mass = get_float_resource (dpy, "minMass", "Double");
 157   min_mass = min_mass < 0 ? DEFAULT_MIN_MASS : min_mass;
 158
 159   max_mass = get_float_resource (dpy, "maxMass", "Double");
 160   max_mass = max_mass < 0 ? DEFAULT_MAX_MASS : max_mass;
 161   max_mass = max_mass < min_mass ? min_mass : max_mass;
 162
 163   min_speed = get_float_resource (dpy, "minSpeed", "Double");
 164   min_speed = min_speed < 0 ? DEFAULT_MIN_SPEED : min_speed;
 165
 166   max_speed = get_float_resource (dpy, "maxSpeed", "Double");
 167   max_speed = max_speed < 0 ? DEFAULT_MAX_SPEED : max_speed;
 168   max_speed = max_speed < min_speed ? min_speed : max_speed;
 169
 170
 171   /* Set up the moving gravity points. */
 172   halftone->gravity_point_x = (double *) malloc(halftone->gravity_point_count * sizeof(double));
 173   halftone->gravity_point_y = (double *) malloc(halftone->gravity_point_count * sizeof(double));
 174   halftone->gravity_point_mass = (double *) malloc(halftone->gravity_point_count * sizeof(double));
 175   halftone->gravity_point_x_inc = (double *) malloc(halftone->gravity_point_count * sizeof(double));
 176   halftone->gravity_point_y_inc = (double *) malloc(halftone->gravity_point_count * sizeof(double));
 177
 178   for (i = 0; i < halftone->gravity_point_count; i++)
 179   {
 180     halftone->gravity_point_x[i] = frand(1);
 181     halftone->gravity_point_y[i] = frand(1);
 182     halftone->gravity_point_mass[i] = min_mass + (max_mass - min_mass) * frand(1);
 183     halftone->gravity_point_x_inc[i] = min_speed + (max_speed - min_speed) * frand(1);
 184     halftone->gravity_point_y_inc[i] = min_speed + (max_speed - min_speed) * frand(1);
 185   }
 186
 187
 188   /* Set up the dots. */
 189   XGetWindowAttributes(halftone->dpy, halftone->window, &attrs);
 190
 191   halftone->ncolors = get_integer_resource (dpy, "colors", "Colors");
 192   if (halftone->ncolors < 4) halftone->ncolors = 4;
 193   halftone->colors = (XColor *) calloc(halftone->ncolors, sizeof(XColor));
 194   make_smooth_colormap (dpy, attrs.visual, attrs.colormap,
 195                         halftone->colors, &halftone->ncolors,
 196                         True, 0, False);
 197   halftone->color0 = 0;
 198   halftone->color1 = halftone->ncolors / 2;
 199   halftone->cycle_speed = get_integer_resource (dpy, "cycleSpeed", "CycleSpeed");
 200   halftone->color_tick = 0;
 201
 202   update_buffer(halftone, &attrs);
 203   update_dot_attributes(halftone, &attrs);
 204
 205   for (x = 0; x < halftone->dots_width; x++)
 206     for (y = 0; y < halftone->dots_height; y++)
 207     {
 208         halftone->dots[x + y * halftone->dots_width] = 0;
 209     }
 210
 211   return halftone;
 212 }
 213
 214
 215
 216 static void fill_circle(Display *dpy, Window window, GC gc, int x, int y, int size)
 217 {
 218   int start_x = x - (size / 2);
 219   int start_y = y - (size / 2);
 220   unsigned int width = size;
 221   unsigned int height = size;
 222   int angle1 = 0;
 223   int angle2 = 360 * 64; /* A full circle */
 224
 225   XFillArc (dpy, window, gc,
 226             start_x, start_y, width, height,
 227             angle1, angle2);
 228 }
 229
 230 static void repaint_halftone(halftone_screen *halftone)
 231 {
 232   int x, y;
 233   /*
 234   int x_offset = halftone->spacing / 2;
 235   int y_offset = halftone->spacing / 2;
 236   */
 237   int x_offset = 0;
 238   int y_offset = 0;
 239
 240
 241   /* Fill buffer with background color */
 242   XSetForeground (halftone->dpy, halftone->buffer_gc,
 243                   halftone->colors[halftone->color0].pixel);
 244   XFillRectangle(halftone->dpy, halftone->buffer, halftone->buffer_gc, 0, 0, halftone->buffer_width, halftone->buffer_height);
 245
 246   /* Draw dots on buffer */
 247   XSetForeground (halftone->dpy, halftone->buffer_gc,
 248                   halftone->colors[halftone->color1].pixel);
 249
 250   if (halftone->color_tick++ >= halftone->cycle_speed)
 251     {
 252       halftone->color_tick = 0;
 253       halftone->color0 = (halftone->color0 + 1) % halftone->ncolors;
 254       halftone->color1 = (halftone->color1 + 1) % halftone->ncolors;
 255     }
 256
 257   for (x = 0; x < halftone->dots_width; x++)
 258     for (y = 0; y < halftone->dots_height; y++)
 259       fill_circle(halftone->dpy, halftone->buffer, halftone->buffer_gc,
 260                   x_offset + x * halftone->spacing, y_offset + y * halftone->spacing,
 261                   halftone->max_dot_size * halftone->dots[x + y * halftone->dots_width]);
 262
 263   /* Copy buffer to window */
 264   if (halftone->buffer != halftone->window)
 265     XCopyArea(halftone->dpy, halftone->buffer, halftone->window, halftone->gc, 0, 0, halftone->buffer_width, halftone->buffer_height, 0, 0);
 266 }
 267
 268 static double calculate_gravity(halftone_screen *halftone, int x, int y)
 269 {
 270   int i;
 271   double gx = 0;
 272   double gy = 0;
 273
 274   for (i = 0; i < halftone->gravity_point_count; i++)
 275   {
 276     double dx = ((double) x) - halftone->gravity_point_x[i] * halftone->dots_width;
 277     double dy = ((double) y) - halftone->gravity_point_y[i] * halftone->dots_height;
 278     double distance = sqrt(dx * dx + dy * dy);
 279
 280     if (distance != 0)
 281     {
 282       double gravity = halftone->gravity_point_mass[i] / (distance * distance  / (halftone->dots_width * halftone->dots_height));
 283
 284       gx += (dx / distance) * gravity;
 285       gy += (dy / distance) * gravity;
 286     }
 287   }
 288
 289   return sqrt(gx * gx + gy * gy);
 290 }
 291
 292 static void update_halftone(halftone_screen *halftone)
 293 {
 294   int x, y, i;
 295   XWindowAttributes attrs;
 296
 297   XGetWindowAttributes(halftone->dpy, halftone->window, &attrs);
 298
 299   /* Make sure we have a valid buffer */
 300   update_buffer(halftone, &attrs);
 301
 302   /* Make sure all dot attributes (spacing, width, height, etc) are correct */
 303   update_dot_attributes(halftone, &attrs);
 304
 305   /* Move gravity points */
 306   for (i = 0; i < halftone->gravity_point_count; i++)
 307   {
 308     halftone->gravity_point_x_inc[i] =
 309       (halftone->gravity_point_x[i] >= 1 || halftone->gravity_point_x[i] <= 0 ?
 310        -halftone->gravity_point_x_inc[i] :
 311        halftone->gravity_point_x_inc[i]);
 312     halftone->gravity_point_y_inc[i] =
 313       (halftone->gravity_point_y[i] >= 1 || halftone->gravity_point_y[i] <= 0 ?
 314        -halftone->gravity_point_y_inc[i] :
 315        halftone->gravity_point_y_inc[i]);
 316
 317     halftone->gravity_point_x[i] += halftone->gravity_point_x_inc[i];
 318     halftone->gravity_point_y[i] += halftone->gravity_point_y_inc[i];
 319   }
 320
 321   /* Update gravity in each dot .*/
 322   for (x = 0; x < halftone->dots_width; x++)
 323     for (y = 0; y < halftone->dots_height; y++)
 324     {
 325       double gravity = calculate_gravity(halftone, x, y);
 326
 327       halftone->dots[x + y * halftone->dots_width] = (gravity > 1 ? 1 : (gravity < 0 ? 0 : gravity));
 328     }
 329 }
 330
 331
 332 static unsigned long
 333 halftone_draw (Display *dpy, Window window, void *closure)
 334 {
 335   halftone_screen *halftone = (halftone_screen *) closure;
 336
 337   repaint_halftone(halftone);
 338   update_halftone(halftone);
 339
 340   return halftone->delay;
 341 }
 342
 343
 344 static void
 345 halftone_reshape (Display *dpy, Window window, void *closure,
 346                  unsigned int w, unsigned int h)
 347 {
 348 }
 349
 350 static Bool
 351 halftone_event (Display *dpy, Window window, void *closure, XEvent *event)
 352 {
 353   return False;
 354 }
 355
 356 static void
 357 halftone_free (Display *dpy, Window window, void *closure)
 358 {
 359   halftone_screen *halftone = (halftone_screen *) closure;
 360   free (halftone);
 361 }
 362
 363
 364 static const char *halftone_defaults [] = {
 365   ".background:         Black",
 366   "*delay:              10000",
 367   "*count:              10",
 368   "*minMass:            0.001",
 369   "*maxMass:            0.02",
 370   "*minSpeed:           0.001",
 371   "*maxSpeed:           0.02",
 372   "*spacing:            14",
 373   "*sizeFactor:         1.5",
 374   "*colors:             200",
 375   "*cycleSpeed:         10",
 376   0
 377 };
 378
 379 static XrmOptionDescRec halftone_options [] = {
 380   { "-delay",           ".delay",       XrmoptionSepArg, 0 },
 381   { "-count",           ".count",       XrmoptionSepArg, 0 },
 382   { "-minmass",         ".minMass",     XrmoptionSepArg, 0 },
 383   { "-maxmass",         ".maxMass",     XrmoptionSepArg, 0 },
 384   { "-minspeed",        ".minSpeed",    XrmoptionSepArg, 0 },
 385   { "-maxspeed",        ".maxSpeed",    XrmoptionSepArg, 0 },
 386   { "-spacing",         ".spacing",     XrmoptionSepArg, 0 },
 387   { "-sizefactor",      ".sizeFactor",  XrmoptionSepArg, 0 },
 388   { "-colors",          ".colors",      XrmoptionSepArg, 0 },
 389   { "-cycle-speed",     ".cycleSpeed",  XrmoptionSepArg, 0 },
 390   { 0, 0, 0, 0 }
 391 };
 392
 393
 394 XSCREENSAVER_MODULE ("Halftone", halftone)