http://ftp.x.org/contrib/applications/xscreensaver-3.10.tar.gz

[xscreensaver] / hacks / penrose.c

/* -*- Mode: C; tab-width: 4 -*-
 * penrose --- quasiperiodic tilings.
 */

/*  As reported in News of the Weird:

          In April, Sir Roger Penrose, a British math professor who has worked
          with Stephen Hawking on such topics as relativity, black holes, and
          whether time has a beginning, filed a copyright-infringement lawsuit
          against the Kimberly-Clark Corporation, which Penrose said copied a
          pattern he created (a pattern demonstrating that "a nonrepeating
          pattern could exist in nature") for its Kleenex quilted toilet paper.
          Penrose said he doesn't like litigation but, "When it comes to the
          population of Great Britain being invited by a multinational to wipe
          their bottoms on what appears to be the work of a Knight of the
          Realm, then a last stand must be taken."

                                NOTW #491, 4-jul-1997, by Chuck Shepherd.
                                http://www.nine.org/notw/notw.html
 */


#if !defined( lint ) && !defined( SABER )
static const char sccsid[] = "@(#)penrose.c     4.00 97/01/01 xlockmore";
#endif

/* Copyright (c) 1996 by Timo Korvola <tkorvola@dopey.hut.fi>
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appear in all copies and that
 * both that copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This file is provided AS IS with no warranties of any kind.  The author
 * shall have no liability with respect to the infringement of copyrights,
 * trade secrets or any patents by this file or any part thereof.  In no
 * event will the author be liable for any lost revenue or profits or
 * other special, indirect and consequential damages.
 *
 * Revision History:
 * 10-May-97: jwz@jwz.org: turned into a standalone program.
 * 09-Sep-96: Written.  */

/*-
Be careful, this probably still has a few bugs (many of which may only
appear with a very low probability).  These are seen with -verbose .
If one of these are hit penrose will reinitialize.
*/

/*-
 * See Onoda, Steinhardt, DiVincenzo and Socolar in
 * Phys. Rev. Lett. 60, #25, 1988 or
 * Strandburg in Computers in Physics, Sep/Oct 1991.
 *
 * This implementation uses the simpler version of the growth
 * algorithm, i.e., if there are no forced vertices, a randomly chosen
 * tile is added to a randomly chosen vertex (no preference for those
 * 108 degree angles).
 *
 * There are two essential differences to the algorithm presented in
 * the literature: First, we do not allow the tiling to enclose an
 * untiled area.  Whenever this is in danger of happening, we just
 * do not add the tile, hoping for a better random choice the next
 * time.  Second, when choosing a vertex randomly, we will take
 * one that lies withing the viewport if available.  If this seems to
 * cause enclosures in the forced rule case, we will allow invisible
 * vertices to be chosen.
 *
 * Tiling is restarted whenever one of the following happens: there
 * are no incomplete vertices within the viewport or the tiling has
 * extended a window's length beyond the edge of the window
 * horizontally or vertically or forced rule choice has failed 100
 * times due to areas about to become enclosed.
 *
 */

#ifdef STANDALONE
# define PROGCLASS                                      "Penrose"
# define HACK_INIT                                      init_penrose
# define HACK_DRAW                                      draw_penrose
# define penrose_opts                           xlockmore_opts
# define DEFAULTS       "*delay:                10000 \n"                       \
                                        "*size:                 40    \n"                       \
                                        "*ncolors:              64   \n"
# include "xlockmore.h"                         /* from the xscreensaver distribution */
#else  /* !STANDALONE */
# include "xlock.h"                                     /* from the xlockmore distribution */
#endif /* !STANDALONE */


/*-
 * Annoyingly the ANSI C library people have reserved all identifiers
 * ending with _t for future use.  Hence we use _c as a suffix for
 * typedefs (c for class, although this is not C++).
 */

#define MINSIZE 5

/*-
 * In theory one could fit 10 tiles to a single vertex.  However, the
 * vertex rules only allow at most seven tiles to meet at a vertex.
 */

#define MAX_TILES_PER_VERTEX 7
#define N_VERTEX_RULES 8
#define ALLOC_NODE( type) ((type *)malloc( sizeof( type)))
#define DEF_AMMANN  "False"

static Bool ammann;

/* How long in seconds should we wait before starting a new tiling? */
static long redo_delay = 3;
static long redo_delay_usec;

static XrmOptionDescRec opts[] =
{
        {"-ammann", ".penrose.ammann", XrmoptionNoArg, (caddr_t) "on"},
        {"+ammann", ".penrose.ammann", XrmoptionNoArg, (caddr_t) "off"},
        {"-redoDelay", ".penrose.redoDelay", XrmoptionSepArg, NULL}
};
static argtype vars[] =
{
        {(caddr_t *) & ammann, "ammann", "Ammann", DEF_AMMANN, t_Bool},
        {(caddr_t *) & redo_delay, "redoDelay", "RedoDelay", "3", t_Int}
};
static OptionStruct desc[] =
{
        {"-/+ammann", "turn on/off Ammann lines"},
        {"-redoDelay", "delay between new tilings"}
};

ModeSpecOpt penrose_opts = { 3, opts, 2, vars, desc };


/*-
 * These are used to specify directions.  They can also be used in bit
 * masks to specify a combination of directions.
 */
#define S_LEFT 1
#define S_RIGHT 2


/*-
 * We do not actually maintain objects corresponding to the tiles since
 * we do not really need them and they would only consume memory and
 * cause additional bookkeeping.  Instead we only have vertices, and
 * each vertex lists the type of each adjacent tile as well as the
 * position of the vertex on the tile (hereafter refered to as
 * "corner").  These positions are numbered in counterclockwise order
 * so that 0 is where two double arrows meet (see one of the
 * articles).  The tile type and vertex number are stored in a single
 * integer (we use char, and even most of it remains unused).
 *
 * The primary use of tile objects would be draw traversal, but we do
 * not currently do redraws at all (we just start over).
 */
