
/**************************************************************************
 *
 *  FILE            lmorph.c
 *  MODULE OF       xscreensaver
 *
 *  DESCRIPTION     Bilinear interpolation for morphing line shapes.
 *
 *  WRITTEN BY      Sverre H. Huseby                Glenn T. Lines
 *                  Maridalsvn. 122, leil 101       Frysjavn. 3, 5. etg.
 *                  N-0461 Oslo                     N-0883 Oslo
 *                  Norway                          Norway
 *
 *                  Phone:  +47 22 71 99 08         Phone:  +47 22 23 71 99
 *                  E-mail: sverrehu@ifi.uio.no     E-mail: gtl@si.sintef.no
 *
 *                  The original idea, and the bilinear interpolation
 *                  mathematics used, emerged in the head of the wise
 *                  Glenn Terje Lines.
 *
 *  MODIFICATIONS   march 1995
 *                    * Converted from an MS-Windows program to X Window.
 *
 **************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "screenhack.h"

/**************************************************************************
 *                                                                        *
 *                       P R I V A T E    D A T A                         *
 *                                                                        *
 **************************************************************************/

/* Define MARGINS to make some space around the figure */
#define MARGINS /**/

#define MAXFIGS    20
#define TWO_PI     (2.0 * M_PI)
#define RND(x)     (random() % (x))
static int
    cFig = 0,                   /* Number of figure arrays. */
    cPoint,                     /* Number of points in each array. */
    nWork,                      /* Current work array number. */
    nFrom,                      /* Current from array number. */
    nTo;                        /* Current to array number. */
static long
    delay;                      /* usecs to wait between updates. */
static XPoint
    *aWork[2],                  /* Working arrays. */
    *a[MAXFIGS],                /* The figure arrays. */
    *aTmp,                      /* Used as source when interrupting morph */
    *aPrev,                     /* Previous points displayed. */
    *aCurr,                     /* The current points displayed. */  
    *aFrom,                     /* Figure converting from. */
    *aTo;                       /* Figure converting to. */
static double
    gam,
    maxGamma = 1.0,
    delta_gam;
static GC
    gcDraw, gcClear;
static Display
    *dpy;
static Window
    window;



/**************************************************************************
 *                                                                        *
 *                        P U B L I C    D A T A                          *
 *                                                                        *
 **************************************************************************/

char *progclass = "LMorph";

char *defaults [] = {
    "LMorph.background: black",
    "LMorph.foreground: green",
    "*points: 150",
    "*steps: 0",
    "*delay: 50000",
    0
};

XrmOptionDescRec options [] = {
  { "-points", ".points", XrmoptionSepArg, 0 },
  { "-steps",  ".steps",  XrmoptionSepArg, 0 },
  { "-delay",  ".delay",  XrmoptionSepArg, 0 },
  { 0, 0, 0, 0 }
};


/**************************************************************************
 *                                                                        *
 *                   P R I V A T E    F U N C T I O N S                   *
 *                                                                        *
 **************************************************************************/

static void *
xmalloc(size_t size)
{
    void *ret;

    if ((ret = malloc(size)) == NULL) {
	fprintf(stderr, "lmorph: out of memory\n");
	exit(1);
    }
    return ret;
}



static double frnd (void)
{
    /*
     *  Hm. for some reason the second line (using RAND_MAX) didn't
     *  work on some machines, so I always use the first.
     */
#ifndef dont_use_RAND_MAX
    return (double) (random() & 0x7FFF) / 0x7FFF;
#else  /* RAND_MAX */
    return ((double) random()) / RAND_MAX;
#endif /* RAND_MAX */
}



