source: trunk/third/xscreensaver/hacks/nerverot.c @ 20148

/* nerverot, nervous rotation of random thingies, v1.4
 * by Dan Bornstein, danfuzz@milk.com
 * Copyright (c) 2000-2001 Dan Bornstein. All rights reserved.
 *
 * 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.
 *
 * The goal of this screensaver is to be interesting and compelling to
 * watch, yet induce a state of nervous edginess in the viewer.
 *
 * See the included man page for more details.
 */

#include <math.h>
#include "screenhack.h"

#define FLOAT double

/* random float in the range (-1..1) */
#define RAND_FLOAT_PM1 \
        (((FLOAT) ((random() >> 8) & 0xffff)) / ((FLOAT) 0x10000) * 2 - 1)

/* random float in the range (0..1) */
#define RAND_FLOAT_01 \
        (((FLOAT) ((random() >> 8) & 0xffff)) / ((FLOAT) 0x10000))



/* parameters that are user configurable */

/* number of blots */
static int requestedBlotCount;

/* delay (usec) between iterations */
int delay;

/* max iterations per model */
int maxIters;

/* variability of xoff/yoff per iteration (0..1) */
static FLOAT nervousness;

/* max nervousness radius (0..1) */
static FLOAT maxNerveRadius;

/* chance per iteration that an event will happen */
static FLOAT eventChance;

/* fraction (0..1) towards rotation target or scale target to move each
 * iteration */
static FLOAT iterAmt;

/* min and max scale for drawing, as fraction of baseScale */
static FLOAT minScale;
static FLOAT maxScale;

/* min and max radius of blot drawing */
static int minRadius;
static int maxRadius;

/* the number of colors to use */
static int colorCount;

/* width of lines */
static int lineWidth;

/* whether or not to do double-buffering */
static Bool doubleBuffer;



/* non-user-modifiable immutable definitions */

/* base scale factor for drawing, calculated as
 * max(screenWidth,screenHeight) */
static int baseScale;

/* width and height of the window */
static int windowWidth;
static int windowHeight;

/* center position of the window */
static int centerX;
static int centerY;

static Display *display;  /* the display to draw on */
static Window window;     /* the window to draw on */
static Drawable drawable; /* the thing to directly draw on */
static GC *gcs;           /* array of gcs, one per color used */



/* structure of the model */

/* each point-like thingy to draw is represented as a blot */
typedef struct blot_s
{
    FLOAT x;           /* 3d x position (-1..1) */
    FLOAT y;           /* 3d y position (-1..1) */
    FLOAT z;           /* 3d z position (-1..1) */
    FLOAT xoff[3][3];  /* display x offset per drawn point (-1..1) */
    FLOAT yoff[3][3];  /* display x offset per drawn point (-1..1) */
} Blot;

/* each drawn line is represented as a LineSegment */
typedef struct linesegment_s
{
    GC gc;
    int x1;
    int y1;
    int x2;
    int y2;
} LineSegment;

/* array of the blots in the model */
static Blot *blots = NULL;
static int blotCount;

/* each blot draws as a simple 2d shape with each coordinate as an int
 * in the range (-1..1); this is the base shape */
static XPoint blotShape[] = { { 0, 0}, { 1, 0}, { 1, 1}, 
                              { 0, 1}, {-1, 1}, {-1, 0}, 
                              {-1,-1}, { 0,-1}, { 1,-1} };
static int blotShapeCount = sizeof (blotShape) / sizeof (XPoint);

/* two arrays of line segments; one for the ones to erase, and one for the
 * ones to draw */
static int segCount;
static LineSegment *segsToDraw = NULL;
static LineSegment *segsToErase = NULL;

/* current rotation values per axis, scale factor, and light position */
static FLOAT xRot;
static FLOAT yRot;
static FLOAT zRot;
static FLOAT curScale;
static FLOAT lightX;
static FLOAT lightY;
static FLOAT lightZ;

/* target rotation values per axis, scale factor, and light position */
static FLOAT xRotTarget;
static FLOAT yRotTarget;
static FLOAT zRotTarget;
static FLOAT scaleTarget;
static FLOAT lightXTarget;
static FLOAT lightYTarget;
static FLOAT lightZTarget;

/* current absolute offsets from the center */
static int centerXOff = 0;
static int centerYOff = 0;

/* iterations until the model changes */
static int itersTillNext;



/*
 * generic blot setup and manipulation
 */

/* initialize a blot with the given coordinates and random display offsets */
static void initBlot (Blot *b, FLOAT x, FLOAT y, FLOAT z)
{
    int i, j;

    b->x = x;
    b->y = y;
    b->z = z;

    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            b->xoff[i][j] = RAND_FLOAT_PM1;
            b->yoff[i][j] = RAND_FLOAT_PM1;
        }
    }
}