#define VT_CORNER_MASK 0x3
#define VT_TYPE_MASK 0x4
#define VT_THIN 0
#define VT_THICK 0x4
#define VT_BITS 3
#define VT_TOTAL_MASK 0x7

typedef unsigned char vertex_type_c;

/*-
 * These allow one to compute the types of the other corners of the tile.  If
 * you are standing at a vertex of type vt looking towards the middle of the
 * tile, VT_LEFT( vt) is the vertex on your left etc.
 */
#define VT_LEFT( vt) ((((vt) - 1) & VT_CORNER_MASK) | (((vt) & VT_TYPE_MASK)))
#define VT_RIGHT( vt) ((((vt) + 1) & VT_CORNER_MASK) | (((vt) & VT_TYPE_MASK)))
#define VT_FAR( vt) ((vt) ^ 2)


/*-
 * Since we do not do redraws, we only store the vertices we need.  These are
 * the ones with still some empty space around them for the growth algorithm
 * to fill.
 *
 * Here we use a doubly chained ring-like structure as vertices often need
 * to be removed or inserted (they are kept in geometrical order 
 * circling the tiled area counterclockwise).  The ring is refered to by
 * a pointer to one more or less random node.  When deleting nodes one
 * must make sure that this pointer continues to refer to a valid
 * node.  A vertex count is maintained to make it easier to pick
 * vertices randomly.
 */
typedef struct forced_node forced_node_c;

typedef struct fringe_node {
        struct fringe_node *prev;
        struct fringe_node *next;
        /* These are numbered counterclockwise.  The gap, if any, lies
           between the last and first tiles.  */
        vertex_type_c tiles[MAX_TILES_PER_VERTEX];
        int         n_tiles;
        /* A bit mask used to indicate vertex rules that are still applicable for
           completing this vertex.  Initialize this to (1 << N_VERTEX_RULES) - 1,
           i.e., all ones, and the rule matching functions will automatically mask
           out rules that no longer match. */
        unsigned char rule_mask;
        /* If the vertex is on the forced vertex list, this points to the
           pointer to the appropriate node in the list.  To remove the
           vertex from the list just set *list_ptr to the next node,
           deallocate and decrement node count. */
        struct forced_node **list_ptr;
        /* Screen coordinates. */
        XPoint      loc;
        /* We also keep track of 5D coordinates to avoid rounding errors.
           These are in units of edge length. */
        int         fived[5];
        /* This is used to quickly check if a vertex is visible. */
        unsigned char off_screen;
} fringe_node_c;

typedef struct {
        fringe_node_c *nodes;
        /* This does not count off-screen nodes. */
        int         n_nodes;
} fringe_c;


/*-
 * The forced vertex pool contains vertices where at least one
 * side of the tiled region can only be extended in one way.  Note
 * that this does not necessarily mean that there would only be one
 * applicable rule.  forced_sides are specified using S_LEFT and
 * S_RIGHT as if looking at the untiled region from the vertex.
 */
struct forced_node {
        fringe_node_c *vertex;
        unsigned    forced_sides;
        struct forced_node *next;
};

typedef struct {
        forced_node_c *first;
        int         n_nodes, n_visible;
} forced_pool_c;


/* This is the data related to the tiling of one screen. */
typedef struct {
        int         width, height;
        XPoint      origin;
        int         edge_length;
        fringe_c    fringe;
        forced_pool_c forced;
        int         done, failures;
        int         thick_color, thin_color;
} tiling_c;

static tiling_c *tilings;       /* = {0} */


/* The tiles are listed in counterclockwise order. */
typedef struct {
        vertex_type_c tiles[MAX_TILES_PER_VERTEX];
        int         n_tiles;
} vertex_rule_c;

static vertex_rule_c vertex_rules[N_VERTEX_RULES] =
{
        {
  {VT_THICK | 2, VT_THICK | 2, VT_THICK | 2, VT_THICK | 2, VT_THICK | 2}, 5},
        {
  {VT_THICK | 0, VT_THICK | 0, VT_THICK | 0, VT_THICK | 0, VT_THICK | 0}, 5},
        {
                {VT_THICK | 0, VT_THICK | 0, VT_THICK | 0, VT_THIN | 0}, 4},
        {
         {VT_THICK | 2, VT_THICK | 2, VT_THIN | 1, VT_THIN | 3, VT_THICK | 2,
          VT_THIN | 1, VT_THIN | 3}, 7},
        {
                {VT_THICK | 2, VT_THICK | 2, VT_THICK | 2, VT_THICK | 2,
                 VT_THIN | 1, VT_THIN | 3}, 6},
        {
                {VT_THICK | 1, VT_THICK | 3, VT_THIN | 2}, 3},
        {
                {VT_THICK | 0, VT_THIN | 0, VT_THIN | 0}, 3},
        {
     {VT_THICK | 2, VT_THIN | 1, VT_THICK | 3, VT_THICK | 1, VT_THIN | 3}, 5}
};


/* Match information returned by match_rules. */
typedef struct {
        int         rule;
        int         pos;
} rule_match_c;


/* Occasionally floating point coordinates are needed. */
typedef struct {
        float       x, y;
} fcoord_c;


/* All angles are measured in multiples of 36 degrees. */
typedef int angle_c;

static angle_c vtype_angles[] =
{4, 1, 4, 1, 2, 3, 2, 3};

#define vtype_angle( v) (vtype_angles[ v])


