/* xscreensaver, Copyright (c) 1992-2014 Jamie Zawinski <jwz@jwz.org>
*
* reaction/diffusion textures
* Copyright (c) 1997 Scott Draves spot@transmeta.com
* this code is derived from Bomb
* see http://www.cs.cmu.edu/~spot/bomb.html
*
* 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.
*
* And remember: X Windows is to graphics hacking as roman numerals are to
* the square root of pi.
*/
#include <math.h>
#include "screenhack.h"
#include "xshm.h"
/* costs ~6% speed */
#define dither_when_mapped 1
struct state {
Display *dpy;
Window window;
int ncolors;
XColor *colors;
Visual *visual;
#if dither_when_mapped
unsigned char *mc;
#endif
Colormap cmap;
int mapped;
int pdepth;
int frame, epoch_time;
unsigned short *r1, *r2, *r1b, *r2b;
int width, height, npix;
int radius;
int reaction;
int diffusion;
char *pd;
int array_width, array_height;
XShmSegmentInfo shm_info;
GC gc;
XImage *image;
double array_x, array_y;
double array_dx, array_dy;
XWindowAttributes xgwa;
int delay;
};
static void random_colors(struct state *st);
/* -----------------------------------------------------------
pixel hack, 8-bit pixel grid, first/next frame interface
pixack_init(int *size_h, int *size_v)
pixack_frame(char *pix_buf)
*/
#define bps 16
#define mx ((1<<16)-1)
/* you can replace integer mults wish shift/adds with these,
but it doesn't help on my 586 */
#define x5(n) ((n<<2)+n)
#define x7(n) ((n<<3)-n)
/* why strip bit? */
#define R (random()&((1<<30)-1))
#define BELLRAND(x) (((random()%(x)) + (random()%(x)) + (random()%(x)))/3)
/* returns number of pixels that the pixack produces. called once. */
static void
pixack_init(struct state *st, int *size_h, int *size_v)
{
st->width = get_integer_resource (st->dpy, "width", "Integer");
st->height = get_integer_resource (st->dpy, "height", "Integer");
if (st->width <= 0 && st->height <= 0 && (R & 1))
st->width = st->height = 64 + BELLRAND(512);
if (st->width <= 0) st->width = 64 + BELLRAND(512);
if (st->height <= 0) st->height = 64 + BELLRAND(512);
if (st->width > st->xgwa.width) st->width = st->xgwa.width;
if (st->height > st->xgwa.height) st->height = st->xgwa.height;
/* jwz: when (and only when) XSHM is in use on an SGI 8-bit visual,
we get shear unless st->width is a multiple of 4. I don't understand
why. This is undoubtedly the wrong fix... */
if (visual_depth (st->xgwa.screen, st->xgwa.visual) == 8)
st->width &= ~0x7;
/* don't go there */
if (st->width < 10) st->width = 10;
if (st->height < 10) st->height = 10;
st->epoch_time = get_integer_resource (st->dpy, "epoch", "Integer");
st->npix = (st->width + 2) * (st->height + 2);
st->r1 = (unsigned short *) malloc(sizeof(unsigned short) * st->npix);
st->r2 = (unsigned short *) malloc(sizeof(unsigned short) * st->npix);
st->r1b = (unsigned short *) malloc(sizeof(unsigned short) * st->npix);
st->r2b = (unsigned short *) malloc(sizeof(unsigned short) * st->npix);
if (!st->r1 || !st->r2 || !st->r1b || !st->r2b) {
fprintf(stderr, "not enough memory for %d pixels.\n", st->npix);
exit(1);
}
*size_h = st->width;
*size_v = st->height;
}
#define test_pattern_hyper 0
/* returns the pixels. called many times. */
static void
pixack_frame(struct state *st, char *pix_buf)
{
int i, j;
int w2 = st->width + 2;
unsigned short *t;
#if test_pattern_hyper
if (st->frame&0x100)
sleep(1);
#endif
if (!(st->frame%st->epoch_time)) {
int s;
for (i = 0; i < st->npix; i++) {
/* equilibrium */
st->r1[i] = 65500;
st->r2[i] = 11;
}
random_colors(st);
XSetWindowBackground(st->dpy, st->window, st->colors[255 % st->ncolors].pixel);
XClearWindow(st->dpy, st->window);
s = w2 * (st->height/2) + st->width/2;
st->radius = get_integer_resource (st->dpy, "radius", "Integer");
{
int maxr = st->width/2-2;
int maxr2 = st->height/2-2;
if (maxr2 < maxr) maxr = maxr2;
if (st->radius < 0)
st->radius = 1 + ((R%10) ? (R%5) : (R % maxr));
if (st->radius > maxr) st->radius = maxr;
}
for (i = -st->radius; i < (st->radius+1); i++)
for (j = -st->radius; j < (st->radius+1); j++)
st->r2[s + i + j*w2] = mx - (R&63);
st->reaction = get_integer_resource (st->dpy, "reaction", "Integer");
if (st->reaction < 0 || st->reaction > 2) st->reaction = R&1;
st->diffusion = get_integer_resource (st->dpy, "diffusion", "Integer");
if (st->diffusion < 0 || st->diffusion > 2)
st->diffusion = (R%5) ? ((R%3)?0:1) : 2;
if (2 == st->reaction && 2 == st->diffusion)
st->reaction = st->diffusion = 0;
}
for (i = 0; i <= st->width+1; i++) {
st->r1[i] = st->r1[i + w2 * st->height];
st->r2[i] = st->r2[i + w2 * st->height];
st->r1[i + w2 * (st->height + 1)] = st->r1[i + w2];
st->r2[i + w2 * (st->height + 1)] = st->r2[i + w2];
}
for (i = 0; i <= st->height+1; i++) {
st->r1[w2 * i] = st->r1[st->width + w2 * i];
st->r2[w2 * i] = st->r2[st->width + w2 * i];
st->r1[w2 * i + st->width + 1] = st->r1[w2 * i + 1];
st->r2[w2 * i + st->width + 1] = st->r2[w2 * i + 1];
}
for (i = 0; i < st->height; i++) {
int ii = i + 1;
char *q = pix_buf + st->width * i;
short *qq = ((short *) pix_buf) + st->width * i;
/* long *qqq = ((long *) pix_buf) + st->width * i; -- crashes on Alpha */
int *qqq = ((int *) pix_buf) + st->width * i;
unsigned short *i1 = st->r1 + 1 + w2 * ii;
unsigned short *i2 = st->r2 + 1 + w2 * ii;
unsigned short *o1 = st->r1b + 1 + w2 * ii;
unsigned short *o2 = st->r2b + 1 + w2 * ii;
for (j = 0; j < st->width; j++) {
#if test_pattern_hyper
int r1 = (i * j + (st->frame&127)*frame)&65535;
#else
int uvv, r1 = 0, r2 = 0;
switch (st->diffusion) {
case 0:
r1 = i1[j] + i1[j+1] + i1[j-1] + i1[j+w2] + i1[j-w2];
r1 = r1 / 5;
r2 = (i2[j]<<3) + i2[j+1] + i2[j-1] + i2[j+w2] + i2[j-w2];
r2 = r2 / 12;
break;
case 1:
r1 = i1[j+1] + i1[j-1] + i1[j+w2] + i1[j-w2];
r1 = r1 >> 2;
r2 = (i2[j]<<2) + i2[j+1] + i2[j-1] + i2[j+w2] + i2[j-w2];
r2 = r2 >> 3;
break;
case 2:
r1 = (i1[j]<<1) + (i1[j+1]<<1) + (i1[j-1]<<1) + i1[j+w2] + i1[j-w2];
r1 = r1 >> 3;
r2 = (i2[j]<<2) + i2[j+1] + i2[j-1] + i2[j+w2] + i2[j-w2];
r2 = r2 >> 3;
break;
}
/* John E. Pearson "Complex Patterns in a Simple System"
Science, July 1993 */
/* uvv = (((r1 * r2) >> bps) * r2) >> bps; */
/* avoid signed integer overflow */
uvv = ((((r1 >> 1)* r2) >> bps) * r2) >> (bps - 1);
switch (st->reaction) { /* costs 4% */
case 0:
r1 += 4 * (((28 * (mx-r1)) >> 10) - uvv);
r2 += 4 * (uvv - ((80 * r2) >> 10));
break;
case 1:
r1 += 3 * (((27 * (mx-r1)) >> 10) - uvv);
r2 += 3 * (uvv - ((80 * r2) >> 10));
break;
case 2:
r1 += 2 * (((28 * (mx-r1)) >> 10) - uvv);
r2 += 3 * (uvv - ((80 * r2) >> 10));
break;
}
if (r1 > mx) r1 = mx;
if (r2 > mx) r2 = mx;
if (r1 < 0) r1 = 0;
if (r2 < 0) r2 = 0;
o1[j] = r1;
o2[j] = r2;
#endif
/* this is terrible. here i want to assume ncolors = 256.
should lose double indirection */
if (st->mapped)
#if dither_when_mapped
q[j] = st->colors[st->mc[r1] % st->ncolors].pixel;
#else
q[j] = st->colors[(r1>>8) % st->ncolors].pixel;
#endif
else if (st->pdepth == 8)
q[j] = st->colors[(r1>>8) % st->ncolors].pixel;
else if (st->pdepth == 16)
#if dither_when_mapped
qq[j] = st->colors[st->mc[r1] % st->ncolors].pixel;
#else
qq[j] = st->colors[(r1>>8) % st->ncolors].pixel;
#endif
else if (st->pdepth == 32)
#if dither_when_mapped
qqq[j] = st->colors[st->mc[r1] % st->ncolors].pixel;
#else
qqq[j] = st->colors[(r1>>8) % st->ncolors].pixel;
#endif
else
abort();
}
}
t = st->r1; st->r1 = st->r1b; st->r1b = t;
t = st->r2; st->r2 = st->r2b; st->r2b = t;
}
/* ------------- xscreensaver rendering -------------- */
static const char *rd_defaults [] = {
".background: black",
".foreground: white",
"*fpsSolid: true",
"*width: 0", /* tried to use -1 but it complained */
"*height: 0",
"*epoch: 40000",
"*reaction: -1",
"*diffusion: -1",
"*radius: -1",
"*speed: 0.0",
"*size: 1.0",
"*delay: 30000",
"*colors: 255",
#ifdef HAVE_XSHM_EXTENSION
"*useSHM: True",
#else
"*useSHM: False",
#endif
#ifdef HAVE_MOBILE
"*ignoreRotation: True",
#endif
0
};
static XrmOptionDescRec rd_options [] = {
{ "-width", ".width", XrmoptionSepArg, 0 },
{ "-height", ".height", XrmoptionSepArg, 0 },
{ "-epoch", ".epoch", XrmoptionSepArg, 0 },
{ "-reaction", ".reaction", XrmoptionSepArg, 0 },
{ "-diffusion", ".diffusion", XrmoptionSepArg, 0 },
{ "-radius", ".radius", XrmoptionSepArg, 0 },
{ "-speed", ".speed", XrmoptionSepArg, 0 },
{ "-size", ".size", XrmoptionSepArg, 0 },
{ "-delay", ".delay", XrmoptionSepArg, 0 },
{ "-ncolors", ".colors", XrmoptionSepArg, 0 },
{ "-shm", ".useSHM", XrmoptionNoArg, "True" },
{ "-no-shm", ".useSHM", XrmoptionNoArg, "False" },
{ 0, 0, 0, 0 }
};
static void
random_colors(struct state *st)
{
memset(st->colors, 0, st->ncolors*sizeof(*st->colors));
make_smooth_colormap (st->xgwa.screen, st->visual, st->cmap,
st->colors, &st->ncolors,
True, 0, True);
if (st->ncolors <= 2) {
mono_p = True;
st->ncolors = 2;
st->colors[0].flags = DoRed|DoGreen|DoBlue;
st->colors[0].red = st->colors[0].green = st->colors[0].blue = 0;
XAllocColor(st->dpy, st->cmap, &st->colors[0]);
st->colors[1].flags = DoRed|DoGreen|DoBlue;
st->colors[1].red = st->colors[1].green = st->colors[1].blue = 0xFFFF;
XAllocColor(st->dpy, st->cmap, &st->colors[1]);
}
/* Scale it up so that there are exactly 255 colors -- that keeps the
animation speed consistent, even when there aren't many allocatable
colors, and prevents the -mono mode from looking like static. */
if (st->ncolors != 255) {
int i, n = 255;
double scale = (double) st->ncolors / (double) (n+1);
XColor *c2 = (XColor *) malloc(sizeof(*c2) * (n+1));
for (i = 0; i < n; i++)
c2[i] = st->colors[(int) (i * scale)];
free(st->colors);
st->colors = c2;
st->ncolors = n;
}
}
/* should factor into RD-specfic and compute-every-pixel general */
static void *
rd_init (Display *dpy, Window win)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
int vdepth;
st->dpy = dpy;
st->window = win;
st->delay = get_integer_resource (st->dpy, "delay", "Float");
XGetWindowAttributes (st->dpy, win, &st->xgwa);
st->visual = st->xgwa.visual;
pixack_init(st, &st->width, &st->height);
{
double s = get_float_resource (st->dpy, "size", "Float");
double p = get_float_resource (st->dpy, "speed", "Float");
if (s < 0.0 || s > 1.0)
s = 1.0;
s = sqrt(s);
st->array_width = st->xgwa.width * s;
st->array_height = st->xgwa.height * s;
if (s < 0.99) {
st->array_width = (st->array_width / st->width) * st->width;
st->array_height = (st->array_height / st->height) * st->height;
}
if (st->array_width < st->width) st->array_width = st->width;
if (st->array_height < st->height) st->array_height = st->height;
st->array_x = (st->xgwa.width - st->array_width)/2;
st->array_y = (st->xgwa.height - st->array_height)/2;
st->array_dx = p;
st->array_dy = .31415926 * p;
/* start in a random direction */
if (random() & 1) st->array_dx = -st->array_dx;
if (random() & 1) st->array_dy = -st->array_dy;
}
st->npix = (st->width + 2) * (st->height + 2);
/* gcv.function = GXcopy;*/
st->gc = XCreateGC(st->dpy, win, 0 /*GCFunction*/, &gcv);
vdepth = visual_depth(DefaultScreenOfDisplay(st->dpy), st->xgwa.visual);
/* This code only deals with pixmap depths of 1, 8, 16, and 32.
Therefore, we assume that those depths will be supported by the
coresponding visual depths (that depth-24 dpys accept depth-32
pixmaps, and that depth-12 dpys accept depth-16 pixmaps.) */
st->pdepth = (vdepth == 1 ? 1 :
vdepth <= 8 ? 8 :
vdepth <= 16 ? 16 :
32);
/* Ok, this like, sucks and stuff. There are some XFree86 systems
that have depth-24 visuals, that do not accept depth-32 XImages!
Which if you ask me is just absurd, since all it would take is
for the server to truncate the bits in that case. So, this crap
here detects the specific case of: we have chosen depth 32;
and the server does not support depth 32. In that case, we
try and use depth 16 instead.
The real fix would be to rewrite this program to deal with
depth 24 directly (or even better, arbitrary depths, but that
would mean going through the XImage routines instead of messing
with the XImage->data directly.)
jwz, 18-Mar-99: well, the X servers I have access to these days do
support 32-deep images on deep visuals, so I no longer have the
ability to test this code -- but it was causing problems on the
visuals that I do have, and I think that's because I mistakenly
wrote `pfv[i].depth' when I meant to write `pfv[i].bits_per_pixel'.
The symptom I was seeing was that the grid was 64x64, but the
images were being drawn 32x32 -- so there was a black stripe on
every other row. Wow, this code sucks so much.
*/
if (st->pdepth == 32)
{
int i, pfvc = 0;
Bool ok = False;
XPixmapFormatValues *pfv = XListPixmapFormats (st->dpy, &pfvc);
for (i = 0; i < pfvc; i++)
if (pfv[i].bits_per_pixel == st->pdepth)
ok = True;
if (!ok)
st->pdepth = 16;
free (pfv);
}
st->cmap = st->xgwa.colormap;
st->ncolors = get_integer_resource (st->dpy, "colors", "Integer");
if (st->ncolors <= 0 || st->ncolors >= 255) {
if (vdepth > 8)
st->ncolors = 2047;
else
st->ncolors = 255;
}
if (mono_p || st->ncolors < 2) st->ncolors = 2;
if (st->ncolors <= 2) mono_p = True;
st->colors = (XColor *) malloc(sizeof(*st->colors) * (st->ncolors+1));
st->mapped = (vdepth <= 8 &&
has_writable_cells(st->xgwa.screen, st->xgwa.visual));
{
int i, di;
st->mc = (unsigned char *) malloc(1<<16);
for (i = 0; i < (1<<16); i++) {
di = (i + (random()&255))>>8;
if (di > 255) di = 255;
st->mc[i] = di;
}
}
st->image = create_xshm_image(st->dpy, st->xgwa.visual, vdepth,
ZPixmap, &st->shm_info, st->width, st->height);
st->pd = st->image->data;
return st;
}
static unsigned long
rd_draw (Display *dpy, Window win, void *closure)
{
struct state *st = (struct state *) closure;
Bool bump = False;
/* Let's compute N frames at once. This speeds up the progress of
the animation and the seething, but doesn't appreciably affect the
frame rate or CPU utilization. */
int ii;
int chunk = 3;
for (ii = 0; ii < chunk; ii++) {
int i, j;
pixack_frame(st, st->pd);
if (ii == chunk-1) { /* Only need to putimage on the final frame */
for (i = 0; i < st->array_width; i += st->width)
for (j = 0; j < st->array_height; j += st->height)
put_xshm_image(st->dpy, st->window, st->gc, st->image, 0, 0, i+st->array_x, j+st->array_y,
st->width, st->height, &st->shm_info);
}
st->array_x += st->array_dx;
st->array_y += st->array_dy;
if (st->array_x < 0) {
st->array_x = 0;
st->array_dx = -st->array_dx;
bump = True;
} else if (st->array_x > (st->xgwa.width - st->array_width)) {
st->array_x = (st->xgwa.width - st->array_width);
st->array_dx = -st->array_dx;
bump = True;
}
if (st->array_y < 0) {
st->array_y = 0;
st->array_dy = -st->array_dy;
bump = True;
} else if (st->array_y > (st->xgwa.height - st->array_height)) {
st->array_y = (st->xgwa.height - st->array_height);
st->array_dy = -st->array_dy;
bump = True;
}
if (bump) {
if (random() & 1) {
double swap = st->array_dx;
st->array_dx = st->array_dy;
st->array_dy = swap;
}
}
st->frame++;
}
return st->delay;
}
static void
rd_reshape (Display *dpy, Window window, void *closure,
unsigned int w, unsigned int h)
{
}
static Bool
rd_event (Display *dpy, Window window, void *closure, XEvent *event)
{
return False;
}
static void
rd_free (Display *dpy, Window window, void *closure)
{
struct state *st = (struct state *) closure;
free (st->r1);
free (st->r2);
free (st->r1b);
free (st->r2b);
free (st->colors);
free (st->mc);
XFreeGC (dpy, st->gc);
destroy_xshm_image (dpy, st->image, &st->shm_info);
free (st);
}
XSCREENSAVER_MODULE_2 ("RDbomb", rdbomb, rd)