/* scale the blots to have a max distance of 1 from the center */
static void scaleBlotsToRadius1 (void)
{
    FLOAT max = 0.0;
    int n;

    for (n = 0; n < blotCount; n++)
    {
        FLOAT distSquare = 
            blots[n].x * blots[n].x +
            blots[n].y * blots[n].y +
            blots[n].z * blots[n].z;
        if (distSquare > max)
        {
            max = distSquare;
        }
    }

    if (max == 0.0)
    {
        return;
    }

    max = sqrt (max);

    for (n = 0; n < blotCount; n++)
    {
        blots[n].x /= max;
        blots[n].y /= max;
        blots[n].z /= max;
    }
}

/* randomly reorder the blots */
static void randomlyReorderBlots (void)
{
    int n;

    for (n = 0; n < blotCount; n++)
    {
        int m = RAND_FLOAT_01 * (blotCount - n) + n;
        Blot tmpBlot = blots[n];
        blots[n] = blots[m];
        blots[m] = tmpBlot;
    }
}

/* randomly rotate the blots around the origin */
static void randomlyRotateBlots (void)
{
    int n;

    /* random amounts to rotate about each axis */
    FLOAT xRot = RAND_FLOAT_PM1 * M_PI;
    FLOAT yRot = RAND_FLOAT_PM1 * M_PI;
    FLOAT zRot = RAND_FLOAT_PM1 * M_PI;

    /* rotation factors */
    FLOAT sinX = sin (xRot);
    FLOAT cosX = cos (xRot);
    FLOAT sinY = sin (yRot);
    FLOAT cosY = cos (yRot);
    FLOAT sinZ = sin (zRot);
    FLOAT cosZ = cos (zRot);

    for (n = 0; n < blotCount; n++)
    {
        FLOAT x1 = blots[n].x;
        FLOAT y1 = blots[n].y;
        FLOAT z1 = blots[n].z;
        FLOAT x2, y2, z2;

        /* rotate on z axis */
        x2 = x1 * cosZ - y1 * sinZ;
        y2 = x1 * sinZ + y1 * cosZ;
        z2 = z1;

        /* rotate on x axis */
        y1 = y2 * cosX - z2 * sinX;
        z1 = y2 * sinX + z2 * cosX;
        x1 = x2;

        /* rotate on y axis */
        z2 = z1 * cosY - x1 * sinY;
        x2 = z1 * sinY + x1 * cosY;
        y2 = y1;

        blots[n].x = x2;
        blots[n].y = y2;
        blots[n].z = z2;
    }
}



/*
 * blot configurations
 */

/* set up the initial array of blots to be a at the edge of a sphere */
static void setupBlotsSphere (void)
{
    int n;

    blotCount = requestedBlotCount;
    blots = calloc (sizeof (Blot), blotCount);

    for (n = 0; n < blotCount; n++)
    {
        /* pick a spot, but reject if its radius is < 0.2 or > 1 to
         * avoid scaling problems */
        FLOAT x, y, z, radius;

        for (;;)
        {
            x = RAND_FLOAT_PM1;
            y = RAND_FLOAT_PM1;
            z = RAND_FLOAT_PM1;

            radius = sqrt (x * x + y * y + z * z);
            if ((radius >= 0.2) && (radius <= 1.0))
            {
                break;
            }
        }

        x /= radius;
        y /= radius;
        z /= radius;

        initBlot (&blots[n], x, y, z);
    }
}

/* set up the initial array of blots to be a simple cube */
static void setupBlotsCube (void)
{
    int i, j, k, n;

    /* derive blotsPerEdge from blotCount, but then do the reverse
     * since roundoff may have changed blotCount */
    int blotsPerEdge = ((requestedBlotCount - 8) / 12) + 2;
    FLOAT distBetween;

    if (blotsPerEdge < 2)
    {
        blotsPerEdge = 2;
    }

    distBetween = 2.0 / (blotsPerEdge - 1.0);

    blotCount = 8 + (blotsPerEdge - 2) * 12;
    blots = calloc (sizeof (Blot), blotCount);
    n = 0;

    /* define the corners */
    for (i = -1; i < 2; i += 2)
    {
        for (j = -1; j < 2; j += 2)
        {
            for (k = -1; k < 2; k += 2)
            {
                initBlot (&blots[n], i, j, k);
                n++;
            } 
        }
    }

    /* define the edges */
    for (i = 1; i < (blotsPerEdge - 1); i++)
    {
        FLOAT varEdge = distBetween * i - 1;
        initBlot (&blots[n++], varEdge, -1, -1);
        initBlot (&blots[n++], varEdge,  1, -1);
        initBlot (&blots[n++], varEdge, -1,  1);
        initBlot (&blots[n++], varEdge,  1,  1);
        initBlot (&blots[n++], -1, varEdge, -1);
        initBlot (&blots[n++],  1, varEdge, -1);
        initBlot (&blots[n++], -1, varEdge,  1);
        initBlot (&blots[n++],  1, varEdge,  1);
        initBlot (&blots[n++], -1, -1, varEdge);
        initBlot (&blots[n++],  1, -1, varEdge);
        initBlot (&blots[n++], -1,  1, varEdge);
        initBlot (&blots[n++],  1,  1, varEdge);
    }

    scaleBlotsToRadius1 ();
    randomlyReorderBlots ();
    randomlyRotateBlots ();
}