/* Direction angle of an edge. */
static      angle_c
vertex_dir(ModeInfo * mi, fringe_node_c * vertex, unsigned side)
{
        tiling_c   *tp = &tilings[MI_SCREEN(mi)];
        fringe_node_c *v2 =
        (side == S_LEFT ? vertex->next : vertex->prev);
        register int i;

        for (i = 0; i < 5; i++)
                switch (v2->fived[i] - vertex->fived[i]) {
                        case 1:
                                return 2 * i;
                        case -1:
                                return (2 * i + 5) % 10;
                }
        tp->done = True;
        if (MI_WIN_IS_VERBOSE(mi)) {
                (void) fprintf(stderr,
                   "Weirdness in vertex_dir (this has been reported)\n");
                for (i = 0; i < 5; i++)
                        (void) fprintf(stderr, "v2->fived[%d]=%d, vertex->fived[%d]=%d\n",
                                      i, v2->fived[i], i, vertex->fived[i]);
        }
        MI_PAUSE(mi) = redo_delay_usec;
        return 0;
}


/* Move one step to a given direction. */
static void
add_unit_vec(angle_c dir, int *fived)
{
        static int  dir2i[] =
        {0, 3, 1, 4, 2};

        while (dir < 0)
                dir += 10;
        fived[dir2i[dir % 5]] += (dir % 2 ? -1 : 1);
}


/* For comparing coordinates. */
#define fived_equal( f1, f2) (!memcmp( (f1), (f2), 5 * sizeof( int)))


/*-
 * This computes screen coordinates from 5D representation.  Note that X
 * uses left-handed coordinates (y increases downwards).
 */
static      XPoint
fived_to_loc(int fived[], tiling_c * tp)
{
        static fcoord_c fived_table[5] =
        {
                {.0, .0}};
        float       fifth = 8 * atan(1.) / 5;
        register int i;
        register float r;
        register fcoord_c offset =
        {.0, .0};
        XPoint      pt = tp->origin;

        if (fived_table[0].x == .0)
                for (i = 0; i < 5; i++) {
                        fived_table[i].x = cos(fifth * i);
                        fived_table[i].y = sin(fifth * i);
                }
        for (i = 0; i < 5; i++) {
                r = fived[i] * tp->edge_length;
                offset.x += r * fived_table[i].x;
                offset.y -= r * fived_table[i].y;
        }
        pt.x += (int) (offset.x + .5);
        pt.y += (int) (offset.y + .5);
        return pt;
}


/* Mop up dynamic data for one screen. */
static void
release_screen(tiling_c * tp)
{
        register fringe_node_c *fp1, *fp2;
        register forced_node_c *lp1, *lp2;

        if (tp->fringe.nodes == 0)
                return;
        fp1 = tp->fringe.nodes;
        do {
                fp2 = fp1;
                fp1 = fp1->next;
                (void) free((char *) fp2);
        } while (fp1 != tp->fringe.nodes);
        tp->fringe.nodes = 0;
        for (lp1 = tp->forced.first; lp1 != 0;) {
                lp2 = lp1;
                lp1 = lp1->next;
                (void) free((char *) lp2);
        }
        tp->forced.first = 0;
}


/* Called to init the mode. */
void
init_penrose(ModeInfo * mi)
{
        tiling_c   *tp;
        fringe_node_c *fp;
        int         i, size;

        redo_delay_usec = redo_delay * 1000000;

        if (tilings == NULL) {
                if ((tilings = (tiling_c *) calloc(MI_NUM_SCREENS(mi),
                                                 sizeof (tiling_c))) == NULL)
                        return;
        }
        tp = &tilings[MI_SCREEN(mi)];
        tp->done = False;
        tp->failures = 0;
        tp->width = MI_WIN_WIDTH(mi);
        tp->height = MI_WIN_HEIGHT(mi);
        if (MI_NPIXELS(mi) > 2) {
                tp->thick_color = NRAND(MI_NPIXELS(mi));
                /* Insure good contrast */
                tp->thin_color = (NRAND(2 * MI_NPIXELS(mi) / 3) + tp->thick_color +
                                  MI_NPIXELS(mi) / 6) % MI_NPIXELS(mi);
        }
        size = MI_SIZE(mi);
        if (size < -MINSIZE)
                tp->edge_length = NRAND(MIN(-size, MAX(MINSIZE,
                   MIN(tp->width, tp->height) / 2)) - MINSIZE + 1) + MINSIZE;
        else if (size < MINSIZE) {
                if (!size)
                        tp->edge_length = MAX(MINSIZE, MIN(tp->width, tp->height) / 2);
                else
                        tp->edge_length = MINSIZE;
        } else
                tp->edge_length = MIN(size, MAX(MINSIZE,
                                            MIN(tp->width, tp->height) / 2));
        tp->origin.x = (tp->width / 2 + NRAND(tp->width)) / 2;
        tp->origin.y = (tp->height / 2 + NRAND(tp->height)) / 2;
        tp->fringe.n_nodes = 2;
        if (tp->fringe.nodes != 0)
                release_screen(tp);
        if (tp->fringe.nodes != 0 || tp->forced.first != 0) {
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in init_penrose()\n");
                        (void) fprintf(stderr, "tp->fringe.nodes = 0 && tp->forced.first = 0\n");
                }
                release_screen(tp);     /* Try again */
                tp->done = True;
        }
        tp->forced.n_nodes = tp->forced.n_visible = 0;
        fp = tp->fringe.nodes = ALLOC_NODE(fringe_node_c);
        if (fp == 0) {
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in init_penrose()\n");
                        (void) fprintf(stderr, "fp = 0\n");
                }
                fp = tp->fringe.nodes = ALLOC_NODE(fringe_node_c);
                tp->done = True;
        }
        /* First vertex. */
        fp->rule_mask = (1 << N_VERTEX_RULES) - 1;
        fp->list_ptr = 0;
        fp->prev = fp->next = ALLOC_NODE(fringe_node_c);
        if (fp->next == 0) {
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in init_penrose()\n");
                        (void) fprintf(stderr, "fp->next = 0\n");
                }
                fp->prev = fp->next = ALLOC_NODE(fringe_node_c);
                tp->done = True;
        }
        fp->n_tiles = 0;
        fp->loc = tp->origin;
        fp->off_screen = False;
        for (i = 0; i < 5; i++)
                fp->fived[i] = 0;

        /* Second vertex. */
        *(fp->next) = *fp;
        fp->next->prev = fp->next->next = fp;
        fp = fp->next;
        i = NRAND(5);
        fp->fived[i] = 2 * NRAND(2) - 1;
        fp->loc = fived_to_loc(fp->fived, tp);
        /* That's it!  We have created our first edge. */
}