static void initPointArrays (void)
{
    XWindowAttributes wa;
    int q, w,
        mx, my,                 /* Max screen coordinates. */
        mp,                     /* Max point number. */
        s, rx, ry,
        marginx, marginy;
    double scalex, scaley;

    XGetWindowAttributes(dpy, window, &wa);
    mx = wa.width - 1;
    my = wa.height - 1;
    mp = cPoint - 1;

    aWork[0] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    aWork[1] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    aTmp     = (XPoint *) xmalloc(cPoint * sizeof(XPoint));


    /*
     *  Figure 0
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    s = cPoint / 4;
    for (q = 0; q < s; q++) {
        a[cFig][q].x = ((double) q / s) * mx;
        a[cFig][q].y = 0;
        a[cFig][s + q].x = mx;
        a[cFig][s + q].y = ((double) q / s) * my;
        a[cFig][2 * s + q].x = mx - ((double) q / s) * mx;
        a[cFig][2 * s + q].y = my;
        a[cFig][3 * s + q].x = 0;
        a[cFig][3 * s + q].y = my - ((double) q / s) * my;
    }
    for (q = 4 * s; q < cPoint; q++) 
        a[cFig][q].x = a[cFig][q].y = 0;
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 1
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = ((double) q / cPoint) * mx;
        a[cFig][q].y = (1.0 - sin(((double) q / mp) * TWO_PI)) * my / 2.0;
    }
    ++cFig;

    /*
     *  Figure 2
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + rx * sin(1 * TWO_PI * (double) q / mp);
        a[cFig][q].y = my / 2 + ry * cos(3 * TWO_PI * (double) q / mp);
    }
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 3
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + ry * sin(3 * TWO_PI * (double) q / mp);
        a[cFig][q].y = my / 2 + ry * cos(1 * TWO_PI * (double) q / mp);
    }
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 4
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + ry * (1 - 0.1 * frnd())
	    * sin(TWO_PI * (double) q / mp);
        a[cFig][q].y = my / 2 + ry * (1 - 0.1 * frnd())
	    * cos(TWO_PI * (double) q / mp);
    }
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 5
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + ry * (0.8 - 0.2 * sin(30 * TWO_PI * q / mp))
	    * sin(TWO_PI * (double) q / mp);
        a[cFig][q].y = my / 2 + ry * (0.8 - 0.2 * sin(30 * TWO_PI * q / mp))
	    * cos(TWO_PI * (double) q / mp);
    }
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 6
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + ry * sin(TWO_PI * (double) q / mp);
        a[cFig][q].y = my / 2 + ry * cos(TWO_PI * (double) q / mp);
    }
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 7
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + rx * cos(TWO_PI * (double) q / mp);
        a[cFig][q].y = my / 2 + ry * sin(TWO_PI * (double) q / mp);
    }
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 8
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = ((double) q / mp) * mx;
        a[cFig][q].y = (1.0 - cos(((double) q / mp) * 3 * TWO_PI)) * my / 2.0;
    }
    ++cFig;

    /*
     *  Figure 9
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + rx * sin(2 * TWO_PI * (double) q / mp);
        a[cFig][q].y = my / 2 + ry * cos(3 * TWO_PI * (double) q / mp);
    }
    a[cFig][mp].x = a[cFig][0].x;
    a[cFig][mp].y = a[cFig][0].y;
    ++cFig;

    /*
     *  Figure 10
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + ry * sin(5 * TWO_PI * (double) q / mp)
	    * ((double) q / mp);
        a[cFig][q].y = my / 2 + ry * cos(5 * TWO_PI * (double) q / mp)
	    * ((double) q / mp);
    }
    ++cFig;

    /*
     *  Figure 11
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    rx = mx / 2;
    ry = my / 2;
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = mx / 2 + ry * sin(6 * TWO_PI * (double) q / mp)
	    * ((double) q / mp);
        a[cFig][q].y = my / 2 - ry * cos(6 * TWO_PI * (double) q / mp)
	    * ((double) q / mp);
    }
    ++cFig;

    /*
     *  Figure 12
     */
    a[cFig] = (XPoint *) xmalloc(cPoint * sizeof(XPoint));
    for (q = 0; q < cPoint; q++) {
        a[cFig][q].x = ((double) q / mp) * mx;
        a[cFig][q].y = (1.0 - sin(((double) q / mp) * 5 * TWO_PI)) * my / 2.0;
    }
    ++cFig;

#ifdef MARGINS
    /*
     *  Make some space around the figures.
     */
    marginx = (mx + 1) / 10;
    marginy = (my + 1) / 10;
    scalex = (double) ((mx + 1) - 2.0 * marginx) / (mx + 1.0);
    scaley = (double) ((my + 1) - 2.0 * marginy) / (my + 1.0);
    for (q = 0; q < cFig; q++)
	for (w = 0; w < cPoint; w++) {
 	    a[q][w].x = marginx + a[q][w].x * scalex;
 	    a[q][w].y = marginy + a[q][w].y * scaley;
	}
#endif
}