/* set up the initial array of blots to be a cylinder */
static void setupBlotsCylinder (void)
{
    int i, j, n;
    FLOAT distBetween;

    /* derive blotsPerEdge and blotsPerRing from blotCount, but then do the
     * reverse since roundoff may have changed blotCount */
    FLOAT reqRoot = sqrt ((FLOAT) requestedBlotCount);
    int blotsPerRing = ceil (RAND_FLOAT_PM1 * reqRoot) / 2 + reqRoot;
    int blotsPerEdge = requestedBlotCount / blotsPerRing;

    if (blotsPerRing < 2)
    {
        blotsPerRing = 2;
    }

    if (blotsPerEdge < 2)
    {
        blotsPerEdge = 2;
    }

    distBetween = 2.0 / (blotsPerEdge - 1);

    blotCount = blotsPerEdge * blotsPerRing;
    blots = calloc (sizeof (Blot), blotCount);
    n = 0;

    /* define the edges */
    for (i = 0; i < blotsPerRing; i++)
    {
        FLOAT x = sin (2 * M_PI / blotsPerRing * i);
        FLOAT y = cos (2 * M_PI / blotsPerRing * i);
        for (j = 0; j < blotsPerEdge; j++)
        {
            initBlot (&blots[n], x, y, j * distBetween - 1);
            n++;
        }
    }

    scaleBlotsToRadius1 ();
    randomlyReorderBlots ();
    randomlyRotateBlots ();
}

/* set up the initial array of blots to be a squiggle */
static void setupBlotsSquiggle (void)
{
    FLOAT x, y, z, xv, yv, zv, len;
    int minCoor, maxCoor;
    int n;

    blotCount = requestedBlotCount;
    blots = calloc (sizeof (Blot), blotCount);

    maxCoor = (int) (RAND_FLOAT_01 * 5) + 1;
    minCoor = -maxCoor;

    x = RAND_FLOAT_PM1;
    y = RAND_FLOAT_PM1;
    z = RAND_FLOAT_PM1;

    xv = RAND_FLOAT_PM1;
    yv = RAND_FLOAT_PM1;
    zv = RAND_FLOAT_PM1;
    len = sqrt (xv * xv + yv * yv + zv * zv);
    xv /= len;
    yv /= len;
    zv /= len;
    
    for (n = 0; n < blotCount; n++)
    {
        FLOAT newx, newy, newz;
        initBlot (&blots[n], x, y, z);

        for (;;)
        {
            xv += RAND_FLOAT_PM1 * 0.1;
            yv += RAND_FLOAT_PM1 * 0.1;
            zv += RAND_FLOAT_PM1 * 0.1;
            len = sqrt (xv * xv + yv * yv + zv * zv);
            xv /= len;
            yv /= len;
            zv /= len;

            newx = x + xv * 0.1;
            newy = y + yv * 0.1;
            newz = z + zv * 0.1;

            if (   (newx >= minCoor) && (newx <= maxCoor)
                && (newy >= minCoor) && (newy <= maxCoor)
                && (newz >= minCoor) && (newz <= maxCoor))
            {
                break;
            }
        }

        x = newx;
        y = newy;
        z = newz;
    }

    scaleBlotsToRadius1 ();
    randomlyReorderBlots ();
}

/* set up the initial array of blots to be near the corners of a
 * cube, distributed slightly */
static void setupBlotsCubeCorners (void)
{
    int n;

    blotCount = requestedBlotCount;
    blots = calloc (sizeof (Blot), blotCount);

    for (n = 0; n < blotCount; n++)
    {
        FLOAT x = rint (RAND_FLOAT_01) * 2 - 1;
        FLOAT y = rint (RAND_FLOAT_01) * 2 - 1;
        FLOAT z = rint (RAND_FLOAT_01) * 2 - 1;

        x += RAND_FLOAT_PM1 * 0.3;
        y += RAND_FLOAT_PM1 * 0.3;
        z += RAND_FLOAT_PM1 * 0.3;

        initBlot (&blots[n], x, y, z);
    }

    scaleBlotsToRadius1 ();
    randomlyRotateBlots ();
}

/* set up the initial array of blots to be randomly distributed
 * on the surface of a tetrahedron */