/*-
 * This attempts to match the configuration of vertex with the vertex
 * rules.   The return value is a total match count.  If matches is
 * non-null, it will be used to store information about the matches
 * and must be large enough to contain it.  To play it absolutely
 * safe, allocate room for MAX_TILES_PER_VERTEX * N_VERTEX_RULES
 * entries when searching all matches.   The rule mask of vertex will
 * be applied and rules masked out will not be searched.  Only strict
 * subsequences match.  If first_only is true, the search stops when
 * the first match is found.  Otherwise all matches will be found and
 * the rule_mask of vertex will be updated, which also happens in
 * single-match mode if no match is found.
 */
static int
match_rules(fringe_node_c * vertex, rule_match_c * matches, int first_only)
{
        /* I will assume that I can fit all the relevant bits in vertex->tiles
           into one unsigned long.  With 3 bits per element and at most 7
           elements this means 21 bits, which should leave plenty of room.
           After packing the bits the rest is just integer comparisons and
           some bit shuffling.  This is essentially Rabin-Karp without
           congruence arithmetic. */
        register int i, j;
        int         hits = 0, good_rules[N_VERTEX_RULES], n_good = 0;
        unsigned long
                    vertex_hash = 0, lower_bits_mask = ~(VT_TOTAL_MASK << VT_BITS * (vertex->n_tiles - 1));
        unsigned    new_rule_mask = 0;

        for (i = 0; i < N_VERTEX_RULES; i++)
                if (vertex->n_tiles >= vertex_rules[i].n_tiles)
                        vertex->rule_mask &= ~(1 << i);
                else if (vertex->rule_mask & 1 << i)
                        good_rules[n_good++] = i;
        for (i = 0; i < vertex->n_tiles; i++)
                vertex_hash |= (unsigned long) vertex->tiles[i] << (VT_BITS * i);

        for (j = 0; j < n_good; j++) {
                unsigned long rule_hash = 0;
                vertex_rule_c *vr = vertex_rules + good_rules[j];

                for (i = 0; i < vertex->n_tiles; i++)
                        rule_hash |= (unsigned long) vr->tiles[i] << (VT_BITS * i);
                if (rule_hash == vertex_hash) {
                        if (matches != 0) {
                                matches[hits].rule = good_rules[j];
                                matches[hits].pos = 0;
                        }
                        hits++;
                        if (first_only)
                                return hits;
                        else
                                new_rule_mask |= 1 << good_rules[j];
                }
                for (i = vr->n_tiles - 1; i > 0; i--) {
                        rule_hash = vr->tiles[i] | (rule_hash & lower_bits_mask) << VT_BITS;
                        if (vertex_hash == rule_hash) {
                                if (matches != 0) {
                                        matches[hits].rule = good_rules[j];
                                        matches[hits].pos = i;
                                }
                                hits++;
                                if (first_only)
                                        return hits;
                                else
                                        new_rule_mask |= 1 << good_rules[j];
                        }
                }
        }
        vertex->rule_mask = new_rule_mask;
        return hits;
}


/*-
 * find_completions finds the possible ways to add a tile to a vertex.
 * The return values is the number of such possibilities.  You must
 * first call match_rules to produce matches and n_matches.  sides
 * specifies which side of the vertex to extend and can be S_LEFT or
 * S_RIGHT.  If results is non-null, it should point to an array large
 * enough to contain the results, which will be stored there.
 * MAX_COMPL elements will always suffice.  If first_only is true we
 * stop as soon as we find one possibility (NOT USED).
 */
#define MAX_COMPL 2

static int
find_completions(fringe_node_c * vertex, rule_match_c * matches, int n_matches,
               unsigned side, vertex_type_c * results /*, int first_only */ )
{
        int         n_res = 0, cont;
        register int i, j;
        vertex_type_c buf[MAX_COMPL];

        if (results == 0)
                results = buf;
        if (n_matches <= 0)
                return 0;
        for (i = 0; i < n_matches; i++) {
                vertex_rule_c *rule = vertex_rules + matches[i].rule;
                int         pos = (matches[i].pos
                   + (side == S_RIGHT ? vertex->n_tiles : rule->n_tiles - 1))
                % rule->n_tiles;
                vertex_type_c vtype = rule->tiles[pos];

                cont = 1;
                for (j = 0; j < n_res; j++)
                        if (vtype == results[j]) {
                                cont = 0;
                                break;
                        }
                if (cont)
                        results[n_res++] = vtype;
        }
        return n_res;
}


/*-
 * Draw a tile on the display.  Vertices must be given in a
 * counterclockwise order.  vtype is the vertex type of v1 (and thus
 * also gives the tile type).
 */