static void createPoints (void)
{
    int    q;
    XPoint *pa = aCurr, *pa1 = aFrom, *pa2 = aTo;
    long   lg, l1g;


    lg = 8192L * gam, l1g = 8192L * (1.0 - gam);
    for (q = 0; q < cPoint; q++) {
        pa->x = (short) ((l1g * pa1->x + lg * pa2->x) / 8192L);
        pa->y = (short) ((l1g * pa1->y + lg * pa2->y) / 8192L);
        ++pa;
        ++pa1;
        ++pa2;
    }
}


static void drawImage (void)
{
    register int q;
    XPoint *old0, *old1, *new0, *new1;

    /*
     *  Problem: update the window without too much flickering. I do
     *  this by handling each linesegment separately. First remove a
     *  line, then draw the new line. The problem is that this leaves
     *  small black pixels on the figure. To fix this, I draw the
     *  entire figure using XDrawLines() afterwards.
     */
    if (aPrev) {
	old0 = aPrev;
	old1 = aPrev + 1;
	new0 = aCurr;
	new1 = aCurr + 1;
	for (q = cPoint - 1; q; q--) {
	    XDrawLine(dpy, window, gcClear,
		      old0->x, old0->y, old1->x, old1->y);
	    XDrawLine(dpy, window, gcDraw,
		      new0->x, new0->y, new1->x, new1->y);
	    ++old0;
	    ++old1;
	    ++new0;
	    ++new1;
	}
    }
    XDrawLines(dpy, window, gcDraw, aCurr, cPoint, CoordModeOrigin);
    XFlush(dpy);
}

static void initLMorph (void)
{
    int               steps;
    XGCValues         gcv;
    XWindowAttributes wa;
    Colormap          cmap;
    
    cPoint = get_integer_resource("points", "Integer");
    steps = get_integer_resource("steps", "Integer");
    delay = get_integer_resource("delay", "Integer");

    if (steps <= 0)
      steps = (random() % 400) + 100;

    delta_gam = 1.0 / steps;
    XGetWindowAttributes(dpy, window, &wa);
    cmap = wa.colormap;
    gcv.foreground = get_pixel_resource("foreground", "Foreground", dpy, cmap);
    gcDraw = XCreateGC(dpy, window, GCForeground, &gcv);
    XSetForeground(dpy, gcDraw, gcv.foreground);
    gcv.foreground = get_pixel_resource("background", "Background", dpy, cmap);
    gcClear = XCreateGC(dpy, window, GCForeground, &gcv);
    XClearWindow(dpy, window);

    srandom(time(NULL));
    initPointArrays();
    aCurr = aWork[nWork = 0];
    aPrev = NULL;
    gam = 2.0;
    nTo = RND(cFig);
}

static void animateLMorph (void)
{
    if (gam > maxGamma) {
        gam = 0.0;
        if (maxGamma == 1.0) {
            nFrom = nTo;
            aFrom = a[nFrom];
        } else {
            memcpy(aTmp, aCurr, cPoint * sizeof(XPoint));
            aFrom = aTmp;
            nFrom = -1;
        }
        do {
            nTo = RND(cFig);
        } while (nTo == nFrom);
        aTo = a[nTo];
        if (RND(2)) {
            /*
             *  Reverse the array to get more variation.
             */
            int    i1, i2;
            XPoint p;
            
            for (i1 = 0, i2 = cPoint - 1; i1 < cPoint / 2; i1++, i2--) {
                p = aTo[i1];
                aTo[i1] = aTo[i2];
                aTo[i2] = p;
            }
        }
        /*
         *  It may be nice to interrupt the next run.
         */
        if (RND(3) > 0)
            maxGamma = 0.1 + 0.7 * (RND(1001) / 1000.0);
        else
            maxGamma = 1.0;
    }

    createPoints();
    drawImage();
    aPrev = aCurr;
    aCurr = aWork[nWork ^= 1];

    gam += delta_gam;
}



/**************************************************************************
 *                                                                        *
 *                    P U B L I C    F U N C T I O N S                    *
 *                                                                        *
 **************************************************************************/

void
screenhack(Display *disp, Window win)
{
    dpy = disp;
    window = win;
    initLMorph();
    for (;;) {
	animateLMorph();
	screenhack_usleep(delay);
    }
}