static void setupBlotsTetrahedron (void)
{
    /* table of corners of the tetrahedron */
    static FLOAT cor[4][3] = { {  0.0,   1.0,  0.0 },
                               { -0.75, -0.5, -0.433013 },
                               {  0.0,  -0.5,  0.866025 },
                               {  0.75, -0.5, -0.433013 } };

    int n, c;

    /* derive blotsPerSurface from blotCount, but then do the reverse
     * since roundoff may have changed blotCount */
    int blotsPerSurface = requestedBlotCount / 4;

    blotCount = blotsPerSurface * 4;
    blots = calloc (sizeof (Blot), blotCount);

    for (n = 0; n < blotCount; n += 4)
    {
        /* pick a random point on a unit right triangle */
        FLOAT rawx = RAND_FLOAT_01;
        FLOAT rawy = RAND_FLOAT_01;

        if ((rawx + rawy) > 1)
        {
            /* swap coords into place */
            FLOAT t = 1.0 - rawx;
            rawx = 1.0 - rawy;
            rawy = t;
        }

        /* translate the point to be on each of the surfaces */
        for (c = 0; c < 4; c++)
        {
            FLOAT x, y, z;
            
            int c1 = (c + 1) % 4;
            int c2 = (c + 2) % 4;
            
            x = (cor[c1][0] - cor[c][0]) * rawx + 
                (cor[c2][0] - cor[c][0]) * rawy + 
                cor[c][0];

            y = (cor[c1][1] - cor[c][1]) * rawx + 
                (cor[c2][1] - cor[c][1]) * rawy + 
                cor[c][1];

            z = (cor[c1][2] - cor[c][2]) * rawx + 
                (cor[c2][2] - cor[c][2]) * rawy + 
                cor[c][2];

            initBlot (&blots[n + c], x, y, z);
        }
    }

    randomlyRotateBlots ();
}

/* set up the initial array of blots to be an almost-evenly-distributed
 * square sheet */
static void setupBlotsSheet (void)
{
    int x, y;

    int blotsPerDimension = floor (sqrt (requestedBlotCount));
    FLOAT spaceBetween;

    if (blotsPerDimension < 2)
    {
        blotsPerDimension = 2;
    }

    spaceBetween = 2.0 / (blotsPerDimension - 1);

    blotCount = blotsPerDimension * blotsPerDimension;
    blots = calloc (sizeof (Blot), blotCount);

    for (x = 0; x < blotsPerDimension; x++)
    {
        for (y = 0; y < blotsPerDimension; y++)
        {
            FLOAT x1 = x * spaceBetween - 1.0;
            FLOAT y1 = y * spaceBetween - 1.0;
            FLOAT z1 = 0.0;

            x1 += RAND_FLOAT_PM1 * spaceBetween / 3;
            y1 += RAND_FLOAT_PM1 * spaceBetween / 3;
            z1 += RAND_FLOAT_PM1 * spaceBetween / 2;

            initBlot (&blots[x + y * blotsPerDimension], x1, y1, z1);
        }
    }

    scaleBlotsToRadius1 ();
    randomlyReorderBlots ();
    randomlyRotateBlots ();
}

/* set up the initial array of blots to be a swirlycone */
static void setupBlotsSwirlyCone (void)
{
    FLOAT radSpace = 1.0 / (requestedBlotCount - 1);
    FLOAT zSpace = radSpace * 2;
    FLOAT rotAmt = RAND_FLOAT_PM1 * M_PI / 10;

    int n;
    FLOAT rot = 0.0;

    blotCount = requestedBlotCount;
    blots = calloc (sizeof (Blot), blotCount);

    for (n = 0; n < blotCount; n++)
    {
        FLOAT radius = n * radSpace;
        FLOAT x = cos (rot) * radius;
        FLOAT y = sin (rot) * radius;
        FLOAT z = n * zSpace - 1.0;

        rot += rotAmt;
        initBlot (&blots[n], x, y, z);
    }

    scaleBlotsToRadius1 ();
    randomlyReorderBlots ();
    randomlyRotateBlots ();
}

/* forward declaration for recursive use immediately below */
static void setupBlots (void);

/* set up the blots to be two of the other choices, placed next to
 * each other */