static void
draw_tile(fringe_node_c * v1, fringe_node_c * v2,
          fringe_node_c * v3, fringe_node_c * v4,
          vertex_type_c vtype, ModeInfo * mi)
{
        Display    *display = MI_DISPLAY(mi);
        Window      window = MI_WINDOW(mi);
        GC          gc = MI_GC(mi);
        tiling_c   *tp = &tilings[MI_SCREEN(mi)];
        XPoint      pts[5];
        vertex_type_c corner = vtype & VT_CORNER_MASK;

        if (v1->off_screen && v2->off_screen && v3->off_screen && v4->off_screen)
                return;
        pts[corner] = v1->loc;
        pts[VT_RIGHT(corner)] = v2->loc;
        pts[VT_FAR(corner)] = v3->loc;
        pts[VT_LEFT(corner)] = v4->loc;
        pts[4] = pts[0];
        if (MI_NPIXELS(mi) > 2) {
                if ((vtype & VT_TYPE_MASK) == VT_THICK)
                        XSetForeground(display, gc, MI_PIXEL(mi, tp->thick_color));
                else
                        XSetForeground(display, gc, MI_PIXEL(mi, tp->thin_color));
        } else
                XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
        XFillPolygon(display, window, gc, pts, 4, Convex, CoordModeOrigin);
        XSetForeground(display, gc, MI_WIN_BLACK_PIXEL(mi));
        XDrawLines(display, window, gc, pts, 5, CoordModeOrigin);

        if (ammann) {
                /* Draw some Ammann lines for debugging purposes.  This will probably
                   fail miserably on a b&w display. */

                if ((vtype & VT_TYPE_MASK) == VT_THICK) {
                        static float r = .0;

                        if (r == .0) {
                                float       pi10 = 2 * atan(1.) / 5;

                                r = 1 - sin(pi10) / (2 * sin(3 * pi10));
                        }
                        if (MI_NPIXELS(mi) > 2)
                                XSetForeground(display, gc, MI_PIXEL(mi, tp->thin_color));
                        else {
                                XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
                                XSetLineAttributes(display, gc, 1, LineOnOffDash, CapNotLast, JoinMiter);
                        }
                        XDrawLine(display, window, gc,
                              (int) (r * pts[3].x + (1 - r) * pts[0].x + .5),
                              (int) (r * pts[3].y + (1 - r) * pts[0].y + .5),
                              (int) (r * pts[1].x + (1 - r) * pts[0].x + .5),
                             (int) (r * pts[1].y + (1 - r) * pts[0].y + .5));
                        if (MI_NPIXELS(mi) <= 2)
                                XSetLineAttributes(display, gc, 1, LineSolid, CapNotLast, JoinMiter);
                } else {
                        if (MI_NPIXELS(mi) > 2)
                                XSetForeground(display, gc, MI_PIXEL(mi, tp->thick_color));
                        else {
                                XSetForeground(display, gc, MI_WIN_WHITE_PIXEL(mi));
                                XSetLineAttributes(display, gc, 1, LineOnOffDash, CapNotLast, JoinMiter);
                        }
                        XDrawLine(display, window, gc,
                                  (int) ((pts[3].x + pts[2].x) / 2 + .5),
                                  (int) ((pts[3].y + pts[2].y) / 2 + .5),
                                  (int) ((pts[1].x + pts[2].x) / 2 + .5),
                                  (int) ((pts[1].y + pts[2].y) / 2 + .5));
                        if (MI_NPIXELS(mi) <= 2)
                                XSetLineAttributes(display, gc, 1, LineSolid, CapNotLast, JoinMiter);
                }
        }
}

/*-
 * Update the status of this vertex on the forced vertex queue.  If
 * the vertex has become untileable set tp->done.  This is supposed
 * to detect dislocations -- never call this routine with a completely
 * tiled vertex.
 *
 * Check for untileable vertices in check_vertex and stop tiling as
 * soon as one finds one.  I don't know if it is possible to run out
 * of forced vertices while untileable vertices exist (or will
 * cavities inevitably appear).  If this can happen, add_random_tile
 * might get called with an untileable vertex, causing ( n <= 1).
 * (This is what the tp->done checks for).
 *
 * A MI_PAUSE celebrates the dislocation.
 */
static void
check_vertex(ModeInfo * mi, fringe_node_c * vertex, tiling_c * tp)
{
        rule_match_c hits[MAX_TILES_PER_VERTEX * N_VERTEX_RULES];
        int         n_hits = match_rules(vertex, hits, False);
        unsigned    forced_sides = 0;

        if (vertex->rule_mask == 0) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Dislocation occured!\n");
                }
                MI_PAUSE(mi) = redo_delay_usec; /* Should be able to recover */
        }
        if (1 == find_completions(vertex, hits, n_hits, S_LEFT, 0 /*, False */ ))
                forced_sides |= S_LEFT;
        if (1 == find_completions(vertex, hits, n_hits, S_RIGHT, 0 /*, False */ ))
                forced_sides |= S_RIGHT;
        if (forced_sides == 0) {
                if (vertex->list_ptr != 0) {
                        forced_node_c *node = *vertex->list_ptr;

                        *vertex->list_ptr = node->next;
                        if (node->next != 0)
                                node->next->vertex->list_ptr = vertex->list_ptr;
                        free(node);
                        tp->forced.n_nodes--;
                        if (!vertex->off_screen)
                                tp->forced.n_visible--;
                        vertex->list_ptr = 0;
                }
        } else {
                forced_node_c *node;

                if (vertex->list_ptr == 0) {
                        node = ALLOC_NODE(forced_node_c);
                        node->vertex = vertex;
                        node->next = tp->forced.first;
                        if (tp->forced.first != 0)
                                tp->forced.first->vertex->list_ptr = &(node->next);
                        tp->forced.first = node;
                        vertex->list_ptr = &(tp->forced.first);
                        tp->forced.n_nodes++;
                        if (!vertex->off_screen)
                                tp->forced.n_visible++;
                } else
                        node = *vertex->list_ptr;
                node->forced_sides = forced_sides;
        }
}


/*-
 * Delete this vertex.  If the vertex is a member of the forced vertex queue,
 * also remove that entry.  We assume that the vertex is no longer
 * connected to the fringe.  Note that tp->fringe.nodes must not point to
 * the vertex being deleted.
 */
static void
delete_vertex(ModeInfo * mi, fringe_node_c * vertex, tiling_c * tp)
{
        if (tp->fringe.nodes == vertex) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in delete_penrose()\n");
                        (void) fprintf(stderr, "tp->fringe.nodes == vertex\n");
                }
                MI_PAUSE(mi) = redo_delay_usec;
        }
        if (vertex->list_ptr != 0) {
                forced_node_c *node = *vertex->list_ptr;

                *vertex->list_ptr = node->next;
                if (node->next != 0)
                        node->next->vertex->list_ptr = vertex->list_ptr;
                free(node);
                tp->forced.n_nodes--;
                if (!vertex->off_screen)
                        tp->forced.n_visible--;
        }
        if (!vertex->off_screen)
                tp->fringe.n_nodes--;
        free(vertex);
}