static void setupBlotsDuo (void)
{
    int origRequest = requestedBlotCount;
    FLOAT tx, ty, tz, radius;
    Blot *blots1, *blots2;
    int count1, count2;
    int n;

    if (requestedBlotCount < 15)
    {
        /* special case bottom-out */
        setupBlotsSphere ();
        return;
    }

    tx = RAND_FLOAT_PM1;
    ty = RAND_FLOAT_PM1;
    tz = RAND_FLOAT_PM1;
    radius = sqrt (tx * tx + ty * ty + tz * tz);
    tx /= radius;
    ty /= radius;
    tz /= radius;

    /* recursive call to setup set 1 */
    requestedBlotCount = origRequest / 2;
    setupBlots ();

    if (blotCount >= origRequest)
    {
        /* return immediately if this satisfies the original count request */
        requestedBlotCount = origRequest;
        return;
    }

    blots1 = blots;
    count1 = blotCount;
    blots = NULL;
    blotCount = 0;
    
    /* translate to new position */
    for (n = 0; n < count1; n++)
    {
        blots1[n].x += tx;
        blots1[n].y += ty;
        blots1[n].z += tz;
    }

    /* recursive call to setup set 2 */
    requestedBlotCount = origRequest - count1;
    setupBlots ();
    blots2 = blots;
    count2 = blotCount;

    /* translate to new position */
    for (n = 0; n < count2; n++)
    {
        blots2[n].x -= tx;
        blots2[n].y -= ty;
        blots2[n].z -= tz;
    }

    /* combine the two arrays */
    blotCount = count1 + count2;
    blots = calloc (sizeof (Blot), blotCount);
    memcpy (&blots[0],      blots1, sizeof (Blot) * count1);
    memcpy (&blots[count1], blots2, sizeof (Blot) * count2);
    free (blots1);
    free (blots2);

    scaleBlotsToRadius1 ();
    randomlyReorderBlots ();

    /* restore the original requested count, for future iterations */
    requestedBlotCount = origRequest;
}



/*
 * main blot setup
 */

/* free the blots, in preparation for a new shape */
static void freeBlots (void)
{
    if (blots != NULL)
    {
        free (blots);
        blots = NULL;
    }

    if (segsToErase != NULL)
    {
        free (segsToErase);
        segsToErase = NULL;
    }

    if (segsToDraw != NULL)
    {
        free (segsToDraw);
        segsToDraw = NULL;
    }
}

/* set up the initial arrays of blots */
static void setupBlots (void)
{
    int which = RAND_FLOAT_01 * 11;

    freeBlots ();

    switch (which)
    {
        case 0:
            setupBlotsCube ();
            break;
        case 1:
            setupBlotsSphere ();
            break;
        case 2:
            setupBlotsCylinder ();
            break;
        case 3:
            setupBlotsSquiggle ();
            break;
        case 4:
            setupBlotsCubeCorners ();
            break;
        case 5:
            setupBlotsTetrahedron ();
            break;
        case 6:
            setupBlotsSheet ();
            break;
        case 7:
            setupBlotsSwirlyCone ();
            break;
        case 8:
        case 9:
        case 10:
            setupBlotsDuo ();
            break;
    }
}

/* set up the segments arrays */
static void setupSegs (void)
{
    /* there are blotShapeCount - 1 line segments per blot */
    segCount = blotCount * (blotShapeCount - 1);
    segsToErase = calloc (sizeof (LineSegment), segCount);
    segsToDraw = calloc (sizeof (LineSegment), segCount);

    /* erase the world */
    XFillRectangle (display, drawable, gcs[0], 0, 0, 
                    windowWidth, windowHeight);
}



/*
 * color setup stuff
 */

/* set up the colormap */
static void setupColormap (XWindowAttributes *xgwa)
{
    int n;
    XGCValues gcv;
    XColor *colors = (XColor *) calloc (sizeof (XColor), colorCount + 1);

    unsigned short r, g, b;
    int h1, h2;
    double s1, s2, v1, v2;

    r = RAND_FLOAT_01 * 0x10000;
    g = RAND_FLOAT_01 * 0x10000;
    b = RAND_FLOAT_01 * 0x10000;
    rgb_to_hsv (r, g, b, &h1, &s1, &v1);
    v1 = 1.0;
    s1 = 1.0;

    r = RAND_FLOAT_01 * 0x10000;
    g = RAND_FLOAT_01 * 0x10000;
    b = RAND_FLOAT_01 * 0x10000;
    rgb_to_hsv (r, g, b, &h2, &s2, &v2);
    s2 = 0.7;
    v2 = 0.7;
    
    colors[0].pixel = get_pixel_resource ("background", "Background",
                                          display, xgwa->colormap);
    
    make_color_ramp (display, xgwa->colormap, h1, s1, v1, h2, s2, v2,
                     colors + 1, &colorCount, False, True, False);

    if (colorCount < 1)
    {
        fprintf (stderr, "%s: couldn't allocate any colors\n", progname);
        exit (-1);
    }
    
    gcs = (GC *) calloc (sizeof (GC), colorCount + 1);

    for (n = 0; n <= colorCount; n++) 
    {
        gcv.foreground = colors[n].pixel;
        gcv.line_width = lineWidth;
        gcs[n] = XCreateGC (display, window, GCForeground | GCLineWidth, &gcv);
    }

    free (colors);
}



/*
 * overall setup stuff
 */

/* set up the system */
static void setup (void)
{
    XWindowAttributes xgwa;

    XGetWindowAttributes (display, window, &xgwa);

    windowWidth = xgwa.width;
    windowHeight = xgwa.height;
    centerX = windowWidth / 2;
    centerY = windowHeight / 2;
    baseScale = (xgwa.height < xgwa.width) ? xgwa.height : xgwa.width;

    if (doubleBuffer)
    {
        drawable = XCreatePixmap (display, window, xgwa.width, xgwa.height,
                                  xgwa.depth);
    }
    else
    {
        drawable = window;
    }

    setupColormap (&xgwa);
    setupBlots ();
    setupSegs ();

    /* set up the initial rotation, scale, and light values as random, but
     * with the targets equal to where it is */
    xRot = xRotTarget = RAND_FLOAT_01 * M_PI;
    yRot = yRotTarget = RAND_FLOAT_01 * M_PI;
    zRot = zRotTarget = RAND_FLOAT_01 * M_PI;
    curScale = scaleTarget = RAND_FLOAT_01 * (maxScale - minScale) + minScale;
    lightX = lightXTarget = RAND_FLOAT_PM1;
    lightY = lightYTarget = RAND_FLOAT_PM1;
    lightZ = lightZTarget = RAND_FLOAT_PM1;

    itersTillNext = RAND_FLOAT_01 * maxIters;
}



/*
 * the simulation
 */

/* "render" the blots into segsToDraw, with the current rotation factors */
static void renderSegs (void)
{
    int n;
    int m = 0;

    /* rotation factors */
    FLOAT sinX = sin (xRot);
    FLOAT cosX = cos (xRot);
    FLOAT sinY = sin (yRot);
    FLOAT cosY = cos (yRot);
    FLOAT sinZ = sin (zRot);
    FLOAT cosZ = cos (zRot);

    for (n = 0; n < blotCount; n++)
    {
        Blot *b = &blots[n];
        int i, j;
        int baseX, baseY;
        FLOAT radius;
        int x[3][3];
        int y[3][3];
        int color;

        FLOAT x1 = blots[n].x;
        FLOAT y1 = blots[n].y;
        FLOAT z1 = blots[n].z;
        FLOAT x2, y2, z2;

        /* rotate on z axis */
        x2 = x1 * cosZ - y1 * sinZ;
        y2 = x1 * sinZ + y1 * cosZ;
        z2 = z1;

        /* rotate on x axis */
        y1 = y2 * cosX - z2 * sinX;
        z1 = y2 * sinX + z2 * cosX;
        x1 = x2;

        /* rotate on y axis */
        z2 = z1 * cosY - x1 * sinY;
        x2 = z1 * sinY + x1 * cosY;
        y2 = y1;

        /* the color to draw is based on the distance from the light of
         * the post-rotation blot */
        x1 = x2 - lightX;
        y1 = y2 - lightY;
        z1 = z2 - lightZ;
        color = 1 + (x1 * x1 + y1 * y1 + z1 * z1) / 4 * colorCount;
        if (color > colorCount)
        {
            color = colorCount;
        }

        /* set up the base screen coordinates for drawing */
        baseX = x2 / 2 * baseScale * curScale + centerX + centerXOff;
        baseY = y2 / 2 * baseScale * curScale + centerY + centerYOff;
        
        radius = (z2 + 1) / 2 * (maxRadius - minRadius) + minRadius;

        for (i = 0; i < 3; i++)
        {
            for (j = 0; j < 3; j++)
            {
                x[i][j] = baseX + 
                    ((i - 1) + (b->xoff[i][j] * maxNerveRadius)) * radius;
                y[i][j] = baseY + 
                    ((j - 1) + (b->yoff[i][j] * maxNerveRadius)) * radius;
            }
        }

        for (i = 1; i < blotShapeCount; i++)
        {
            segsToDraw[m].gc = gcs[color];
            segsToDraw[m].x1 = x[blotShape[i-1].x + 1][blotShape[i-1].y + 1];
            segsToDraw[m].y1 = y[blotShape[i-1].x + 1][blotShape[i-1].y + 1];
            segsToDraw[m].x2 = x[blotShape[i].x   + 1][blotShape[i].y   + 1];
            segsToDraw[m].y2 = y[blotShape[i].x   + 1][blotShape[i].y   + 1];
            m++;
        }
    }
}