/* Check whether the addition of a tile of type vtype would completely fill *
   the space available at vertex. */
static int
fills_vertex(ModeInfo * mi, vertex_type_c vtype, fringe_node_c * vertex)
{
        return
                (vertex_dir(mi, vertex, S_LEFT) - vertex_dir(mi, vertex, S_RIGHT)
                 - vtype_angle(vtype)) % 10 == 0;
}


/*-
 * If you were to add a tile of type vtype to a specified side of
 * vertex, fringe_changes tells you which other vertices it would
 * attach to.  The addresses of these vertices will be stored in the
 * last three arguments.  Null is stored if the corresponding vertex
 * would need to be allocated.
 *
 * The function also analyzes which vertices would be swallowed by the tiling
 * and thus cut off from the fringe.  The result is returned as a bit pattern.
 */
#define FC_BAG 1                /* Total enclosure.  Should never occur. */
#define FC_NEW_RIGHT 2
#define FC_NEW_FAR 4
#define FC_NEW_LEFT 8
#define FC_NEW_MASK 0xe
#define FC_CUT_THIS 0x10
#define FC_CUT_RIGHT 0x20
#define FC_CUT_FAR 0x40
#define FC_CUT_LEFT 0x80
#define FC_CUT_MASK 0xf0
#define FC_TOTAL_MASK 0xff

static unsigned
fringe_changes(ModeInfo * mi, fringe_node_c * vertex,
               unsigned side, vertex_type_c vtype,
               fringe_node_c ** right, fringe_node_c ** far,
               fringe_node_c ** left)
{
        fringe_node_c *v, *f = NULL;
        unsigned    result = FC_NEW_FAR;        /* We clear this later if necessary. */

        if (far)
                *far = 0;
        if (fills_vertex(mi, vtype, vertex)) {
                result |= FC_CUT_THIS;
        } else if (side == S_LEFT) {
                result |= FC_NEW_RIGHT;
                if (right)
                        *right = 0;
        } else {
                result |= FC_NEW_LEFT;
                if (left)
                        *left = 0;
        }

        if (!(result & FC_NEW_LEFT)) {
                v = vertex->next;
                if (left)
                        *left = v;
                if (fills_vertex(mi, VT_LEFT(vtype), v)) {
                        result = (result & ~FC_NEW_FAR) | FC_CUT_LEFT;
                        f = v->next;
                        if (far)
                                *far = f;
                }
        }
        if (!(result & FC_NEW_RIGHT)) {
                v = vertex->prev;
                if (right)
                        *right = v;
                if (fills_vertex(mi, VT_RIGHT(vtype), v)) {
                        result = (result & ~FC_NEW_FAR) | FC_CUT_RIGHT;
                        f = v->prev;
                        if (far)
                                *far = f;
                }
        }
        if (!(result & FC_NEW_FAR)
            && fills_vertex(mi, VT_FAR(vtype), f)) {
                result |= FC_CUT_FAR;
                result &= (~FC_NEW_LEFT & ~FC_NEW_RIGHT);
                if (right && (result & FC_CUT_LEFT))
                        *right = f->next;
                if (left && (result & FC_CUT_RIGHT))
                        *left = f->prev;
        }
        if (((result & FC_CUT_LEFT) && (result & FC_CUT_RIGHT))
            || ((result & FC_CUT_THIS) && (result & FC_CUT_FAR)))
                result |= FC_BAG;
        return result;
}


/* A couple of lesser helper functions for add_tile. */
static void
add_vtype(fringe_node_c * vertex, unsigned side, vertex_type_c vtype)
{
        if (side == S_RIGHT)
                vertex->tiles[vertex->n_tiles++] = vtype;
        else {
                register int i;

                for (i = vertex->n_tiles; i > 0; i--)
                        vertex->tiles[i] = vertex->tiles[i - 1];
                vertex->tiles[0] = vtype;
                vertex->n_tiles++;
        }
}

static fringe_node_c *
alloc_vertex(ModeInfo * mi, angle_c dir, fringe_node_c * from, tiling_c * tp)
{
        fringe_node_c *v = ALLOC_NODE(fringe_node_c);

        if (v == 0) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in alloc_vertex()\n");
                        (void) fprintf(stderr, "v = 0\n");
                }
                MI_PAUSE(mi) = redo_delay_usec;
        }
        *v = *from;
        add_unit_vec(dir, v->fived);
        v->loc = fived_to_loc(v->fived, tp);
        if (v->loc.x < 0 || v->loc.y < 0
            || v->loc.x >= tp->width || v->loc.y >= tp->height) {
                v->off_screen = True;
                if (v->loc.x < -tp->width || v->loc.y < -tp->height
                  || v->loc.x >= 2 * tp->width || v->loc.y >= 2 * tp->height)
                        tp->done = True;
        } else {
                v->off_screen = False;
                tp->fringe.n_nodes++;
        }
        v->n_tiles = 0;
        v->rule_mask = (1 << N_VERTEX_RULES) - 1;
        v->list_ptr = 0;
        return v;
}

/* 
 * Add a tile described by vtype to the side of vertex.  This must be
 * allowed by the rules -- we do not check it here.  New vertices are
 * allocated as necessary.  The fringe and the forced vertex pool are updated.
 * The new tile is drawn on the display.
 *
 * One thing we do check here is whether the new tile causes an untiled
 * area to become enclosed by the tiling.  If this would happen, the tile
 * is not added.  The return value is true iff a tile was added.
 */
static int
add_tile(ModeInfo * mi,
         fringe_node_c * vertex, unsigned side, vertex_type_c vtype)
{
        tiling_c   *tp = &tilings[MI_SCREEN(mi)];

        fringe_node_c
                * left = 0,
                *right = 0,
                *far = 0,
                *node;
        unsigned    fc = fringe_changes(mi, vertex, side, vtype, &right, &far, &left);

        vertex_type_c
                ltype = VT_LEFT(vtype),
                rtype = VT_RIGHT(vtype),
                ftype = VT_FAR(vtype);

        /* By our conventions vertex->next lies to the left of vertex and
           vertex->prev to the right. */

        /* This should never occur. */
        if (fc & FC_BAG) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in add_tile()\n");
                        (void) fprintf(stderr, "fc = %d, FC_BAG = %d\n", fc, FC_BAG);
                }
        }
        if (side == S_LEFT) {
                if (right == 0)
                        right = alloc_vertex(mi,
                                             vertex_dir(mi, vertex, S_LEFT) - vtype_angle(vtype), vertex, tp);
                if (far == 0)
                        far = alloc_vertex(mi,
                                           vertex_dir(mi, left, S_RIGHT) + vtype_angle(ltype), left, tp);
        } else {
                if (left == 0)
                        left = alloc_vertex(mi,
                                            vertex_dir(mi, vertex, S_RIGHT) + vtype_angle(vtype), vertex, tp);
                if (far == 0)
                        far = alloc_vertex(mi,
                                           vertex_dir(mi, right, S_LEFT) - vtype_angle(rtype), right, tp);
        }

        /* Having allocated the new vertices, but before joining them with
           the rest of the fringe, check if vertices with same coordinates
           already exist.  If any such are found, give up. */
        node = tp->fringe.nodes;
        do {
                if (((fc & FC_NEW_LEFT) && fived_equal(node->fived, left->fived))
                    || ((fc & FC_NEW_RIGHT) && fived_equal(node->fived, right->fived))
                    || ((fc & FC_NEW_FAR) && fived_equal(node->fived, far->fived))) {
                        /* Better luck next time. */
                        if (fc & FC_NEW_LEFT)
                                delete_vertex(mi, left, tp);
                        if (fc & FC_NEW_RIGHT)
                                delete_vertex(mi, right, tp);
                        if (fc & FC_NEW_FAR)
                                delete_vertex(mi, far, tp);
                        return False;
                }
                node = node->next;
        } while (node != tp->fringe.nodes);

        /* Rechain. */
        if (!(fc & FC_CUT_THIS))
                if (side == S_LEFT) {
                        vertex->next = right;
                        right->prev = vertex;
                } else {
                        vertex->prev = left;
                        left->next = vertex;
                }
        if (!(fc & FC_CUT_FAR)) {
                if (!(fc & FC_CUT_LEFT)) {
                        far->next = left;
                        left->prev = far;
                }
                if (!(fc & FC_CUT_RIGHT)) {
                        far->prev = right;
                        right->next = far;
                }
        }
        draw_tile(vertex, right, far, left, vtype, mi);

        /* Delete vertices that are no longer on the fringe.  Check the others. */
        if (fc & FC_CUT_THIS) {
                tp->fringe.nodes = far;
                delete_vertex(mi, vertex, tp);
        } else {
                add_vtype(vertex, side, vtype);
                check_vertex(mi, vertex, tp);
                tp->fringe.nodes = vertex;
        }
        if (fc & FC_CUT_FAR)
                delete_vertex(mi, far, tp);
        else {
                add_vtype(far, fc & FC_CUT_RIGHT ? S_LEFT : S_RIGHT, ftype);
                check_vertex(mi, far, tp);
        }
        if (fc & FC_CUT_LEFT)
                delete_vertex(mi, left, tp);
        else {
                add_vtype(left, fc & FC_CUT_FAR ? S_LEFT : S_RIGHT, ltype);
                check_vertex(mi, left, tp);
        }
        if (fc & FC_CUT_RIGHT)
                delete_vertex(mi, right, tp);
        else {
                add_vtype(right, fc & FC_CUT_FAR ? S_RIGHT : S_LEFT, rtype);
                check_vertex(mi, right, tp);
        }
        return True;
}


/*-
 * Add a forced tile to a given forced vertex.  Basically an easy job,
 * since we know what to add.  But it might fail if adding the tile
 * would cause some untiled area to become enclosed.  There is also another
 * more exotic culprit: we might have a dislocation.  Fortunately, they
 * are very rare (the PRL article reported that perfect tilings of over
 * 2^50 tiles had been generated).  There is a version of the algorithm
 * that doesn't produce dislocations, but it's a lot hairier than the
 * simpler version I used.
 */
static int
add_forced_tile(ModeInfo * mi, forced_node_c * node)
{
        tiling_c   *tp = &tilings[MI_SCREEN(mi)];
        unsigned    side;
        vertex_type_c vtype;
        rule_match_c hits[MAX_TILES_PER_VERTEX * N_VERTEX_RULES];
        int         n;

        if (node->forced_sides == (S_LEFT | S_RIGHT))
                side = NRAND(2) ? S_LEFT : S_RIGHT;
        else
                side = node->forced_sides;
        n = match_rules(node->vertex, hits, True);
        n = find_completions(node->vertex, hits, n, side, &vtype /*, True */ );
        if (n <= 0) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in add_forced_tile()\n");
                        (void) fprintf(stderr, "n = %d\n", n);
                }
        }
        return add_tile(mi, node->vertex, side, vtype);
}


/*-
 * Whether the addition of a tile of vtype on the given side of vertex
 * would conform to the rules.  The efficient way to do this would be
 * to add the new tile and then use the same type of search as in
 * match_rules.  However, this function is not a performance
 * bottleneck (only needed for random tile additions, which are
 * relatively infrequent), so I will settle for a simpler implementation.
 */
static int
legal_move(fringe_node_c * vertex, unsigned side, vertex_type_c vtype)
{
        rule_match_c hits[MAX_TILES_PER_VERTEX * N_VERTEX_RULES];
        vertex_type_c legal_vt[MAX_COMPL];
        int         n_hits, n_legal, i;

        n_hits = match_rules(vertex, hits, False);
        n_legal = find_completions(vertex, hits, n_hits, side, legal_vt /*, False */ );
        for (i = 0; i < n_legal; i++)
                if (legal_vt[i] == vtype)
                        return True;
        return False;
}