/* update blots, adjusting the offsets and rotation factors. */
static void updateWithFeeling (void)
{
    int n, i, j;

    /* pick a new model if the time is right */
    itersTillNext--;
    if (itersTillNext < 0)
    {
        itersTillNext = RAND_FLOAT_01 * maxIters;
        setupBlots ();
        setupSegs ();
        renderSegs ();
    }

    /* update the rotation factors by moving them a bit toward the targets */
    xRot = xRot + (xRotTarget - xRot) * iterAmt; 
    yRot = yRot + (yRotTarget - yRot) * iterAmt;
    zRot = zRot + (zRotTarget - zRot) * iterAmt;

    /* similarly the scale factor */
    curScale = curScale + (scaleTarget - curScale) * iterAmt;

    /* and similarly the light position */
    lightX = lightX + (lightXTarget - lightX) * iterAmt; 
    lightY = lightY + (lightYTarget - lightY) * iterAmt; 
    lightZ = lightZ + (lightZTarget - lightZ) * iterAmt; 

    /* for each blot... */
    for (n = 0; n < blotCount; n++)
    {
        /* add a bit of random jitter to xoff/yoff */
        for (i = 0; i < 3; i++)
        {
            for (j = 0; j < 3; j++)
            {
                FLOAT newOff;

                newOff = blots[n].xoff[i][j] + RAND_FLOAT_PM1 * nervousness;
                if (newOff < -1) newOff = -(newOff + 1) - 1;
                else if (newOff > 1) newOff = -(newOff - 1) + 1;
                blots[n].xoff[i][j] = newOff;

                newOff = blots[n].yoff[i][j] + RAND_FLOAT_PM1 * nervousness;
                if (newOff < -1) newOff = -(newOff + 1) - 1;
                else if (newOff > 1) newOff = -(newOff - 1) + 1;
                blots[n].yoff[i][j] = newOff;
            }
        }
    }

    /* depending on random chance, update one or more factors */
    if (RAND_FLOAT_01 <= eventChance)
    {
        int which = RAND_FLOAT_01 * 14;
        switch (which)
        {
            case 0:
            {
                xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                break;
            }
            case 1:
            {
                yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                break;
            }
            case 2:
            {
                zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                break;
            }
            case 3:
            {
                xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                break;
            }
            case 4:
            {
                xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                break;
            }
            case 5:
            {
                yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                break;
            }
            case 6:
            {
                xRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                yRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                zRotTarget = RAND_FLOAT_PM1 * M_PI * 2;
                break;
            }
            case 7:
            {
                centerXOff = RAND_FLOAT_PM1 * maxRadius;
                break;
            }
            case 8:
            {
                centerYOff = RAND_FLOAT_PM1 * maxRadius;
                break;
            }
            case 9:
            {
                centerXOff = RAND_FLOAT_PM1 * maxRadius;
                centerYOff = RAND_FLOAT_PM1 * maxRadius;
                break;
            }
            case 10:
            {
                scaleTarget = 
                    RAND_FLOAT_01 * (maxScale - minScale) + minScale;
                break;
            }
            case 11:
            {
                curScale = 
                    RAND_FLOAT_01 * (maxScale - minScale) + minScale;
                break;
            }
            case 12:
            {
                lightX = RAND_FLOAT_PM1;
                lightY = RAND_FLOAT_PM1;
                lightZ = RAND_FLOAT_PM1;
                break;
            }
            case 13:
            {
                lightXTarget = RAND_FLOAT_PM1;
                lightYTarget = RAND_FLOAT_PM1;
                lightZTarget = RAND_FLOAT_PM1;
                break;
            }
        }
    }
}

/* erase segsToErase and draw segsToDraw */
static void eraseAndDraw (void)
{
    int n;

    for (n = 0; n < segCount; n++)
    {
        LineSegment *seg = &segsToErase[n];
        XDrawLine (display, drawable, gcs[0], 
                   seg->x1, seg->y1, seg->x2, seg->y2);
        seg = &segsToDraw[n];
        XDrawLine (display, drawable, seg->gc,
                   seg->x1, seg->y1, seg->x2, seg->y2);
    }

    if (doubleBuffer)
    {
        XCopyArea (display, drawable, window, gcs[0], 0, 0, 
                   windowWidth, windowHeight, 0, 0);
    }
}

/* do one iteration */
static void oneIteration (void)
{
    /* switch segsToErase and segsToDraw */
    LineSegment *temp = segsToDraw;
    segsToDraw = segsToErase;
    segsToErase = temp;

    /* update the model */
    updateWithFeeling ();

    /* render new segments */
    renderSegs ();

    /* erase old segments and draw new ones */
    eraseAndDraw ();
}

char *progclass = "NerveRot";

char *defaults [] = {
    ".background:       black",
    ".foreground:       white",
    "*count:            250",
    "*colors:           4",
    "*delay:            10000",
    "*maxIters:         1200",
    "*doubleBuffer:     false",
    "*eventChance:      0.2",
    "*iterAmt:          0.01",
    "*lineWidth:        0",
    "*minScale:         0.6",
    "*maxScale:         1.75",
    "*minRadius:        3",
    "*maxRadius:        25",
    "*maxNerveRadius:   0.7",
    "*nervousness:      0.3",
    0
};

XrmOptionDescRec options [] = {
  { "-count",            ".count",          XrmoptionSepArg, 0 },
  { "-colors",           ".colors",         XrmoptionSepArg, 0 },
  { "-delay",            ".delay",          XrmoptionSepArg, 0 },
  { "-max-iters",        ".maxIters",       XrmoptionSepArg, 0 },
  { "-db",               ".doubleBuffer",   XrmoptionNoArg,  "true" },
  { "-no-db",            ".doubleBuffer",   XrmoptionNoArg,  "false" },
  { "-event-chance",     ".eventChance",    XrmoptionSepArg, 0 },
  { "-iter-amt",         ".iterAmt",        XrmoptionSepArg, 0 },
  { "-line-width",       ".lineWidth",      XrmoptionSepArg, 0 },
  { "-min-scale",        ".minScale",       XrmoptionSepArg, 0 },
  { "-max-scale",        ".maxScale",       XrmoptionSepArg, 0 },
  { "-min-radius",       ".minRadius",      XrmoptionSepArg, 0 },
  { "-max-radius",       ".maxRadius",      XrmoptionSepArg, 0 },
  { "-max-nerve-radius", ".maxNerveRadius", XrmoptionSepArg, 0 },
  { "-nervousness",      ".nervousness",    XrmoptionSepArg, 0 },
  { 0, 0, 0, 0 }
};

/* initialize the user-specifiable params */
static void initParams (void)
{
    int problems = 0;

    delay = get_integer_resource ("delay", "Delay");
    if (delay < 0)
    {
        fprintf (stderr, "error: delay must be at least 0\n");
        problems = 1;
    }
    
    maxIters = get_integer_resource ("maxIters", "Integer");
    if (maxIters < 0)
    {
        fprintf (stderr, "error: maxIters must be at least 0\n");
        problems = 1;
    }
    
    doubleBuffer = get_boolean_resource ("doubleBuffer", "Boolean");

    requestedBlotCount = get_integer_resource ("count", "Count");
    if (requestedBlotCount <= 0)
    {
        fprintf (stderr, "error: count must be at least 0\n");
        problems = 1;
    }

    colorCount = get_integer_resource ("colors", "Colors");
    if (colorCount <= 0)
    {
        fprintf (stderr, "error: colors must be at least 1\n");
        problems = 1;
    }

    lineWidth = get_integer_resource ("lineWidth", "LineWidth");
    if (lineWidth < 0)
    {
        fprintf (stderr, "error: line width must be at least 0\n");
        problems = 1;
    }

    nervousness = get_float_resource ("nervousness", "Float");
    if ((nervousness < 0) || (nervousness > 1))
    {
        fprintf (stderr, "error: nervousness must be in the range 0..1\n");
        problems = 1;
    }

    maxNerveRadius = get_float_resource ("maxNerveRadius", "Float");
    if ((maxNerveRadius < 0) || (maxNerveRadius > 1))
    {
        fprintf (stderr, "error: maxNerveRadius must be in the range 0..1\n");
        problems = 1;
    }

    eventChance = get_float_resource ("eventChance", "Float");
    if ((eventChance < 0) || (eventChance > 1))
    {
        fprintf (stderr, "error: eventChance must be in the range 0..1\n");
        problems = 1;
    }

    iterAmt = get_float_resource ("iterAmt", "Float");
    if ((iterAmt < 0) || (iterAmt > 1))
    {
        fprintf (stderr, "error: iterAmt must be in the range 0..1\n");
        problems = 1;
    }

    minScale = get_float_resource ("minScale", "Float");
    if ((minScale < 0) || (minScale > 10))
    {
        fprintf (stderr, "error: minScale must be in the range 0..10\n");
        problems = 1;
    }

    maxScale = get_float_resource ("maxScale", "Float");
    if ((maxScale < 0) || (maxScale > 10))
    {
        fprintf (stderr, "error: maxScale must be in the range 0..10\n");
        problems = 1;
    }

    if (maxScale < minScale)
    {
        fprintf (stderr, "error: maxScale must be >= minScale\n");
        problems = 1;
    }   

    minRadius = get_integer_resource ("minRadius", "Integer");
    if ((minRadius < 1) || (minRadius > 100))
    {
        fprintf (stderr, "error: minRadius must be in the range 1..100\n");
        problems = 1;
    }

    maxRadius = get_integer_resource ("maxRadius", "Integer");
    if ((maxRadius < 1) || (maxRadius > 100))
    {
        fprintf (stderr, "error: maxRadius must be in the range 1..100\n");
        problems = 1;
    }

    if (maxRadius < minRadius)
    {
        fprintf (stderr, "error: maxRadius must be >= minRadius\n");
        problems = 1;
    }   

    if (problems)
    {
        exit (1);
    }
}

/* main function */
void screenhack (Display *dpy, Window win)
{
    display = dpy;
    window = win;

    initParams ();
    setup ();

    /* make a valid set to erase at first */
    renderSegs ();
    
    for (;;) 
    {
        oneIteration ();
        XSync (dpy, False);
        screenhack_handle_events (dpy);
        usleep (delay);
    }
}