/*-
 * Add a randomly chosen tile to a given vertex.  This requires more checking
 * as we must make sure the new tile conforms to the vertex rules at every
 * vertex it touches. */
static void
add_random_tile(fringe_node_c * vertex, ModeInfo * mi)
{
        fringe_node_c *right, *left, *far;
        int         i, j, n, n_hits, n_good;
        unsigned    side, fc, no_good, s;
        vertex_type_c vtypes[MAX_COMPL];
        rule_match_c hits[MAX_TILES_PER_VERTEX * N_VERTEX_RULES];
        tiling_c   *tp = &tilings[MI_SCREEN(mi)];

        if (MI_NPIXELS(mi) > 2) {
                tp->thick_color = NRAND(MI_NPIXELS(mi));
                /* Insure good contrast */
                tp->thin_color = (NRAND(2 * MI_NPIXELS(mi) / 3) + tp->thick_color +
                                  MI_NPIXELS(mi) / 6) % MI_NPIXELS(mi);
        } else
                tp->thick_color = tp->thin_color = MI_WIN_WHITE_PIXEL(mi);
        n_hits = match_rules(vertex, hits, False);
        side = NRAND(2) ? S_LEFT : S_RIGHT;
        n = find_completions(vertex, hits, n_hits, side, vtypes /*, False */ );
        /* One answer would mean a forced tile. */
        if (n <= 0) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in add_random_tile()\n");
                        (void) fprintf(stderr, "n = %d\n", n);
                }
        }
        no_good = 0;
        n_good = n;
        for (i = 0; i < n; i++) {
                fc = fringe_changes(mi, vertex, side, vtypes[i], &right, &far, &left);
                if (fc & FC_BAG) {
                        tp->done = True;
                        if (MI_WIN_IS_VERBOSE(mi)) {
                                (void) fprintf(stderr, "Weirdness in add_random_tile()\n");
                                (void) fprintf(stderr, "fc = %d, FC_BAG = %d\n", fc, FC_BAG);
                        }
                }
                if (right) {
                        s = (((fc & FC_CUT_FAR) && (fc & FC_CUT_LEFT)) ? S_RIGHT : S_LEFT);
                        if (!legal_move(right, s, VT_RIGHT(vtypes[i]))) {
                                no_good |= (1 << i);
                                n_good--;
                                continue;
                        }
                }
                if (left) {
                        s = (((fc & FC_CUT_FAR) && (fc & FC_CUT_RIGHT)) ? S_LEFT : S_RIGHT);
                        if (!legal_move(left, s, VT_LEFT(vtypes[i]))) {
                                no_good |= (1 << i);
                                n_good--;
                                continue;
                        }
                }
                if (far) {
                        s = ((fc & FC_CUT_LEFT) ? S_RIGHT : S_LEFT);
                        if (!legal_move(far, s, VT_FAR(vtypes[i]))) {
                                no_good |= (1 << i);
                                n_good--;
                        }
                }
        }
        if (n_good <= 0) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in add_random_tile()\n");
                        (void) fprintf(stderr, "n_good = %d\n", n_good);
                }
        }
        n = NRAND(n_good);
        for (i = j = 0; i <= n; i++, j++)
                while (no_good & (1 << j))
                        j++;

        i = add_tile(mi, vertex, side, vtypes[j - 1]);
        if (!i) {
                tp->done = True;
                if (MI_WIN_IS_VERBOSE(mi)) {
                        (void) fprintf(stderr, "Weirdness in add_random_tile()\n");
                        (void) fprintf(stderr, "i = %d\n", i);
                }
        }
}

/* One step of the growth algorithm. */
void
draw_penrose(ModeInfo * mi)
{
        tiling_c   *tp = &tilings[MI_SCREEN(mi)];
        int         i = 0, n;
        forced_node_c *p = tp->forced.first;

        if (tp->done || tp->failures >= 100) {
                init_penrose(mi);
                return;
        }
        /* Check for the initial "2-gon". */
        if (tp->fringe.nodes->prev == tp->fringe.nodes->next) {
                vertex_type_c vtype = VT_TOTAL_MASK & LRAND();

                XClearWindow(MI_DISPLAY(mi), MI_WINDOW(mi));
                (void) add_tile(mi, tp->fringe.nodes, S_LEFT, vtype);
                return;
        }
        /* No visible nodes left. */
        if (tp->fringe.n_nodes == 0) {
                tp->done = True;
                MI_PAUSE(mi) = redo_delay_usec; /* Just finished drawing */
                return;
        }
        if (tp->forced.n_visible > 0 && tp->failures < 10) {
                n = NRAND(tp->forced.n_visible);
                for (;;) {
                        while (p->vertex->off_screen)
                                p = p->next;
                        if (i++ < n)
                                p = p->next;
                        else
                                break;
                }
        } else if (tp->forced.n_nodes > 0) {
                n = NRAND(tp->forced.n_nodes);
                while (i++ < n)
                        p = p->next;
        } else {
                fringe_node_c *p = tp->fringe.nodes;

                n = NRAND(tp->fringe.n_nodes);
                i = 0;
                for (; i <= n; i++)
                        do {
                                p = p->next;
                        } while (p->off_screen);
                add_random_tile(p, mi);
                tp->failures = 0;
                return;
        }
        if (add_forced_tile(mi, p))
                tp->failures = 0;
        else
                tp->failures++;
}


/* Total clean-up. */
void
release_penrose(ModeInfo * mi)
{
        if (tilings != NULL) {
                int         screen;

                for (screen = 0; screen < MI_NUM_SCREENS(mi); screen++) {
                        tiling_c   *tp = &tilings[screen];

                        release_screen(tp);
                }
                (void) free((void *) tilings);
                tilings = NULL;
        }
}