/* juggle, Copyright (c) 1996-2009 Tim Auckland <tda10.geo@yahoo.com>
 * and Jamie Zawinski <jwz@jwz.org>
 *
 * 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.
 *
 * NOTE: this program was originally called "juggle" and was 2D Xlib.
 *       There was another program called "juggler3d" that was OpenGL.
 *       In 2009, jwz converted "juggle" to OpenGL and renamed
 *       "juggle" to "juggler3d".  The old "juggler3d" hack is gone.
 *
 * Revision History
 * 09-Aug-2009: jwz: converted from Xlib to OpenGL.
 * 13-Dec-2004: [TDA] Use -cycles and -count in a rational manner.
 *              Add -rings, -bballs.  Add -describe.  Finally made
 *              live pattern updates possible.  Add refill_juggle(),
 *              change_juggle() and reshape_juggle().  Make
 *              init_juggle() non-destructive.  Reorder erase/draw
 *              operations.  Update xscreensaver xml and manpage.
 * 15-Nov-2004: [TDA] Fix all memory leaks.
 * 12-Nov-2004: [TDA] Add -torches and another new trail
 *              implementation, so that different objects can have
 *              different length trails.
 * 11-Nov-2004: [TDA] Clap when all the balls are in the air.
 * 10-Nov-2004: [TDA] Display pattern name converted to hight
 *              notation.
 * 31-Oct-2004: [TDA] Add -clubs and new trail implementation.
 * 02-Sep-2003: Non-real time to see what is happening without a
 *              strobe effect for slow machines.
 * 01-Nov-2000: Allocation checks
 * 1996: Written
 */

/*-
 * TODO
 * Implement the anonymously promised -uni option.
 */


/*
 * Notes on Adam Chalcraft Juggling Notation (used by permission)
 * a-> Adam's notation  s-> Site swap (Cambridge) notation
 *
 * To define a map from a-notation to s-notation ("site-swap"), both
 * of which look like doubly infinite sequences of natural numbers. In
 * s-notation, there is a restriction on what is allowed, namely for
 * the sequence s_n, the associated function f(n)=n+s_n must be a
 * bijection. In a-notation, there is no restriction.
 *
 * To go from a-notation to s-notation, you start by mapping each a_n
 * to a permutation of N, the natural numbers.
 *
 * 0 -> the identity
 * 1 -> (10) [i.e. f(1)=0, f(0)=1]
 * 2 -> (210) [i.e. f(2)=1, f(1)=0, f(0)=2]
 * 3 -> (3210) [i.e. f(3)=2, f(2)=1, f(1)=0, f(0)=3]
 * etc.
 *
 * Then for each n, you look at how long 0 takes to get back to 0
 * again and you call this t_n. If a_n=0, for example, then since the
 * identity leaves 0 alone, it gets back to 0 in 1 step, so t_n=1. If
 * a_n=1, then f(0)=1. Now any further a_n=0 leave 1 alone, but the
 * next a_n>0 sends 1 back to 0. Hence t_n is 2 + the number of 0's
 * following the 1. Finally, set s_n = t_n - 1.
 *
 * To give some examples, it helps to have a notation for cyclic
 * sequences. By (123), for example, I mean ...123123123123... . Now
 * under the a-notation -> s-notation mapping we have some familiar
 * examples:
 *
 * (0)->(0), (1)->(1), (2)->(2) etc.
 * (21)->(31), (31)->(51), (41)->(71) etc.
 * (10)->(20), (20)->(40), (30)->(60) etc.
 * (331)->(441), (312)->(612), (303)->(504), (321)->(531)
 * (43)->(53), (434)->(534), (433)->(633)
 * (552)->(672)
 *
 * In general, the number of balls is the *average* of the s-notation,
 * and the *maximum* of the a-notation. Another theorem is that the
 * minimum values in the a-notation and the s-notation and equal, and
 * preserved in the same positions.
 *
 * The usefulness of a-notation is the fact that there are no
 * restrictions on what is allowed. This makes random juggle
 * generation much easier. It also makes enumeration very
 * easy. Another handy feature is computing changes.  Suppose you can
 * do (5) and want a neat change up to (771) in s-notation [Mike Day
 * actually needed this example!]. Write them both in a-notation,
 * which gives (5) and (551). Now concatenate them (in general, there
 * may be more than one way to do this, but not in this example), to
 * get
 *
 * ...55555555551551551551551...
 *
 * Now convert back to s-notation, to get
 *
 * ...55555566771771771771771...
 *
 * So the answer is to do two 6 throws and then go straight into
 * (771).  Coming back down of course,
 *
 * ...5515515515515515555555555...
 *
 * converts to
 *
 * ...7717717717716615555555555...
 *
 * so the answer is to do a single 661 and then drop straight down to
 * (5).
 *
 * [The number of balls in the generated pattern occasionally changes.
 * In order to decrease the number of balls I had to introduce a new
 * symbol into the Adam notation, [*] which means 'lose the current
 * ball'.]
 */

/* This code uses so many linked lists it's worth having a built-in
 * leak-checker */
#undef MEMTEST

# define DEFAULTS	"*delay:	10000	\n" \
			"*count:	200	\n" \
			"*cycles:	1000	\n" \
			"*ncolors:	32	\n" \
                        "*titleFont:    sans-serif bold 18\n" \
			"*showFPS:	False	\n" \
			"*wireframe:	False	\n" \

# define release_juggle 0

#include "xlockmore.h"
#include "sphere.h"
#include "tube.h"
#include "rotator.h"
#include "gltrackball.h"
#include "texfont.h"
#include <ctype.h>

#ifdef USE_GL /* whole file */

#define DEF_PATTERN "random" /* All patterns */
#define DEF_TAIL "1" /* No trace */
#ifdef UNI
/* Maybe a ROLA BOLA would be at a better angle for viewing */
#define DEF_UNI "False" /* No unicycle */ /* Not implemented yet */
#endif
#define DEF_REAL "True"
#define DEF_DESCRIBE "True"

#define DEF_BALLS "True" /* Use Balls */
#define DEF_CLUBS "True" /* Use Clubs */
#define DEF_TORCHES "True" /* Use Torches */
#define DEF_KNIVES "True" /* Use Knives */
#define DEF_RINGS "True" /* Use Rings */
#define DEF_BBALLS "True" /* Use Bowling Balls */

static char *pattern;
static int tail;
#ifdef UNI
static Bool uni;
#endif
static Bool real;
static Bool describe;
static Bool balls;
static Bool clubs;
static Bool torches;
static Bool knives;
static Bool rings;
static Bool bballs;
static char *only;

static XrmOptionDescRec opts[] = {
  {"-pattern",  ".juggle.pattern",  XrmoptionSepArg, NULL  },
  {"-tail",     ".juggle.tail",     XrmoptionSepArg, NULL  },
#ifdef UNI
  {"-uni",      ".juggle.uni",      XrmoptionNoArg,  "on"  },
  {"+uni",      ".juggle.uni",      XrmoptionNoArg,  "off" },
#endif
  {"-real",     ".juggle.real",     XrmoptionNoArg,  "on"  },
  {"+real",     ".juggle.real",     XrmoptionNoArg,  "off" },
  {"-describe", ".juggle.describe", XrmoptionNoArg,  "on"  },
  {"+describe", ".juggle.describe", XrmoptionNoArg,  "off" },
  {"-balls",    ".juggle.balls",    XrmoptionNoArg,  "on"  },
  {"+balls",    ".juggle.balls",    XrmoptionNoArg,  "off" },
  {"-clubs",    ".juggle.clubs",    XrmoptionNoArg,  "on"  },
  {"+clubs",    ".juggle.clubs",    XrmoptionNoArg,  "off" },
  {"-torches",  ".juggle.torches",  XrmoptionNoArg,  "on"  },
  {"+torches",  ".juggle.torches",  XrmoptionNoArg,  "off" },
  {"-knives",   ".juggle.knives",   XrmoptionNoArg,  "on"  },
  {"+knives",   ".juggle.knives",   XrmoptionNoArg,  "off" },
  {"-rings",    ".juggle.rings",    XrmoptionNoArg,  "on"  },
  {"+rings",    ".juggle.rings",    XrmoptionNoArg,  "off" },
  {"-bballs",   ".juggle.bballs",   XrmoptionNoArg,  "on"  },
  {"+bballs",   ".juggle.bballs",   XrmoptionNoArg,  "off" },
  {"-only",     ".juggle.only",     XrmoptionSepArg, NULL  },
};

static argtype vars[] = {
  { &pattern,  "pattern",  "Pattern",  DEF_PATTERN,  t_String },
  { &tail,     "tail",     "Tail",     DEF_TAIL,     t_Int    },
#ifdef UNI
  { &uni,      "uni",      "Uni",      DEF_UNI,      t_Bool   },
#endif
  { &real,     "real",     "Real",     DEF_REAL,     t_Bool   },
  { &describe, "describe", "Describe", DEF_DESCRIBE, t_Bool   },
  { &balls,    "balls",    "Clubs",    DEF_BALLS,    t_Bool   },
  { &clubs,    "clubs",    "Clubs",    DEF_CLUBS,    t_Bool   },
  { &torches,  "torches",  "Torches",  DEF_TORCHES,  t_Bool   },
  { &knives,   "knives",   "Knives",   DEF_KNIVES,   t_Bool   },
  { &rings,    "rings",    "Rings",    DEF_RINGS,    t_Bool   },
  { &bballs,   "bballs",   "BBalls",   DEF_BBALLS,   t_Bool   },
  { &only,     "only",     "BBalls",   " ",          t_String },
};

static OptionStruct desc[] =
{
  { "-pattern string", "Cambridge Juggling Pattern" },
  { "-tail num",       "Trace Juggling Patterns" },
#ifdef UNI
  { "-/+uni",          "Unicycle" },
#endif
  { "-/+real",         "Real-time" },
  { "-/+describe",     "turn on/off pattern descriptions." },
  { "-/+balls",        "turn on/off Balls." },
  { "-/+clubs",        "turn on/off Clubs." },
  { "-/+torches",      "turn on/off Flaming Torches." },
  { "-/+knives",       "turn on/off Knives." },
  { "-/+rings",        "turn on/off Rings." },
  { "-/+bballs",       "turn on/off Bowling Balls." },
  { "-only",           "Turn off all objects but the named one." },
};

ENTRYPOINT ModeSpecOpt juggle_opts =
 {countof(opts), opts, countof(vars), vars, desc};


/* Note: All "lengths" are scaled by sp->scale = MI_HEIGHT/480.  All
   "thicknesses" are scaled by sqrt(sp->scale) so that they are
   proportionally thicker for smaller windows.  Objects spinning out
   of the plane (such as clubs) fake perspective by compressing their
   horizontal coordinates by PERSPEC  */

/* Figure */
#define ARMLENGTH 50
#define ARMWIDTH ((int) (8.0 * sqrt(sp->scale)))
#define POSE 10
#define BALLRADIUS ARMWIDTH

/* build all the models assuming a 480px high scene */
#define SCENE_HEIGHT 480
#define SCENE_WIDTH ((int)(SCENE_HEIGHT*(MI_WIDTH(mi)/(float)MI_HEIGHT(mi))))

/*#define PERSPEC  0.4*/

/* macros */
#define GRAVITY(h, t) 4*(double)(h)/((t)*(t))

/* Timing based on count.  Units are milliseconds.  Juggles per second
       is: 2000 / THROW_CATCH_INTERVAL + CATCH_THROW_INTERVAL */

#define THROW_CATCH_INTERVAL (sp->count)
#define THROW_NULL_INTERVAL  (sp->count * 0.5)
#define CATCH_THROW_INTERVAL (sp->count * 0.2)

/********************************************************************
 * Trace Definitions                                                *
 *                                                                  *
 * These record rendering data so that a drawn object can be erased *
 * later.  Each object has its own Trace list.                      *
 *                                                                  *
 ********************************************************************/

typedef struct {double x, y; } DXPoint;
typedef struct trace *TracePtr;
typedef struct trace {
  TracePtr next, prev;
  double x, y;
  double angle;
  int divisions;
  DXPoint dlast;
#ifdef MEMTEST
  char pad[1024];
#endif
} Trace;

/*******************************************************************
 * Object Definitions                                              *
 *                                                                 *
 * These describe the various types of Object that can be juggled  *
 *                                                                 *
 *******************************************************************/
typedef int (DrawProc)(ModeInfo*, unsigned long, Trace *);

static DrawProc show_ball, show_europeanclub, show_torch, show_knife;
static DrawProc show_ring, show_bball;

typedef enum {BALL, CLUB, TORCH, KNIFE, RING, BBALLS,
              NUM_OBJECT_TYPES} ObjType;

#define OBJMIXPROB 20   /* inverse of the chances of using an odd
						   object in the pattern */

static const GLfloat body_color_1[4] = { 0.9, 0.7, 0.5, 1 };
static const GLfloat body_color_2[4] = { 0.6, 0.4, 0.2, 1 };

static const struct {
  DrawProc *draw;                           /* Object Rendering function */
  int       handle;                         /* Length of object's handle */
  int       mintrail;                            /* Minimum trail length */
  double    cor;      /* Coefficient of Restitution.  perfect bounce = 1 */
  double    weight;          /* Heavier objects don't get thrown as high */
} ObjectDefs[] = {
  { /* Ball */
	show_ball,
	0,
	1,
	0.9,
	1.0,
  },
  { /* Club */
	show_europeanclub,
	15,
	1,
	0.55, /* Clubs don't bounce too well */
	1.0,
  },
  { /* Torch */
	show_torch,
	15,
	20, /* Torches need flames */
	0, /* Torches don't bounce -- fire risk! */
	1.0,
  },
  { /* Knife */
	show_knife,
	15,
	1,
	0, /* Knives don't bounce */
	1.0,
  },
  { /* Ring */
	show_ring,
	15,
	1,
	0.8,
	1.0,
  },
  { /* Bowling Ball */
	show_bball,
	0,
	1,
	0.2,
	5.0,
  },
};

/**************************
 * Trajectory definitions *
 **************************/

typedef enum {HEIGHT, ADAM} Notation;
typedef enum {Empty, Full, Ball} Throwable;
typedef enum {LEFT, RIGHT} Hand;
typedef enum {THROW, CATCH} Action;
typedef enum {HAND, ELBOW, SHOULDER} Joint;
typedef enum {ATCH, THRATCH, ACTION, LINKEDACTION,
			  PTHRATCH, BPREDICTOR, PREDICTOR} TrajectoryStatus;
typedef struct {double a, b, c, d; } Spline;
typedef DXPoint Arm[3];


/* Object is an arbitrary object being juggled.  Each Trajectory
 * references an Object ("count" tracks this), and each Object is also
 * linked into a global Objects list.  Objects may include a Trace
 * list for tracking erasures. */
typedef struct object *ObjectPtr;
typedef struct object {
  ObjectPtr next, prev;

  ObjType type;
  int     color;
  int     count; /* reference count */
  Bool    active; /* Object is in use */

  Trace  *trace;
  int     tracelen;
  int     tail;
#ifdef MEMTEST
  char pad[1024];
#endif
} Object;

/* Trajectory is a segment of juggling action.  A list of Trajectories
 * defines the juggling performance.  The Trajectory list goes through
 * multiple processing steps to convert it from basic juggling
 * notation into rendering data. */

typedef struct trajectory *TrajectoryPtr;
typedef struct trajectory {
  TrajectoryPtr prev, next;  /* for building list */
  TrajectoryStatus status;

  /* Throw */
  char posn;
  int height;
  int adam;
  char *pattern;
  char *name;

  /* Action */
  Hand hand;
  Action action;

  /* LinkedAction */
  int color;
  Object *object;
  int divisions;
  double angle, spin;
  TrajectoryPtr balllink;
  TrajectoryPtr handlink;

  /* PThratch */
  double cx; /* Moving juggler */
  double x, y; /* current position */
  double dx, dy; /* initial velocity */

  /* Predictor */
  Throwable type;
  unsigned long start, finish;
  Spline xp, yp;

#ifdef MEMTEST
  char pad[1024];
#endif
} Trajectory;


/*******************
 * Pattern Library *
 *******************/

typedef struct {
  const char * pattern;
  const char * name;
} patternstruct;

/* List of popular patterns, in any order */
/* Patterns should be given in Adam notation so the generator can
   concatenate them safely.  Null descriptions are ok.  Height
   notation will be displayed automatically.  */
/* Can't const this because it is qsorted.  This *should* be reentrant,
   I think... */
static /*const*/ patternstruct portfolio[] = {
  {"[+2 1]", /* +3 1 */ "Typical 2 ball juggler"},
  {"[2 0]", /* 4 0 */ "2 in 1 hand"},
  {"[2 0 1]", /* 5 0 1 */},
  {"[+2 0 +2 0 0]" /* +5 0 +5 0 0 */},
  {"[+2 0 1 2 2]", /* +4 0 1 2 3 */},
  {"[2 0 1 1]", /* 6 0 1 1 */},

  {"[3]", /* 3 */ "3 cascade"},
  {"[+3]", /* +3 */ "reverse 3 cascade"},
  {"[=3]", /* =3 */ "cascade 3 under arm"},
  {"[&3]", /* &3 */ "cascade 3 catching under arm"},
  {"[_3]", /* _3 */ "bouncing 3 cascade"},
  {"[+3 x3 =3]", /* +3 x3 =3 */ "Mill's mess"},
  {"[3 2 1]", /* 5 3 1" */},
  {"[3 3 1]", /* 4 4 1" */},
  {"[3 1 2]", /* 6 1 2 */ "See-saw"},
  {"[=3 3 1 2]", /* =4 5 1 2 */},
  {"[=3 2 2 3 1 2]", /* =6 2 2 5 1 2 */ "=4 5 1 2 stretched"},
  {"[+3 3 1 3]", /* +4 4 1 3 */ "anemic shower box"},
  {"[3 3 1]", /* 4 4 1 */},
  {"[+3 2 3]", /* +4 2 3 */},
  {"[+3 1]", /* +5 1 */ "3 shower"},
  {"[_3 1]", /* _5 1 */ "bouncing 3 shower"},
  {"[3 0 3 0 3]", /* 5 0 5 0 5 */ "shake 3 out of 5"},
  {"[3 3 3 0 0]", /* 5 5 5 0 0 */ "flash 3 out of 5"},
  {"[3 3 0]", /* 4 5 0 */ "complete waste of a 5 ball juggler"},
  {"[3 3 3 0 0 0 0]", /* 7 7 7 0 0 0 0 */ "3 flash"},
  {"[+3 0 +3 0 +3 0 0]", /* +7 0 +7 0 +7 0 0 */},
  {"[3 2 2 0 3 2 0 2 3 0 2 2 0]", /* 7 3 3 0 7 3 0 3 7 0 3 3 0 */},
  {"[3 0 2 0]", /* 8 0 4 0 */},
  {"[_3 2 1]", /* _5 3 1 */},
  {"[_3 0 1]", /* _8 0 1 */},
  {"[1 _3 1 _3 0 1 _3 0]", /* 1 _7 1 _7 0 1 _7 0 */},
  {"[_3 2 1 _3 1 2 1]", /* _6 3 1 _6 1 3 1 */},

  {"[4]", /* 4 */ "4 cascade"},
  {"[+4 3]", /* +5 3 */ "4 ball half shower"},
  {"[4 4 2]", /* 5 5 2 */},
  {"[+4 4 4 +4]", /* +4 4 4 +4 */ "4 columns"},
  {"[+4 3 +4]", /* +5 3 +4 */},
  {"[4 3 4 4]", /* 5 3 4 4 */},
  {"[4 3 3 4]", /* 6 3 3 4 */},
  {"[4 3 2 4", /* 6 4 2 4 */},
  {"[+4 1]", /* +7 1 */ "4 shower"},
  {"[4 4 4 4 0]", /* 5 5 5 5 0 */ "learning 5"},
  {"[+4 x4 =4]", /* +4 x4 =4 */ "Mill's mess for 4"},
  {"[+4 2 1 3]", /* +9 3 1 3 */},
  {"[4 4 1 4 1 4]", /* 6 6 1 5 1 5, by Allen Knutson */},
  {"[_4 _4 _4 1 _4 1]", /* _5 _6 _6 1 _5 1 */},
  {"[_4 3 3]", /* _6 3 3 */},
  {"[_4 3 1]", /* _7 4 1 */},
  {"[_4 2 1]", /* _8 3 1 */},
  {"[_4 3 3 3 0]", /* _8 4 4 4 0 */},
  {"[_4 1 3 1]", /* _9 1 5 1 */},
  {"[_4 1 3 1 2]", /* _10 1 6 1 2 */},

  {"[5]", /* 5 */ "5 cascade"},
  {"[_5 _5 _5 _5 _5 5 5 5 5 5]", /* _5 _5 _5 _5 _5 5 5 5 5 5 */},
  {"[+5 x5 =5]", /* +5 x5 =5 */ "Mill's mess for 5"},
  {"[5 4 4]", /* 7 4 4 */},
  {"[_5 4 4]", /* _7 4 4 */},
  {"[1 2 3 4 5 5 5 5 5]", /* 1 2 3 4 5 6 7 8 9 */ "5 ramp"},
  {"[5 4 5 3 1]", /* 8 5 7 4 1, by Allen Knutson */},
  {"[_5 4 1 +4]", /* _9 5 1 5 */},
  {"[_5 4 +4 +4]", /* _8 4 +4 +4 */},
  {"[_5 4 4 4 1]", /* _9 5 5 5 1 */},
  {"[_5 4 4 5 1]",},
  {"[_5 4 4 +4 4 0]", /*_10 5 5 +5 5 0 */},

  {"[6]", /* 6 */ "6 cascade"},
  {"[+6 5]", /* +7 5 */},
  {"[6 4]", /* 8 4 */},
  {"[+6 3]", /* +9 3 */},
  {"[6 5 4 4]", /* 9 7 4 4 */},
  {"[+6 5 5 5]", /* +9 5 5 5 */},
  {"[6 0 6]", /* 9 0 9 */},
  {"[_6 0 _6]", /* _9 0 _9 */},

  {"[_7]", /* _7 */ "bouncing 7 cascade"},
  {"[7]", /* 7 */ "7 cascade"},
  {"[7 6 6 6 6]", /* 11 6 6 6 6 */ "Gatto's High Throw"},

};



typedef struct { int start; int number; } PatternIndex;

struct patternindex {
  int minballs;
  int maxballs;
  PatternIndex index[countof(portfolio)];
};


/* Jugglestruct: per-screen global data.  The master Object
 * and Trajectory lists are anchored here. */
typedef struct {
  GLXContext *glx_context;
  rotator *rot;
  trackball_state *trackball;
  Bool button_down_p;

  double        scale;
  double        cx;
  double        Gr;
  Trajectory   *head;
  Arm           arm[2][2];
  char         *pattern;
  int           count;
  int           num_balls;
  time_t        begintime; /* should make 'time' usable for at least 48 days
							on a 32-bit machine */
  unsigned long time; /* millisecond timer*/
  ObjType       objtypes;
  Object       *objects;
  struct patternindex patternindex;
  texture_font_data *font_data;
} jugglestruct;

static jugglestruct *juggles = (jugglestruct *) NULL;

/*******************
 * list management *
 *******************/

#define DUP_OBJECT(n, t) { \
  (n)->object = (t)->object; \
  if((n)->object != NULL) (n)->object->count++; \
}

/* t must point to an existing element.  t must not be an
   expression ending ->next or ->prev */
#define REMOVE(t) { \
  (t)->next->prev = (t)->prev; \
  (t)->prev->next = (t)->next; \
  free(t); \
}

/* t receives element to be created and added to the list.  ot must
   point to an existing element or be identical to t to start a new
   list. Applicable to Trajectories, Objects and Traces. */
#define ADD_ELEMENT(type, t, ot) \
  if (((t) = (type*)calloc(1,sizeof(type))) != NULL) { \
    (t)->next = (ot)->next; \
    (t)->prev = (ot); \
    (ot)->next = (t); \
    (t)->next->prev = (t); \
  }

static void
object_destroy(Object* o)
{
  if(o->trace != NULL) {
	while(o->trace->next != o->trace) {
	  Trace *s = o->trace->next;
	  REMOVE(s); /* Don't eliminate 's' */
	}
	free(o->trace);
  }
  REMOVE(o);
}

static void
trajectory_destroy(Trajectory *t) {
  if(t->name != NULL) free(t->name);
  if(t->pattern != NULL) free(t->pattern);
  /* Reduce object link count and call destructor if necessary */
  if(t->object != NULL && --t->object->count < 1 && t->object->tracelen == 0) {
	object_destroy(t->object);
  }
  REMOVE(t); /* Unlink and free */
}

ENTRYPOINT void
free_juggle(ModeInfo *mi) {
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];

  if (!sp->glx_context) return;
  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *sp->glx_context);

  if (sp->trackball) gltrackball_free (sp->trackball);
  if (sp->rot) free_rotator (sp->rot);
  if (sp->font_data) free_texture_font (sp->font_data);

  if (sp->head != NULL) {
	while (sp->head->next != sp->head) {
	  trajectory_destroy(sp->head->next);
	}
	free(sp->head);
	sp->head = (Trajectory *) NULL;
  }
  if(sp->objects != NULL) {
	while (sp->objects->next != sp->objects) {
	  object_destroy(sp->objects->next);
	}
	free(sp->objects);
	sp->objects = (Object*)NULL;
  }
  if(sp->pattern != NULL) {
	free(sp->pattern);
	sp->pattern = NULL;
  }
}

static Bool
add_throw(ModeInfo *mi, char type, int h, Notation n, const char* name)
{
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  Trajectory *t;

  ADD_ELEMENT(Trajectory, t, sp->head->prev);
  if(t == NULL){ /* Out of Memory */
	return False;
  }
  t->object = NULL;
  if(name != NULL)
	t->name = strdup(name);
  t->posn = type;
  if (n == ADAM) {
	t->adam = h;
	t->height = 0;
	t->status = ATCH;
  } else {
	t->height = h;
	t->status = THRATCH;
  }
  return True;
}

/* add a Thratch to the performance */
static Bool
program(ModeInfo *mi, const char *patn, const char *name, int cycles)
{
  const char *p;
  int w, h, i, seen;
  Notation notation;
  char type;

  if (MI_IS_VERBOSE(mi)) {
	(void) fprintf(stderr, "juggle[%d]: Programmed: %s x %d\n",
				   MI_SCREEN(mi), (name == NULL) ? patn : name, cycles);
  }

  for(w=i=0; i < cycles; i++, w++) { /* repeat until at least "cycles" throws
										have been programmed */
	/* title is the pattern name to be supplied to the first throw of
	   a sequence.  If no name if given, use an empty title so that
	   the sequences are still delimited. */
	const char *title = (name != NULL)? name : "";
	type=' ';
	h = 0;
	seen = 0;
	notation = HEIGHT;
	for(p=patn; *p; p++) {
	  if (*p >= '0' && *p <='9') {
		seen = 1;
		h = 10*h + (*p - '0');
	  } else {
		Notation nn = notation;
		switch (*p) {
		case '[':            /* begin Adam notation */
		  notation = ADAM;
		  break;
		case '-':            /* Inside throw */
		  type = ' ';
		  break;
		case '+':            /* Outside throw */
		case '=':            /* Cross throw */
		case '&':            /* Cross catch */
		case 'x':            /* Cross throw and catch */
		case '_':            /* Bounce */
		case 'k':            /* Kickup */
		  type = *p;
		  break;
		case '*':            /* Lose ball */
		  seen = 1;
		  h = -1;
		  /* fall through */
		case ']':             /* end Adam notation */
		  nn = HEIGHT;
		  /* fall through */
		case ' ':
		  if (seen) {
			i++;
			if (!add_throw(mi, type, h, notation, title))
				return False;
			title = NULL;
			type=' ';
			h = 0;
			seen = 0;
		  }
		  notation = nn;
		  break;
		default:
		  if(w == 0) { /* Only warn on first pass */
			(void) fprintf(stderr,
						   "juggle[%d]: Unexpected pattern instruction: '%c'\n",
						   MI_SCREEN(mi), *p);
		  }
		  break;
		}
	  }
	}
	if (seen) { /* end of sequence */
	  if (!add_throw(mi, type, h, notation, title))
		return False;
	  title = NULL;
	}
  }
  return True;
}

/*
 ~~~~\~~~~~\~~~
 \\~\\~\~\\\~~~
 \\~\\\\~\\\~\~
 \\\\\\\\\\\~\\

[ 3 3 1 3 4 2 3 1 3 3 4 0 2 1 ]

4 4 1 3 12 2 4 1 4 4 13 0 3 1

*/
#define BOUNCEOVER 10
#define KICKMIN 7
#define THROWMAX 20

/* Convert Adam notation into heights */
static void
adam(jugglestruct *sp)
{
  Trajectory *t, *p;
  for(t = sp->head->next; t != sp->head; t = t->next) {
	if (t->status == ATCH) {
	  int a = t->adam;
	  t->height = 0;
	  for(p = t->next; a > 0; p = p->next) {
		if(p == sp->head) {
		  t->height = -9; /* Indicate end of processing for name() */
		  return;
		}
		if (p->status != ATCH || p->adam < 0 || p->adam>= a) {
		  a--;
		}
		t->height++;
	  }
	  if(t->height > BOUNCEOVER && t->posn == ' '){
		t->posn = '_'; /* high defaults can be bounced */
	  } else if(t->height < 3 && t->posn == '_') {
		t->posn = ' '; /* Can't bounce short throws. */
	  }
	  if(t->height < KICKMIN && t->posn == 'k'){
		t->posn = ' '; /* Can't kick short throws */
	  }
	  if(t->height > THROWMAX){
		t->posn = 'k'; /* Use kicks for ridiculously high throws */
	  }
	  t->status = THRATCH;
	}
  }
}

/* Discover converted heights and update the sequence title */
static void
name(jugglestruct *sp)
{
  Trajectory *t, *p;
  char buffer[BUFSIZ];
  char *b;
  for(t = sp->head->next; t != sp->head; t = t->next) {
	if (t->status == THRATCH && t->name != NULL) {
	  b = buffer;
	  for(p = t; p == t || p->name == NULL; p = p->next) {
		if(p == sp->head || p->height < 0) { /* end of reliable data */
		  return;
		}
		if(p->posn == ' ') {
		  b += sprintf(b, " %d", p->height);
		} else {
		  b += sprintf(b, " %c%d", p->posn, p->height);
		}
		if(b - buffer > 500) break; /* otherwise this could eventually
									   overflow.  It'll be too big to
									   display anyway. */
	  }
	  if(*t->name != 0) {
		(void) sprintf(b, ", %s", t->name);
	  }
	  free(t->name); /* Don't need name any more, it's been converted
						to pattern */
	  t->name = NULL;
	  if(t->pattern != NULL) free(t->pattern);
	  t->pattern = strdup(buffer);
	}
  }
}

/* Split Thratch notation into explicit throws and catches.
   Usually Catch follows Throw in same hand, but take care of special
   cases. */

/* ..n1.. -> .. LTn RT1 LC RC .. */
/* ..nm.. -> .. LTn LC RTm RC .. */

static Bool
part(ModeInfo *mi)
{
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  Trajectory *t, *nt, *p;
  Hand hand = (LRAND() & 1) ? RIGHT : LEFT;

  for (t = sp->head->next; t != sp->head; t = t->next) {
	if (t->status > THRATCH) {
	  hand = t->hand;
	} else if (t->status == THRATCH) {
	  char posn = '=';

	  /* plausibility check */
	  if (t->height <= 2 && t->posn == '_') {
		t->posn = ' '; /* no short bounces */
	  }
	  if (t->height <= 1 && (t->posn == '=' || t->posn == '&')) {
		t->posn = ' '; /* 1's need close catches */
	  }

	  switch (t->posn) {
		  /*         throw          catch    */
	  case ' ': posn = '-'; t->posn = '+'; break;
	  case '+': posn = '+'; t->posn = '-'; break;
	  case '=': posn = '='; t->posn = '+'; break;
	  case '&': posn = '+'; t->posn = '='; break;
	  case 'x': posn = '='; t->posn = '='; break;
	  case '_': posn = '_'; t->posn = '-'; break;
	  case 'k': posn = 'k'; t->posn = 'k'; break;
	  default:
		(void) fprintf(stderr, "juggle: unexpected posn %c\n", t->posn);
		break;
	  }
	  hand = (Hand) ((hand + 1) % 2);
	  t->status = ACTION;
	  t->hand = hand;
	  p = t->prev;

	  if (t->height == 1 && p != sp->head) {
		p = p->prev; /* '1's are thrown earlier than usual */
	  }



	  t->action = CATCH;
	  ADD_ELEMENT(Trajectory, nt, p);
	  if(nt == NULL){
		return False;
	  }
	  nt->object = NULL;
	  nt->status = ACTION;
	  nt->action = THROW;
	  nt->height = t->height;
	  nt->hand = hand;
	  nt->posn = posn;

	}
  }
  return True;
}

static ObjType
choose_object(void) {
  ObjType o;
  for (;;) {
	o = (ObjType)NRAND((ObjType)NUM_OBJECT_TYPES);
	if(balls && o == BALL) break;
	if(clubs && o == CLUB) break;
	if(torches && o == TORCH) break;
	if(knives && o == KNIFE) break;
	if(rings && o == RING) break;
	if(bballs && o == BBALLS) break;
  }
  return o;
}

/* Connnect up throws and catches to figure out which ball goes where.
   Do the same with the juggler's hands. */

static void
lob(ModeInfo *mi)
{
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  Trajectory *t, *p;
  int h;
  for (t = sp->head->next; t != sp->head; t = t->next) {
	if (t->status == ACTION) {
	  if (t->action == THROW) {
		if (t->type == Empty) {
		  /* Create new Object */
		  ADD_ELEMENT(Object, t->object, sp->objects);
		  t->object->count = 1;
		  t->object->tracelen = 0;
		  t->object->active = False;
		  /* Initialise object's circular trace list */
		  ADD_ELEMENT(Trace, t->object->trace, t->object->trace);

		  if (MI_NPIXELS(mi) > 2) {
			t->object->color = 1 + NRAND(MI_NPIXELS(mi) - 2);
		  } else {
#ifdef STANDALONE
			t->object->color = 1;
#else
			t->object->color = 0;
#endif
		  }

		  /* Small chance of picking a random object instead of the
			 current theme. */
		  if(NRAND(OBJMIXPROB) == 0) {
			t->object->type = choose_object();
		  } else {
			t->object->type = sp->objtypes;
		  }

		  /* Check to see if we need trails for this object */
		  if(tail < ObjectDefs[t->object->type].mintrail) {
			t->object->tail = ObjectDefs[t->object->type].mintrail;
		  } else {
			t->object->tail = tail;
		  }
		}

		/* Balls can change divisions at each throw */
                /* no, that looks stupid. -jwz */
                if (t->divisions < 1)
                  t->divisions = 2 * (NRAND(2) + 1);

		/* search forward for next catch in this hand */
		for (p = t->next; t->handlink == NULL; p = p->next) {
		  if(p->status < ACTION || p == sp->head) return;
		  if (p->action == CATCH) {
			if (t->handlink == NULL && p->hand == t->hand) {
			  t->handlink = p;
			}
		  }
		}

		if (t->height > 0) {
		  h = t->height - 1;

		  /* search forward for next ball catch */
		  for (p = t->next; t->balllink == NULL; p = p->next) {
			if(p->status < ACTION || p == sp->head) {
			  t->handlink = NULL;
			  return;
			}
			if (p->action == CATCH) {
			  if (t->balllink == NULL && --h < 1) { /* caught */
				t->balllink = p; /* complete trajectory */
# if 0
				if (p->type == Full) {
				  (void) fprintf(stderr, "juggle[%d]: Dropped %d\n",
						  MI_SCREEN(mi), t->object->color);
				}
#endif
				p->type = Full;
				DUP_OBJECT(p, t); /* accept catch */
				p->angle = t->angle;
				p->divisions = t->divisions;
			  }
			}
		  }
		}
		t->type = Empty; /* thrown */
	  } else if (t->action == CATCH) {
		/* search forward for next throw from this hand */
		for (p = t->next; t->handlink == NULL; p = p->next) {
		  if(p->status < ACTION || p == sp->head) return;
		  if (p->action == THROW && p->hand == t->hand) {
			p->type = t->type; /* pass ball */
			DUP_OBJECT(p, t); /* pass object */
			p->divisions = t->divisions;
			t->handlink = p;
		  }
		}
	  }
	  t->status = LINKEDACTION;
	}
  }
}

/* Clap when both hands are empty */
static void
clap(jugglestruct *sp)
{
  Trajectory *t, *p;
  for (t = sp->head->next; t != sp->head; t = t->next) {
	if (t->status == LINKEDACTION &&
		t->action == CATCH &&
		t->type == Empty &&
		t->handlink != NULL &&
		t->handlink->height == 0) { /* Completely idle hand */

	  for (p = t->next; p != sp->head; p = p->next) {
		if (p->status == LINKEDACTION &&
			p->action == CATCH &&
			p->hand != t->hand) { /* Next catch other hand */
		  if(p->type == Empty &&
			 p->handlink != NULL &&
			 p->handlink->height == 0) { /* Also completely idle */

			t->handlink->posn = '^'; /* Move first hand's empty throw */
			p->posn = '^';           /* to meet second hand's empty
										catch */

		  }
		  break; /* Only need first catch */
		}
	  }
	}
  }
}

#define CUBIC(s, t) ((((s).a * (t) + (s).b) * (t) + (s).c) * (t) + (s).d)

/* Compute single spline from x0 with velocity dx0 at time t0 to x1
   with velocity dx1 at time t1 */
static Spline
makeSpline(double x0, double dx0, int t0, double x1, double dx1, int t1)
{
  Spline s;
  double a, b, c, d;
  double x10;
  double t10;

  x10 = x1 - x0;
  t10 = t1 - t0;
  a = ((dx0 + dx1)*t10 - 2*x10) / (t10*t10*t10);
  b = (3*x10 - (2*dx0 + dx1)*t10) / (t10*t10);
  c = dx0;
  d = x0;
  s.a = a;
  s.b = -3*a*t0 + b;
  s.c = (3*a*t0 - 2*b)*t0 + c;
  s.d = ((-a*t0 + b)*t0 - c)*t0 +d;
  return s;
}

/* Compute a pair of splines.  s1 goes from x0 vith velocity dx0 at
   time t0 to x1 at time t1.  s2 goes from x1 at time t1 to x2 with
   velocity dx2 at time t2.  The arrival and departure velocities at
   x1, t1 must be the same. */
static double
makeSplinePair(Spline *s1, Spline *s2,
			   double x0, double dx0, int t0,
			   double x1,             int t1,
			   double x2, double dx2, int t2)
{
  double x10, x21, t21, t10, t20, dx1;
  x10 = x1 - x0;
  x21 = x2 - x1;
  t21 = t2 - t1;
  t10 = t1 - t0;
  t20 = t2 - t0;
  dx1 = (3*x10*t21*t21 + 3*x21*t10*t10 + 3*dx0*t10*t21*t21
		 - dx2*t10*t10*t21 - 4*dx0*t10*t21*t21) /
	(2*t10*t21*t20);
  *s1 = makeSpline(x0, dx0, t0, x1, dx1, t1);
  *s2 = makeSpline(x1, dx1, t1, x2, dx2, t2);
  return dx1;
}

/* Compute a Ballistic path in a pair of degenerate splines.  sx goes
   from x at time t at constant velocity dx.  sy goes from y at time t
   with velocity dy and constant acceleration g. */
static void
makeParabola(Trajectory *n,
			 double x, double dx, double y, double dy, double g)
{
  double t = (double)n->start;
  n->xp.a = 0;
  n->xp.b = 0;
  n->xp.c = dx;
  n->xp.d = -dx*t + x;
  n->yp.a = 0;
  n->yp.b = g/2;
  n->yp.c = -g*t + dy;
  n->yp.d = g/2*t*t - dy*t + y;
}




#define SX 25 /* Shoulder Width */

/* Convert hand position symbols into actual time/space coordinates */
static void
positions(jugglestruct *sp)
{
  Trajectory *t;
  unsigned long now = sp->time; /* Make sure we're not lost in the past */
  for (t = sp->head->next; t != sp->head; t = t->next) {
	if (t->status >= PTHRATCH) {
	  now = t->start;
	} else if (t->status == ACTION || t->status == LINKEDACTION) {
	  /* Allow ACTIONs to be annotated, but we won't mark them ready
		 for the next stage */

	  double xo = 0, yo;
	  double sx = SX;
	  double pose = SX/2;

	  /* time */
	  if (t->action == CATCH) { /* Throw-to-catch */
		if (t->type == Empty) {
		  now += (int) THROW_NULL_INTERVAL; /* failed catch is short */
		} else {     /* successful catch */
		  now += (int)(THROW_CATCH_INTERVAL);
		}
	  } else { /* Catch-to-throw */
		if(t->object != NULL) {
		  now += (int) (CATCH_THROW_INTERVAL *
						ObjectDefs[t->object->type].weight);
		} else {
		  now += (int) (CATCH_THROW_INTERVAL);
		}
	  }

	  if(t->start == 0)
		t->start = now;
	  else /* Concatenated performances may need clock resync */
		now = t->start;

	  t->cx = 0;

	  /* space */
	  yo = 90;

	  /* Add room for the handle */
	  if(t->action == CATCH && t->object != NULL)
		yo -= ObjectDefs[t->object->type].handle;

	  switch (t->posn) {
	  case '-': xo = sx - pose; break;
	  case '_':
	  case 'k':
	  case '+': xo = sx + pose; break;
	  case '~':
	  case '=': xo = - sx - pose; yo += pose; break;
	  case '^': xo = 0; yo += pose*2; break; /* clap */
	  default:
		(void) fprintf(stderr, "juggle: unexpected posn %c\n", t->posn);
		break;
	  }

#ifdef _2DSpinsDontWorkIn3D
	  t->angle = (((t->hand == LEFT) ^
				   (t->posn == '+' || t->posn == '_' || t->posn == 'k' ))?
					-1 : 1) * M_PI/2;
#else
         t->angle = -M_PI/2;
#endif

	  t->x = t->cx + ((t->hand == LEFT) ? xo : -xo);
	  t->y = yo;

	  /* Only mark complete if it was already linked */
	  if(t->status == LINKEDACTION) {
		t->status = PTHRATCH;
	  }
	}
  }
}


/* Private physics functions */

/* Compute the spin-rate for a trajectory.  Different types of throw
   (eg, regular thows, bounces, kicks, etc) have different spin
   requirements.

   type = type of object
   h = trajectory of throwing hand (throws), or next throwing hand (catches)
   old = earlier spin to consider
   dt = time span of this trajectory
   height = height of ball throw or 0 if based on old spin
   turns = full club turns required during this operation
   togo = partial club turns required to match hands
*/
static double
spinrate(ObjType type, Trajectory *h, double old, double dt,
		 int height, int turns, double togo)
{
#ifdef _2DSpinsDontWorkIn3D
  const int dir = (h->hand == LEFT) ^ (h->posn == '+')? -1 : 1;
#else
  const int dir = 1;
#endif

  if(ObjectDefs[type].handle != 0) { /* Clubs */
	return (dir * turns * 2 * M_PI + togo) / dt;
  } else if(height == 0) { /* Balls already spinning */
	return old/2;
  } else { /* Balls */
	return dir * NRAND(height*10)/20/ObjectDefs[type].weight * 2 * M_PI / dt;
  }
}


/* compute the angle at the end of a spinning trajectory */
static double
end_spin(Trajectory *t)
{
  return t->angle + t->spin * (t->finish - t->start);
}

/* Sets the initial angle of the catch following hand movement t to
   the final angle of the throw n.  Also sets the angle of the
   subsequent throw to the same angle plus half a turn. */
static void
match_spins_on_catch(Trajectory *t, Trajectory *n)
{
  if(ObjectDefs[t->balllink->object->type].handle == 0) {
	t->balllink->angle = end_spin(n);
	if(t->balllink->handlink != NULL) {
#ifdef _2DSpinsDontWorkIn3D
	  t->balllink->handlink->angle = t->balllink->angle + M_PI;
#else
         t->balllink->handlink->angle = t->balllink->angle;
#endif
	}
  }
}

static double
find_bounce(jugglestruct *sp,
			double yo, double yf, double yc, double tc, double cor)
{
  double tb, i, dy = 0;
  const double e = 1; /* permissible error in yc */

  /*
	tb = time to bounce
	yt = height at catch time after one bounce
	one or three roots according to timing
	find one by interval bisection
  */
  tb = tc;
  for(i = tc / 2; i > 0.0001; i/=2){
	double dt, yt;
	if(tb == 0){
	  (void) fprintf(stderr, "juggle: bounce div by zero!\n");
	  break;
	}
	dy = (yf - yo)/tb + sp->Gr/2*tb;
	dt = tc - tb;
	yt = -cor*dy*dt + sp->Gr/2*dt*dt + yf;
	if(yt < yc + e){
	  tb-=i;
	}else if(yt > yc - e){
	  tb+=i;
	}else{
	  break;
	}
  }
  if(dy*THROW_CATCH_INTERVAL < -200) { /* bounce too hard */
	tb = -1;
  }
  return tb;
}

static Trajectory*
new_predictor(const Trajectory *t, int start, int finish, double angle)
{
  Trajectory *n;
  ADD_ELEMENT(Trajectory, n, t->prev);
  if(n == NULL){
	return NULL;
  }
  DUP_OBJECT(n, t);
  n->divisions = t->divisions;
  n->type = Ball;
  n->status = PREDICTOR;

  n->start = start;
  n->finish = finish;
  n->angle = angle;
  return n;
}

/* Turn abstract timings into physically appropriate object trajectories. */
static Bool
projectile(jugglestruct *sp)
{
  Trajectory *t;
  const int yf = 0; /* Floor height */

  for (t = sp->head->next; t != sp->head; t = t->next) {
	if (t->status != PTHRATCH || t->action != THROW) {
	  continue;
	} else if (t->balllink == NULL) { /* Zero Throw */
	  t->status = BPREDICTOR;
	} else if (t->balllink->handlink == NULL) { /* Incomplete */
	  return True;
	} else if(t->balllink == t->handlink) {
	  /* '2' height - hold on to ball.  Don't need to consider
		 flourishes, 'hands' will do that automatically anyway */

	  t->type = Full;
	  /* Zero spin to avoid wrist injuries */
	  t->spin = 0;
	  match_spins_on_catch(t, t);
	  t->dx = t->dy = 0;
	  t->status = BPREDICTOR;
	  continue;
	} else {
	  if (t->posn == '_') { /* Bounce once */

		const int tb = t->start +
		  find_bounce(sp, t->y, (double) yf, t->balllink->y,
					  (double) (t->balllink->start - t->start),
					  ObjectDefs[t->object->type].cor);

		if(tb < t->start) { /* bounce too hard */
		  t->posn = '+'; /* Use regular throw */
		} else {
		  Trajectory *n; /* First (throw) trajectory. */
		  double dt; /* Time span of a trajectory */
		  double dy; /* Distance span of a follow-on trajectory.
						First trajectory uses t->dy */
		  /* dx is constant across both trajectories */
		  t->dx = (t->balllink->x - t->x) / (t->balllink->start - t->start);

		  { /* ball follows parabola down */
			n = new_predictor(t, t->start, tb, t->angle);
			if(n == NULL) return False;
			dt = n->finish - n->start;
			/* Ball rate 4, no flight or matching club turns */
			n->spin = spinrate(t->object->type, t, 0.0, dt, 4, 0, 0.0);
			t->dy = (yf - t->y)/dt - sp->Gr/2*dt;
			makeParabola(n, t->x, t->dx, t->y, t->dy, sp->Gr);
		  }

		  { /* ball follows parabola up */
			Trajectory *m = new_predictor(t, n->finish, t->balllink->start,
										  end_spin(n));
			if(m == NULL) return False;
			dt = m->finish - m->start;
			/* Use previous ball rate, no flight club turns */
			m->spin = spinrate(t->object->type, t, n->spin, dt, 0, 0,
							   t->balllink->angle - m->angle);
			match_spins_on_catch(t, m);
			dy = (t->balllink->y - yf)/dt - sp->Gr/2 * dt;
			makeParabola(m, t->balllink->x - t->dx * dt,
						 t->dx, (double) yf, dy, sp->Gr);
		  }

		  t->status = BPREDICTOR;
		  continue;
		}
	  } else if (t->posn == 'k') { /* Drop & Kick */
		Trajectory *n; /* First (drop) trajectory. */
		Trajectory *o; /* Second (rest) trajectory */
		Trajectory *m; /* Third (kick) trajectory */
		const int td = t->start + 2*THROW_CATCH_INTERVAL; /* Drop time */
		const int tk = t->balllink->start - 5*THROW_CATCH_INTERVAL; /* Kick */
		double dt, dy;

		{ /* Fall to ground */
		  n = new_predictor(t, t->start, td, t->angle);
		  if(n == NULL) return False;
		  dt = n->finish - n->start;
		  /* Ball spin rate 4, no flight club turns */
		  n->spin = spinrate(t->object->type, t, 0.0, dt, 4, 0,
							 t->balllink->angle - n->angle);
		  t->dx = (t->balllink->x - t->x) / dt;
		  t->dy = (yf - t->y)/dt - sp->Gr/2*dt;
		  makeParabola(n, t->x, t->dx, t->y, t->dy, sp->Gr);
		}

		{ /* Rest on ground */
		  o = new_predictor(t, n->finish, tk, end_spin(n));
		  if(o == NULL) return False;
		  o->spin = 0;
		  makeParabola(o, t->balllink->x, 0.0, (double) yf, 0.0, 0.0);
		}

		/* Kick up */
		{
		  m = new_predictor(t, o->finish, t->balllink->start, end_spin(o));
		  if(m == NULL) return False;
		  dt = m->finish - m->start;
		  /* Match receiving hand, ball rate 4, one flight club turn */
		  m->spin = spinrate(t->object->type, t->balllink->handlink, 0.0, dt,
							 4, 1, t->balllink->angle - m->angle);
		  match_spins_on_catch(t, m);
		  dy = (t->balllink->y - yf)/dt - sp->Gr/2 * dt;
		  makeParabola(m, t->balllink->x, 0.0, (double) yf, dy, sp->Gr);
		}

		t->status = BPREDICTOR;
		continue;
	  }

	  /* Regular flight, no bounce */
	  { /* ball follows parabola */
		double dt;
		Trajectory *n = new_predictor(t, t->start,
									  t->balllink->start, t->angle);
		if(n == NULL) return False;
		dt = t->balllink->start - t->start;
		/* Regular spin */
		n->spin = spinrate(t->object->type, t, 0.0, dt, t->height, t->height/2,
						   t->balllink->angle - n->angle);
		match_spins_on_catch(t, n);
		t->dx = (t->balllink->x - t->x) / dt;
		t->dy = (t->balllink->y - t->y) / dt - sp->Gr/2 * dt;
		makeParabola(n, t->x, t->dx, t->y, t->dy, sp->Gr);
	  }

	  t->status = BPREDICTOR;
	}
  }
  return True;
}

/* Turn abstract hand motions into cubic splines. */
static void
hands(jugglestruct *sp)
{
  Trajectory *t, *u, *v;

  for (t = sp->head->next; t != sp->head; t = t->next) {
	/* no throw => no velocity */
	if (t->status != BPREDICTOR) {
	  continue;
	}

	u = t->handlink;
	if (u == NULL) { /* no next catch */
	  continue;
	}
	v = u->handlink;
	if (v == NULL) { /* no next throw */
	  continue;
	}

	/* double spline takes hand from throw, thru catch, to
	   next throw */

	t->finish = u->start;
	t->status = PREDICTOR;

	u->finish = v->start;
	u->status = PREDICTOR;


	/* FIXME: These adjustments leave a small glitch when alternating
	   balls and clubs.  Just hope no-one notices.  :-) */

	/* make sure empty hand spin matches the thrown object in case it
	   had a handle */

	t->spin = ((t->hand == LEFT)? -1 : 1 ) *
	  fabs((u->angle - t->angle)/(u->start - t->start));

	u->spin = ((v->hand == LEFT) ^ (v->posn == '+')? -1 : 1 ) *
	  fabs((v->angle - u->angle)/(v->start - u->start));

	(void) makeSplinePair(&t->xp, &u->xp,
						  t->x, t->dx, t->start,
						  u->x, u->start,
						  v->x, v->dx, v->start);
	(void) makeSplinePair(&t->yp, &u->yp,
						  t->y, t->dy, t->start,
						  u->y, u->start,
						  v->y, v->dy, v->start);

	t->status = PREDICTOR;
  }
}

/* Given target x, y find_elbow puts hand at target if possible,
 * otherwise makes hand point to the target */
static void
find_elbow(int armlength, DXPoint *h, DXPoint *e, DXPoint *p, DXPoint *s,
		   int z)
{
  double r, h2, t;
  double x = p->x - s->x;
  double y = p->y - s->y;
  h2 = x*x + y*y + z*z;
  if (h2 > 4 * armlength * armlength) {
	t = armlength/sqrt(h2);
	e->x = t*x + s->x;
	e->y = t*y + s->y;
	h->x = 2 * t * x + s->x;
	h->y = 2 * t * y + s->y;
  } else {
	r = sqrt((double)(x*x + z*z));
	t = sqrt(4 * armlength * armlength / h2 - 1);
	e->x = x*(1 + y*t/r)/2 + s->x;
	e->y = (y - r*t)/2 + s->y;
	h->x = x + s->x;
	h->y = y + s->y;
  }
}


/* NOTE: returned x, y adjusted for arm reach */
static void
reach_arm(ModeInfo * mi, Hand side, DXPoint *p)
{
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  DXPoint h, e;
  find_elbow(40, &h, &e, p, &sp->arm[1][side][SHOULDER], 25);
  *p = sp->arm[1][side][HAND] = h;
  sp->arm[1][side][ELBOW] = e;
}

#if DEBUG
/* dumps a human-readable rendition of the current state of the juggle
   pipeline to stderr for debugging */
static void
dump(jugglestruct *sp)
{
  Trajectory *t;
  for (t = sp->head->next; t != sp->head; t = t->next) {
	switch (t->status) {
	case ATCH:
	  (void) fprintf(stderr, "%p a %c%d\n", (void*)t, t->posn, t->adam);
	  break;
	case THRATCH:
	  (void) fprintf(stderr, "%p T %c%d %s\n", (void*)t, t->posn, t->height,
					 t->pattern == NULL?"":t->pattern);
	  break;
	case ACTION:
	  if (t->action == CATCH)
	    (void) fprintf(stderr, "%p A %c%cC\n",
					 (void*)t, t->posn,
					 t->hand ? 'R' : 'L');
	  else
	    (void) fprintf(stderr, "%p A %c%c%c%d\n",
					 (void*)t, t->posn,
					 t->hand ? 'R' : 'L',
					 (t->action == THROW)?'T':'N',
					 t->height);
	  break;
	case LINKEDACTION:
	  (void) fprintf(stderr, "%p L %c%c%c%d %d %p %p\n",
					 (void*)t, t->posn,
					 t->hand?'R':'L',
					 (t->action == THROW)?'T':(t->action == CATCH?'C':'N'),
					 t->height, t->object == NULL?0:t->object->color,
					 (void*)t->handlink, (void*)t->balllink);
	  break;
	case PTHRATCH:
	  (void) fprintf(stderr, "%p O %c%c%c%d %d %2d %6lu %6lu\n",
					 (void*)t, t->posn,
					 t->hand?'R':'L',
					 (t->action == THROW)?'T':(t->action == CATCH?'C':'N'),
					 t->height, t->type, t->object == NULL?0:t->object->color,
					 t->start, t->finish);
	  break;
	case BPREDICTOR:
	  (void) fprintf(stderr, "%p B %c      %2d %6lu %6lu %g\n",
					 (void*)t, t->type == Ball?'b':t->type == Empty?'e':'f',
					 t->object == NULL?0:t->object->color,
					 t->start, t->finish, t->yp.c);
	  break;
	case PREDICTOR:
	  (void) fprintf(stderr, "%p P %c      %2d %6lu %6lu %g\n",
					 (void*)t, t->type == Ball?'b':t->type == Empty?'e':'f',
					 t->object == NULL?0:t->object->color,
					 t->start, t->finish, t->yp.c);
	  break;
	default:
	  (void) fprintf(stderr, "%p: status %d not implemented\n",
					 (void*)t, t->status);
	  break;
	}
  }
  (void) fprintf(stderr, "---\n");
}
#endif

static int get_num_balls(const char *j)
{
  int balls = 0;
  const char *p;
  int h = 0;
  if (!j) abort();
  for (p = j; *p; p++) {
	if (*p >= '0' && *p <='9') { /* digit */
	  h = 10*h + (*p - '0');
	} else {
	  if (h > balls) {
		balls = h;
	  }
	  h = 0;
	}
  }
  return balls;
}

static int
compare_num_balls(const void *p1, const void *p2)
{
  int i, j;
  i = get_num_balls(((patternstruct*)p1)->pattern);
  j = get_num_balls(((patternstruct*)p2)->pattern);
  if (i > j) {
	return (1);
  } else if (i < j) {
	return (-1);
  } else {
	return (0);
  }
}


/**************************************************************************
 *                        Rendering Functions                             *
 *                                                                        *
 **************************************************************************/

static int
show_arms(ModeInfo * mi)
{
  int polys = 0;
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  unsigned int i, j;
  Hand side;
  XPoint a[countof(sp->arm[0][0])];
  int slices = 12;
  int thickness = 7;
  int soffx = 10;
  int soffy = 11;

  glFrontFace(GL_CCW);

  j = 1;
  for(side = LEFT; side <= RIGHT; side = (Hand)((int)side + 1)) {
	/* Translate into device coords */
	for(i = 0; i < countof(a); i++) {
	  a[i].x = (short)(SCENE_WIDTH/2 + sp->arm[j][side][i].x*sp->scale);
	  a[i].y = (short)(SCENE_HEIGHT  - sp->arm[j][side][i].y*sp->scale);
	  if(j == 1)
		sp->arm[0][side][i] = sp->arm[1][side][i];
	}

        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_1);

        /* Upper arm */
        polys += tube (a[2].x - (side == LEFT ? soffx : -soffx), a[2].y + soffy, 0,
                       a[1].x, a[1].y, ARMLENGTH/2,
                       thickness, 0, slices,
                       True, True, MI_IS_WIREFRAME(mi));

        /* Lower arm */
        polys += tube (a[1].x, a[1].y, ARMLENGTH/2,
                       a[0].x, a[0].y, ARMLENGTH,
                       thickness * 0.8, 0, slices,
                       True, True, MI_IS_WIREFRAME(mi));

        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_2);

        /* Shoulder */
        glPushMatrix();
        glTranslatef (a[2].x - (side == LEFT ? soffx : -soffx), 
                      a[2].y + soffy, 
                      0);
        glScalef(9, 9, 9);
        polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
        glPopMatrix();

        /* Elbow */
        glPushMatrix();
        glTranslatef (a[1].x, a[1].y, ARMLENGTH/2);
        glScalef(4, 4, 4);
        polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
        glPopMatrix();

        /* Hand */
        glPushMatrix();
        glTranslatef (a[0].x, a[0].y, ARMLENGTH);
        glScalef(8, 8, 8);
        polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
        glPopMatrix();

  }
  return polys;
}

static int
show_figure(ModeInfo * mi, Bool init)
{
  int polys = 0;
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  /*XPoint p[7];*/
  int i;

  /*      +-----+ 9
          |  6  |
       10 +--+--+
       2 +---+---+ 3
          \  5  /
           \   /
            \ /
           1 +
            / \
           /   \
        0 +-----+ 4
          |     |
          |     |
          |     |
        7 +     + 8
  */

  /* #### most of this is unused now */
  static const XPoint figure[] = {
	{ 15,  70}, /* 0  Left Hip */
	{  0,  90}, /* 1  Waist */
	{ SX, 130}, /* 2  Left Shoulder */
	{-SX, 130}, /* 3  Right Shoulder */
	{-15,  70}, /* 4  Right Hip */
	{  0, 130}, /* 5  Neck */
	{  0, 140}, /* 6  Chin */
	{ SX,   0}, /* 7  Left Foot */
	{-SX,   0}, /* 8  Right Foot */
	{-17, 174}, /* 9  Head1 */
	{ 17, 140}, /* 10 Head2 */
  };
  XPoint a[countof(figure)];
  GLfloat gcolor[4] = { 1, 1, 1, 1 };

  /* Translate into device coords */
  for(i = 0; i < countof(figure); i++) {
	a[i].x = (short)(SCENE_WIDTH/2 + (sp->cx + figure[i].x)*sp->scale);
	a[i].y = (short)(SCENE_HEIGHT - figure[i].y*sp->scale);
  }

  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gcolor);

  glFrontFace(GL_CCW);

  {
    GLfloat scale = ((GLfloat) a[10].x - a[9].x) / 2;
    int slices = 12;

    glPushMatrix();
    {
      glTranslatef(a[6].x, a[6].y - scale, 0);
      glScalef(scale, scale, scale);

      /* Head */
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_1);
      glPushMatrix();
      scale = 0.75;
      glScalef(scale, scale, scale);
      glTranslatef(0, 0.3, 0);
      glPushMatrix();
      glTranslatef(0, 0, 0.35);
      polys += tube (0, 0, 0,
                     0, 1.1, 0,
                     0.64, 0,
                     slices, True, True, MI_IS_WIREFRAME(mi));
      glPopMatrix();
      glScalef(0.9, 0.9, 1);
      polys += unit_sphere(2*slices, 2*slices, MI_IS_WIREFRAME(mi));
      glPopMatrix();

      /* Neck */
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_2);
      glTranslatef(0, 1.1, 0);
      glPushMatrix();
      scale = 0.35;
      glScalef(scale, scale, scale);
      polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
      glPopMatrix();

      /* Torso */
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_1);
      glTranslatef(0, 1.1, 0);
      glPushMatrix();
      glScalef(0.9, 1.0, 0.9);
      polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
      glPopMatrix();

      /* Belly */
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_2);
      glTranslatef(0, 1.0, 0);
      glPushMatrix();
      scale = 0.6;
      glScalef(scale, scale, scale);
      polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
      glPopMatrix();

      /* Hips */
      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_1);
      glTranslatef(0, 0.8, 0);
      glPushMatrix();
      scale = 0.85;
      glScalef(scale, scale, scale);
      polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
      glPopMatrix();


      /* Legs */
      glTranslatef(0, 0.7, 0);

      for (i = -1; i <= 1; i += 2) {
        glPushMatrix();

        glRotatef (i*10, 0, 0, 1);
        glTranslatef(-i*0.65, 0, 0);
        
        /* Hip socket */
        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_2);
        scale = 0.45;
        glScalef(scale, scale, scale);
        polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));

        /* Thigh */
        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_1);
        glPushMatrix();
        glTranslatef(0, 0.6, 0);
        polys += tube (0, 0, 0,
                       0, 3.5, 0,
                       1, 0,
                       slices, True, True, MI_IS_WIREFRAME(mi));
        glPopMatrix();

        /* Knee */
        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_2);
        glPushMatrix();
        glTranslatef(0, 4.4, 0);
        scale = 0.7;
        glScalef(scale, scale, scale);
        polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
        glPopMatrix();

        /* Calf */
        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_1);
        glPushMatrix();
        glTranslatef(0, 4.7, 0);
        polys += tube (0, 0, 0,
                       0, 4.7, 0,
                       0.8, 0,
                       slices, True, True, MI_IS_WIREFRAME(mi));
        glPopMatrix();

        /* Ankle */
        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_2);
        glPushMatrix();
        glTranslatef(0, 9.7, 0);
        scale = 0.5;
        glScalef(scale, scale, scale);
        polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));
        glPopMatrix();

        /* Foot */
        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, body_color_1);
        glPushMatrix();
        glRotatef (-i*10, 0, 0, 1);
        glTranslatef(-i*1.75, 9.7, 0.9);

        glScalef (0.4, 1, 1);
        polys += tube (0, 0, 0,
                       0, 0.6, 0,
                       1.9, 0,
                       slices*4, True, True, MI_IS_WIREFRAME(mi));
        glPopMatrix();

        glPopMatrix();
      }
    }
    glPopMatrix();
  }

  sp->arm[1][LEFT][SHOULDER].x = sp->cx + figure[2].x;
  sp->arm[1][RIGHT][SHOULDER].x = sp->cx + figure[3].x;
  if(init) {
	/* Initialise arms */
	unsigned int i;
	for(i = 0; i < 2; i++){
	  sp->arm[i][LEFT][SHOULDER].y = figure[2].y;
	  sp->arm[i][LEFT][ELBOW].x = figure[2].x;
	  sp->arm[i][LEFT][ELBOW].y = figure[1].y;
	  sp->arm[i][LEFT][HAND].x = figure[0].x;
	  sp->arm[i][LEFT][HAND].y = figure[1].y;
	  sp->arm[i][RIGHT][SHOULDER].y = figure[3].y;
	  sp->arm[i][RIGHT][ELBOW].x = figure[3].x;
	  sp->arm[i][RIGHT][ELBOW].y = figure[1].y;
	  sp->arm[i][RIGHT][HAND].x = figure[4].x;
	  sp->arm[i][RIGHT][HAND].y = figure[1].y;
	}
  }
  return polys;
}

typedef struct { GLfloat x, y, z; } XYZ;

/* lifted from sphere.c */
static int
striped_unit_sphere (int stacks, int slices, 
                     int stripes, 
                     GLfloat *color1, GLfloat *color2,
                     int wire_p)
{
  int polys = 0;
  int i,j;
  double theta1, theta2, theta3;
  XYZ e, p;
  XYZ la = { 0, 0, 0 }, lb = { 0, 0, 0 };
  XYZ c = {0, 0, 0};  /* center */
  double r = 1.0;     /* radius */
  int stacks2 = stacks * 2;

  if (r < 0)
    r = -r;
  if (slices < 0)
    slices = -slices;

  if (slices < 4 || stacks < 2 || r <= 0)
    {
      glBegin (GL_POINTS);
      glVertex3f (c.x, c.y, c.z);
      glEnd();
      return 1;
    }

  glFrontFace(GL_CW);

  for (j = 0; j < stacks; j++)
    {
      theta1 = j       * (M_PI+M_PI) / stacks2 - M_PI_2;
      theta2 = (j + 1) * (M_PI+M_PI) / stacks2 - M_PI_2;

      glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE,
                    ((j == 0 || j == stacks-1 ||
                     j % (stacks / (stripes+1)))
                     ? color1 : color2));

      glBegin (wire_p ? GL_LINE_LOOP : GL_TRIANGLE_STRIP);
      for (i = 0; i <= slices; i++)
        {
          theta3 = i * (M_PI+M_PI) / slices;

          if (wire_p && i != 0)
            {
              glVertex3f (lb.x, lb.y, lb.z);
              glVertex3f (la.x, la.y, la.z);
            }

          e.x = cos (theta2) * cos(theta3);
          e.y = sin (theta2);
          e.z = cos (theta2) * sin(theta3);
          p.x = c.x + r * e.x;
          p.y = c.y + r * e.y;
          p.z = c.z + r * e.z;

          glNormal3f (e.x, e.y, e.z);
          glTexCoord2f (i       / (double)slices,
                        2*(j+1) / (double)stacks2);
          glVertex3f (p.x, p.y, p.z);
          if (wire_p) la = p;

          e.x = cos(theta1) * cos(theta3);
          e.y = sin(theta1);
          e.z = cos(theta1) * sin(theta3);
          p.x = c.x + r * e.x;
          p.y = c.y + r * e.y;
          p.z = c.z + r * e.z;

          glNormal3f (e.x, e.y, e.z);
          glTexCoord2f (i   / (double)slices,
                        2*j / (double)stacks2);
          glVertex3f (p.x, p.y, p.z);
          if (wire_p) lb = p;
          polys++;
        }
      glEnd();
    }
  return polys;
}



static int
show_ball(ModeInfo *mi, unsigned long color, Trace *s)
{
  int polys = 0;
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  /*int offset = (int)(s->angle*64*180/M_PI);*/
  short x = (short)(SCENE_WIDTH/2 + s->x * sp->scale);
  short y = (short)(SCENE_HEIGHT - s->y * sp->scale);
  GLfloat gcolor1[4] = { 0, 0, 0, 1 };
  GLfloat gcolor2[4] = { 0, 0, 0, 1 };
  int slices = 24;

  /* Avoid wrapping */
  if(s->y*sp->scale >  SCENE_HEIGHT * 2) return 0;

  gcolor1[0] = mi->colors[color].red   / 65536.0;
  gcolor1[1] = mi->colors[color].green / 65536.0;
  gcolor1[2] = mi->colors[color].blue  / 65536.0;

  gcolor2[0] = gcolor1[0] / 3;
  gcolor2[1] = gcolor1[1] / 3;
  gcolor2[2] = gcolor1[2] / 3;

  glFrontFace(GL_CCW);

  {
    GLfloat scale = BALLRADIUS;
    glPushMatrix();
    glTranslatef(x, y, 0);
    glScalef(scale, scale, scale);

    glRotatef (s->angle / M_PI*180, 1, 1, 0);

    polys += striped_unit_sphere (slices, slices, s->divisions, 
                                  gcolor1, gcolor2, MI_IS_WIREFRAME(mi));
    glPopMatrix();
  }
  return polys;
}

static int
show_europeanclub(ModeInfo *mi, unsigned long color, Trace *s)
{
  int polys = 0;
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  /*int offset = (int)(s->angle*64*180/M_PI);*/
  short x = (short)(SCENE_WIDTH/2 + s->x * sp->scale);
  short y = (short)(SCENE_HEIGHT - s->y * sp->scale);
  double radius = 12 * sp->scale;
  GLfloat gcolor1[4] = { 0, 0, 0, 1 };
  GLfloat gcolor2[4] = { 1, 1, 1, 1 };
  int slices = 16;
  int divs = 4;

  /*    6   6
         +-+
        /   \
     4 +-----+ 7
      ////////\
   3 +---------+ 8
   2 +---------+ 9
      |///////|
    1 +-------+ 10
       |     |
       |     |
        |   |
        |   |
         | |
         | |
         +-+
        0  11 	*/

  /* Avoid wrapping */
  if(s->y*sp->scale >  SCENE_HEIGHT * 2) return 0;

  gcolor1[0] = mi->colors[color].red   / 65536.0;
  gcolor1[1] = mi->colors[color].green / 65536.0;
  gcolor1[2] = mi->colors[color].blue  / 65536.0;

  glFrontFace(GL_CCW);

  {
    GLfloat scale = radius;
    glPushMatrix();
    glTranslatef(x, y, 0);
    glScalef(scale, scale, scale);

    glTranslatef (0, 0, 2);  /* put end of handle in hand */

    glRotatef (s->angle / M_PI*180, 1, 0, 0);

    glPushMatrix();
    glScalef (0.5, 1, 0.5);
    polys += striped_unit_sphere (slices, slices, divs, gcolor2, gcolor1, 
                                  MI_IS_WIREFRAME(mi));
    glPopMatrix();
    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gcolor2);
    polys += tube (0, 0, 0,
                   0, 2, 0,
                   0.2, 0,
                   slices, True, True, MI_IS_WIREFRAME(mi));

    glTranslatef (0, 2, 0);
    glScalef (0.25, 0.25, 0.25);
    polys += unit_sphere(slices, slices, MI_IS_WIREFRAME(mi));

    glPopMatrix();
  }
  return polys;
}


static int
show_torch(ModeInfo *mi, unsigned long color, Trace *s)
{
  int polys = 0;
#if 0
	jugglestruct *sp = &juggles[MI_SCREEN(mi)];
	XPoint head, tail, last;
	DXPoint dhead, dlast;
	const double sa = sin(s->angle);
	const double ca = cos(s->angle);

	const double TailLen = -24;
	const double HeadLen = 16;
	const short Width   = (short)(5 * sqrt(sp->scale));

	/*
      +///+ head
    last  |
          |
          |
          |
          |
          + tail
	*/

	dhead.x = s->x + HeadLen * PERSPEC * sa;
	dhead.y = s->y - HeadLen * ca;

	if(color == MI_BLACK_PIXEL(mi)) { /* Use 'last' when erasing */
	  dlast = s->dlast;
	} else { /* Store 'last' so we can use it later when s->prev has
				gone */
	  if(s->prev != s->next) {
		dlast.x = s->prev->x + HeadLen * PERSPEC * sin(s->prev->angle);
		dlast.y = s->prev->y - HeadLen * cos(s->prev->angle);
	  } else {
		dlast = dhead;
	  }
	  s->dlast = dlast;
	}

	/* Avoid wrapping (after last is stored) */
	if(s->y*sp->scale >  SCENE_HEIGHT * 2) return 0;

	head.x = (short)(SCENE_WIDTH/2 + dhead.x*sp->scale);
	head.y = (short)(SCENE_HEIGHT - dhead.y*sp->scale);

	last.x = (short)(SCENE_WIDTH/2 + dlast.x*sp->scale);
	last.y = (short)(SCENE_HEIGHT - dlast.y*sp->scale);

	tail.x = (short)(SCENE_WIDTH/2 +
					 (s->x + TailLen * PERSPEC * sa)*sp->scale );
	tail.y = (short)(SCENE_HEIGHT - (s->y - TailLen * ca)*sp->scale );

	if(color != MI_BLACK_PIXEL(mi)) {
	  XSetForeground(MI_DISPLAY(mi), MI_GC(mi), MI_BLACK_PIXEL(mi));
	  XSetLineAttributes(MI_DISPLAY(mi), MI_GC(mi),
						 Width, LineSolid, CapRound, JoinRound);
	  draw_line(mi, head.x, head.y, tail.x, tail.y);
	}
	XSetForeground(MI_DISPLAY(mi), MI_GC(mi), color);
	XSetLineAttributes(MI_DISPLAY(mi), MI_GC(mi),
					   Width * 2, LineSolid, CapRound, JoinRound);

	draw_line(mi, head.x, head.y, last.x, last.y);

#endif /* 0 */
   return polys;
}


static int
show_knife(ModeInfo *mi, unsigned long color, Trace *s)
{
  int polys = 0;
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  /*int offset = (int)(s->angle*64*180/M_PI);*/
  short x = (short)(SCENE_WIDTH/2 + s->x * sp->scale);
  short y = (short)(SCENE_HEIGHT - s->y * sp->scale);
  GLfloat gcolor1[4] = { 0, 0, 0, 1 };
  GLfloat gcolor2[4] = { 1, 1, 1, 1 };
  int slices = 8;

  /* Avoid wrapping */
  if(s->y*sp->scale >  SCENE_HEIGHT * 2) return 0;

  gcolor1[0] = mi->colors[color].red   / 65536.0;
  gcolor1[1] = mi->colors[color].green / 65536.0;
  gcolor1[2] = mi->colors[color].blue  / 65536.0;

  glFrontFace(GL_CCW);

  glPushMatrix();
  glTranslatef(x, y, 0);
  glScalef (2, 2, 2);

  glTranslatef (0, 0, 2);  /* put end of handle in hand */
  glRotatef (s->angle / M_PI*180, 1, 0, 0);

  glScalef (0.3, 1, 1);  /* flatten blade */

  glTranslatef(0, 6, 0);
  glRotatef (180, 1, 0, 0);

  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gcolor1);
  polys += tube (0, 0, 0,
                 0, 10, 0,
                 1, 0,
                 slices, True, True, MI_IS_WIREFRAME(mi));

  glTranslatef (0, 12, 0);
  glScalef (0.7, 10, 0.7);
  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gcolor2);
  polys += unit_sphere (slices, slices, MI_IS_WIREFRAME(mi));

  glPopMatrix();
  return polys;
}


static int
show_ring(ModeInfo *mi, unsigned long color, Trace *s)
{
  int polys = 0;
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  /*int offset = (int)(s->angle*64*180/M_PI);*/
  short x = (short)(SCENE_WIDTH/2 + s->x * sp->scale);
  short y = (short)(SCENE_HEIGHT - s->y * sp->scale);
  double radius = 12 * sp->scale;
  GLfloat gcolor1[4] = { 0, 0, 0, 1 };
  GLfloat gcolor2[4] = { 0, 0, 0, 1 };
  int slices = 24;
  int i, j;
  int wire_p = MI_IS_WIREFRAME(mi);
  GLfloat width = M_PI * 2 / slices;
  GLfloat ra = 1.0;
  GLfloat rb = 0.7;
  GLfloat thickness = 0.15;

  /* Avoid wrapping */
  if(s->y*sp->scale >  SCENE_HEIGHT * 2) return 0;

  gcolor1[0] = mi->colors[color].red   / 65536.0;
  gcolor1[1] = mi->colors[color].green / 65536.0;
  gcolor1[2] = mi->colors[color].blue  / 65536.0;

  gcolor2[0] = gcolor1[0] / 3;
  gcolor2[1] = gcolor1[1] / 3;
  gcolor2[2] = gcolor1[2] / 3;

  glFrontFace(GL_CCW);

  glPushMatrix();
  glTranslatef(0, 0, 12);  /* back of ring in hand */

  glTranslatef(x, y, 0);
  glScalef(radius, radius, radius);

  glRotatef (90, 0, 1, 0);
  glRotatef (s->angle / M_PI*180, 0, 0, 1);

  glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gcolor1);

  /* discs */
  for (j = -1; j <= 1; j += 2)
    {
      GLfloat z = j * thickness/2;
      glFrontFace (j < 0 ? GL_CCW : GL_CW);
      glNormal3f (0, 0, j*1);
      glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);
      for (i = 0; i < slices + (wire_p ? 0 : 1); i++) {
        GLfloat th, cth, sth;
        glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE,
                      (i % (slices/3) ? gcolor1 : gcolor2));
        th = i * width;
        cth = cos(th);
        sth = sin(th);
        glVertex3f (cth * ra, sth * ra, z);
        glVertex3f (cth * rb, sth * rb, z);
        polys++;
      }
      glEnd();
    }

  /* outer ring */
  glFrontFace (GL_CCW);
  glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);
  for (i = 0; i < slices + (wire_p ? 0 : 1); i++)
    {
      GLfloat th = i * width;
      GLfloat cth = cos(th);
      GLfloat sth = sin(th);
      glNormal3f (cth, sth, 0);
      glVertex3f (cth * ra, sth * ra, thickness/2);
      glVertex3f (cth * ra, sth * ra, -thickness/2);
      polys++;
    }
  glEnd();

  /* inner ring */
  glFrontFace (GL_CW);
  glBegin (wire_p ? GL_LINES : GL_QUAD_STRIP);
  for (i = 0; i < slices + (wire_p ? 0 : 1); i++)
    {
      GLfloat th = i * width;
      GLfloat cth = cos(th);
      GLfloat sth = sin(th);
      glNormal3f (-cth, -sth, 0);
      glVertex3f (cth * rb, sth * ra, thickness/2);
      glVertex3f (cth * rb, sth * ra, -thickness/2);
      polys++;
    }
  glEnd();

  glFrontFace (GL_CCW);
  glPopMatrix();
  return polys;
}


static int
show_bball(ModeInfo *mi, unsigned long color, Trace *s)
{
  int polys = 0;
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  /*int offset = (int)(s->angle*64*180/M_PI);*/
  short x = (short)(SCENE_WIDTH/2 + s->x * sp->scale);
  short y = (short)(SCENE_HEIGHT - s->y * sp->scale);
  double radius = 12 * sp->scale;
  GLfloat gcolor1[4] = { 0, 0, 0, 1 };
  GLfloat gcolor2[4] = { 0, 0, 0, 1 };
  int slices = 16;
  int i, j;

  /* Avoid wrapping */
  if(s->y*sp->scale >  SCENE_HEIGHT * 2) return 0;

  gcolor1[0] = mi->colors[color].red   / 65536.0;
  gcolor1[1] = mi->colors[color].green / 65536.0;
  gcolor1[2] = mi->colors[color].blue  / 65536.0;

  glFrontFace(GL_CCW);

  {
    GLfloat scale = radius;
    glPushMatrix();

    glTranslatef(0, -6, 5);  /* position on top of hand */

    glTranslatef(x, y, 0);
    glScalef(scale, scale, scale);
    glRotatef (s->angle / M_PI*180, 1, 0, 1);

    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gcolor1);
    polys += unit_sphere (slices, slices, MI_IS_WIREFRAME(mi));

    glRotatef (90, 0, 0, 1);
    glTranslatef (0, 0, 0.81);
    glScalef(0.15, 0.15, 0.15);
    glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gcolor2);
    for (i = 0; i < 3; i++) {
      glPushMatrix();
      glTranslatef (0, 0, 1);
      glRotatef (360 * i / 3, 0, 0, 1);
      glTranslatef (2, 0, 0);
      glRotatef (18, 0, 1, 0);
      glBegin (MI_IS_WIREFRAME(mi) ? GL_LINE_LOOP : GL_TRIANGLE_FAN);
      glVertex3f (0, 0, 0);
      for (j = slices; j >= 0; j--) {
        GLfloat th = j * M_PI*2 / slices;
        glVertex3f (cos(th), sin(th), 0);
        polys++;
      }
      glEnd();
      glPopMatrix();
    }

    glPopMatrix();
  }
  return polys;
}


/**************************************************************************
 *                    Public Functions                                    *
 *                                                                        *
 **************************************************************************/


/* FIXME: refill_juggle currently just appends new throws to the
 * programme.  This is fine if the programme is empty, but if there
 * are still some trajectories left then it really should take these
 * into account */

static void
refill_juggle(ModeInfo * mi)
{
  jugglestruct *sp = NULL;
  int i;

  if (juggles == NULL)
	return;
  sp = &juggles[MI_SCREEN(mi)];

  /* generate pattern */

  if (pattern == NULL) {

#define MAXPAT 10
#define MAXREPEAT 300
#define CHANGE_BIAS 8 /* larger makes num_ball changes less likely */
#define POSITION_BIAS 20 /* larger makes hand movements less likely */

	int count = 0;
	while (count < MI_CYCLES(mi)) {
	  char buf[MAXPAT * 3 + 3], *b = buf;
	  int maxseen = 0;
	  int l = NRAND(MAXPAT) + 1;
	  int t = NRAND(MIN(MAXREPEAT, (MI_CYCLES(mi) - count))) + 1;

	  { /* vary number of balls */
		int new_balls = sp->num_balls;
		int change;

		if (new_balls == 2) /* Do not juggle 2 that often */
		  change = NRAND(2 + CHANGE_BIAS / 4);
		else
		  change = NRAND(2 + CHANGE_BIAS);
		switch (change) {
		case 0:
		  new_balls++;
		  break;
		case 1:
		  new_balls--;
		  break;
		default:
		  break; /* NO-OP */
		}
		if (new_balls < sp->patternindex.minballs) {
		  new_balls += 2;
		}
		if (new_balls > sp->patternindex.maxballs) {
		  new_balls -= 2;
		}
		if (new_balls < sp->num_balls) {
		  if (!program(mi, "[*]", NULL, 1)) /* lose ball */
			return;
		}
		sp->num_balls = new_balls;
	  }

	  count += t;
	  if (NRAND(2) && sp->patternindex.index[sp->num_balls].number) {
		/* Pick from PortFolio */
		int p = sp->patternindex.index[sp->num_balls].start +
		  NRAND(sp->patternindex.index[sp->num_balls].number);
		if (!program(mi, portfolio[p].pattern, portfolio[p].name, t))
		  return;
	  } else {
		/* Invent a new pattern */
		*b++='[';
		for(i = 0; i < l; i++){
		  int n, m;
		  do { /* Triangular Distribution => high values more likely */
			m = NRAND(sp->num_balls + 1);
			n = NRAND(sp->num_balls + 1);
		  } while(m >= n);
		  if (n == sp->num_balls) {
			maxseen = 1;
		  }
		  switch(NRAND(5 + POSITION_BIAS)){
		  case 0:            /* Outside throw */
			*b++ = '+'; break;
		  case 1:            /* Cross throw */
			*b++ = '='; break;
		  case 2:            /* Cross catch */
			*b++ = '&'; break;
		  case 3:            /* Cross throw and catch */
			*b++ = 'x'; break;
		  case 4:            /* Bounce */
			*b++ = '_'; break;
		  default:
			break;             /* Inside throw (default) */
		  }

		  *b++ = n + '0';
		  *b++ = ' ';
		}
		*b++ = ']';
		*b = '\0';
		if (maxseen) {
		  if (!program(mi, buf, NULL, t))
			return;
		}
	  }
	}
  } else { /* pattern supplied in height or 'a' notation */
	if (!program(mi, pattern, NULL, MI_CYCLES(mi)))
	  return;
  }

  adam(sp);

  name(sp);

  if (!part(mi))
	return;

  lob(mi);

  clap(sp);

  positions(sp);

  if (!projectile(sp)) {
	return;
  }

  hands(sp);
#ifdef DEBUG
  if(MI_IS_DEBUG(mi)) dump(sp);
#endif
}

static void
change_juggle(ModeInfo * mi)
{
  jugglestruct *sp = NULL;
  Trajectory *t;

  if (juggles == NULL)
	return;
  sp = &juggles[MI_SCREEN(mi)];

  /* Strip pending trajectories */
  for (t = sp->head->next; t != sp->head; t = t->next) {
	if(t->start > sp->time || t->finish < sp->time) {
	  Trajectory *n = t;
	  t=t->prev;
	  trajectory_destroy(n);
	}
  }

  /* Pick the current object theme */
  sp->objtypes = choose_object();

  refill_juggle(mi);

  mi->polygon_count += show_figure(mi, True);
}


ENTRYPOINT void
reshape_juggle (ModeInfo *mi, int width, int height)
{
  GLfloat h = (GLfloat) height / (GLfloat) width;

  glViewport (0, 0, (GLint) width, (GLint) height);

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective (30.0, 1/h, 1.0, 100.0);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  gluLookAt( 0.0, 0.0, 30.0,
             0.0, 0.0, 0.0,
             0.0, 1.0, 0.0);

  glClear(GL_COLOR_BUFFER_BIT);
}


ENTRYPOINT void
init_juggle (ModeInfo * mi)
{
  jugglestruct *sp = 0;
  int wire = MI_IS_WIREFRAME(mi);

  MI_INIT (mi, juggles);

  sp = &juggles[MI_SCREEN(mi)];

  if (!sp->glx_context)   /* re-initting breaks print_texture_label */
    sp->glx_context = init_GL(mi);

  sp->font_data = load_texture_font (mi->dpy, "titleFont");

  reshape_juggle (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
  clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */

  if (!wire)
    {
      GLfloat pos[4] = {1.0, 1.0, 1.0, 0.0};
      GLfloat amb[4] = {0.0, 0.0, 0.0, 1.0};
      GLfloat dif[4] = {1.0, 1.0, 1.0, 1.0};
      GLfloat spc[4] = {0.0, 1.0, 1.0, 1.0};

      glEnable(GL_LIGHTING);
      glEnable(GL_LIGHT0);
      glEnable(GL_DEPTH_TEST);
      glEnable(GL_CULL_FACE);

      glLightfv(GL_LIGHT0, GL_POSITION, pos);
      glLightfv(GL_LIGHT0, GL_AMBIENT,  amb);
      glLightfv(GL_LIGHT0, GL_DIFFUSE,  dif);
      glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
    }

  make_random_colormap (0, 0, 0,
                        mi->colors, &MI_NPIXELS(mi),
                        True, False, 0, False);

  {
    double spin_speed   = 0.05;
    double wander_speed = 0.001;
    double spin_accel   = 0.05;
    sp->rot = make_rotator (0, spin_speed, 0, 
                            spin_accel, wander_speed, False);
    sp->trackball = gltrackball_init (False);
  }

  if (only && *only && strcmp(only, " ")) {
    balls = clubs = torches = knives = rings = bballs = False;
    if (!strcasecmp (only, "balls"))   balls   = True;
    else if (!strcasecmp (only, "clubs"))   clubs   = True;
    else if (!strcasecmp (only, "torches")) torches = True;
    else if (!strcasecmp (only, "knives"))  knives  = True;
    else if (!strcasecmp (only, "rings"))   rings   = True;
    else if (!strcasecmp (only, "bballs"))  bballs  = True;
    else {
      (void) fprintf (stderr,
               "Juggle: -only must be one of: balls, clubs, torches, knives,\n"
               "\t rings, or bballs (not \"%s\")\n", only);
#ifdef STANDALONE /* xlock mustn't exit merely because of a bad argument */
      exit (1);
#endif
    }
  }

  /* #### hard to make this look good in OpenGL... */
  torches = False;


  if (sp->head == 0) {  /* first time initializing this juggler */

	sp->count = ABS(MI_COUNT(mi));
	if (sp->count == 0)
	  sp->count = 200;

	/* record start time */
	sp->begintime = time(NULL);
	if(sp->patternindex.maxballs > 0) {
	  sp->num_balls = sp->patternindex.minballs +
		NRAND(sp->patternindex.maxballs - sp->patternindex.minballs);
	}

        mi->polygon_count +=
          show_figure(mi, True); /* Draw figure.  Also discovers
                                    information about the juggler's
                                    proportions */

	/* "7" should be about three times the height of the juggler's
	   shoulders */
	sp->Gr = -GRAVITY(3 * sp->arm[0][RIGHT][SHOULDER].y,
					  7 * THROW_CATCH_INTERVAL);

	if(!balls && !clubs && !torches && !knives && !rings && !bballs)
	  balls = True; /* Have to juggle something! */

	/* create circular trajectory list */
	ADD_ELEMENT(Trajectory, sp->head, sp->head);
	if(sp->head == NULL){
	  return;
	}

	/* create circular object list */
	ADD_ELEMENT(Object, sp->objects, sp->objects);
	if(sp->objects == NULL){
	  return;
	}

	sp->pattern =  strdup(""); /* Initialise saved pattern with 
                                      free-able memory */
  }

  sp = &juggles[MI_SCREEN(mi)];

  if (pattern &&
      (!*pattern ||
       !strcasecmp (pattern, ".") ||
       !strcasecmp (pattern, "random")))
	pattern = NULL;

  if (pattern == NULL && sp->patternindex.maxballs == 0) {
	/* pattern list needs indexing */
	int nelements = countof(portfolio);
	int numpat = 0;
	int i;

	/* sort according to number of balls */
	qsort((void*)portfolio, nelements,
		  sizeof(portfolio[1]), compare_num_balls);

	/* last pattern has most balls */
	sp->patternindex.maxballs = get_num_balls(portfolio[nelements - 1].pattern);
	/* run through sorted list, indexing start of each group
	   and number in group */
	sp->patternindex.maxballs = 1;
	for (i = 0; i < nelements; i++) {
	  int b = get_num_balls(portfolio[i].pattern);
	  if (b > sp->patternindex.maxballs) {
		sp->patternindex.index[sp->patternindex.maxballs].number = numpat;
		if(numpat == 0) sp->patternindex.minballs = b;
		sp->patternindex.maxballs = b;
		numpat = 1;
		sp->patternindex.index[sp->patternindex.maxballs].start = i;
	  } else {
		numpat++;
	  }
	}
	sp->patternindex.index[sp->patternindex.maxballs].number = numpat;
  }

  /* Set up programme */
  change_juggle(mi);

  /* Only put things here that won't interrupt the programme during
	 a window resize */

  /* Use MIN so that users can resize in interesting ways, eg
	 narrow windows for tall patterns, etc */
  sp->scale = MIN(SCENE_HEIGHT/480.0, SCENE_WIDTH/160.0);

}

ENTRYPOINT Bool
juggle_handle_event (ModeInfo *mi, XEvent *event)
{
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];

  if (gltrackball_event_handler (event, sp->trackball,
                                 MI_WIDTH (mi), MI_HEIGHT (mi),
                                 &sp->button_down_p))
    return True;
  else if (screenhack_event_helper (MI_DISPLAY(mi), MI_WINDOW(mi), event))
    {
      change_juggle (mi);
      return True;
    }

  return False;
}


ENTRYPOINT void
draw_juggle (ModeInfo *mi)
{
  jugglestruct *sp = &juggles[MI_SCREEN(mi)];
  Display *dpy = MI_DISPLAY(mi);
  Window window = MI_WINDOW(mi);

  Trajectory *traj = NULL;
  Object *o = NULL;
  unsigned long future = 0;
  char *pattern = NULL;

  if (!sp->glx_context)
    return;

  glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *sp->glx_context);

  glShadeModel(GL_SMOOTH);

  glEnable(GL_DEPTH_TEST);
  glEnable(GL_NORMALIZE);
  glEnable(GL_CULL_FACE);

  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushMatrix ();
  glRotatef(current_device_rotation(), 0, 0, 1);

  glTranslatef(0,-3,0);

  {
    double x, y, z;
    get_position (sp->rot, &x, &y, &z, !sp->button_down_p);
    glTranslatef((x - 0.5) * 8,
                 (y - 0.5) * 3,
                 (z - 0.5) * 15);

    gltrackball_rotate (sp->trackball);

    get_rotation (sp->rot, &x, &y, &z, !sp->button_down_p);

    if (y < 0.8) y = 0.8 - (y - 0.8);	/* always face forward */
    if (y > 1.2) y = 1.2 - (y - 1.2);

    glRotatef (x * 360, 1.0, 0.0, 0.0);
    glRotatef (y * 360, 0.0, 1.0, 0.0);
    glRotatef (z * 360, 0.0, 0.0, 1.0);
  }

  {
    GLfloat scale = 20.0 / SCENE_HEIGHT;
    glScalef(scale, scale, scale);
  }

  glRotatef (180, 0, 0, 1);
  glTranslatef(-SCENE_WIDTH/2, -SCENE_HEIGHT/2, 0);
  glTranslatef(0, -150, 0);

  mi->polygon_count = 0;

  /* Update timer */
  if (real) {
	struct timeval tv;
	(void)gettimeofday(&tv, NULL);
	sp->time = (int) ((tv.tv_sec - sp->begintime)*1000 + tv.tv_usec/1000);
  } else {
	sp->time += MI_DELAY(mi) / 1000;
  }

  /* First pass: Move arms and strip out expired elements */
  for (traj = sp->head->next; traj != sp->head; traj = traj->next) {
	if (traj->status != PREDICTOR) {
	  /* Skip any elements that need further processing */
	  /* We could remove them, but there shoudn't be many and they
		 would be needed if we ever got the pattern refiller
		 working */
	  continue;
	}
	if (traj->start > future) { /* Lookahead to the end of the show */
	  future = traj->start;
	}
	if (sp->time < traj->start) { /* early */
	  continue;
	} else if (sp->time < traj->finish) { /* working */

	  /* Look for pattern name */
	  if(traj->pattern != NULL) {
		pattern=traj->pattern;
	  }

	  if (traj->type == Empty || traj->type == Full) {
		/* Only interested in hands on this pass */
/*		double angle = traj->angle + traj->spin * (sp->time - traj->start);*/
		double xd = 0, yd = 0;
		DXPoint p;

		/* Find the catching offset */
		if(traj->object != NULL) {
#if 0
                  /* #### not sure what this is doing, but I'm guessing
                     that the use of PERSPEC means this isn't needed
                     in the OpenGL version? -jwz
                   */
		  if(ObjectDefs[traj->object->type].handle > 0) {
			/* Handles Need to be oriented */
			xd = ObjectDefs[traj->object->type].handle *
			  PERSPEC * sin(angle);
			yd = ObjectDefs[traj->object->type].handle *
			  cos(angle);
		  } else
#endif
                    {
			/* Balls are always caught at the bottom */
			xd = 0;
			yd = -4;
		  }
		}
		p.x = (CUBIC(traj->xp, sp->time) - xd);
		p.y = (CUBIC(traj->yp, sp->time) + yd);
		reach_arm(mi, traj->hand, &p);

		/* Store updated hand position */
		traj->x = p.x + xd;
		traj->y = p.y - yd;
	  }
	  if (traj->type == Ball || traj->type == Full) {
		/* Only interested in objects on this pass */
		double x, y;
		Trace *s;

		if(traj->type == Full) {
		  /* Adjusted these in the first pass */
		  x = traj->x;
		  y = traj->y;
		} else {
		  x = CUBIC(traj->xp, sp->time);
		  y = CUBIC(traj->yp, sp->time);
		}

		ADD_ELEMENT(Trace, s, traj->object->trace->prev);
		s->x = x;
		s->y = y;
		s->angle = traj->angle + traj->spin * (sp->time - traj->start);
		s->divisions = traj->divisions;
		traj->object->tracelen++;
		traj->object->active = True;
	  }
	} else { /* expired */
	  Trajectory *n = traj;
	  traj=traj->prev;
	  trajectory_destroy(n);
	}
  }


  mi->polygon_count += show_figure(mi, False);
  mi->polygon_count += show_arms(mi);

  /* Draw Objects */
  glTranslatef(0, 0, ARMLENGTH);
  for (o = sp->objects->next; o != sp->objects; o = o->next) {
	if(o->active) {
	  mi->polygon_count += ObjectDefs[o->type].draw(mi, o->color, 
                                                        o->trace->prev);
	  o->active = False;
	}
  }


  /* Save pattern name so we can erase it when it changes */
  if(pattern != NULL && strcmp(sp->pattern, pattern) != 0 ) {
	free(sp->pattern);
	sp->pattern = strdup(pattern);

	if (MI_IS_VERBOSE(mi)) {
	  (void) fprintf(stderr, "Juggle[%d]: Running: %s\n",
					 MI_SCREEN(mi), sp->pattern);
	}
  }

#ifndef HAVE_ANDROID   /* Doesn't work -- causes whole scene to be black */
  glColor3f (1, 1, 0);
  print_texture_label (mi->dpy, sp->font_data,
                       mi->xgwa.width, mi->xgwa.height,
                       1, sp->pattern);
#endif

#ifdef MEMTEST
  if((int)(sp->time/10) % 1000 == 0)
	(void) fprintf(stderr, "sbrk: %d\n", (int)sbrk(0));
#endif

  if (future < sp->time + 100 * THROW_CATCH_INTERVAL) {
	refill_juggle(mi);
  } else if (sp->time > 1<<30) { /* Hard Reset before the clock wraps */
	init_juggle(mi);
  }

  glPopMatrix ();

  if (mi->fps_p) do_fps (mi);
  glFinish();

  glXSwapBuffers(dpy, window);
}

XSCREENSAVER_MODULE_2 ("Juggler3D", juggler3d, juggle)

#endif /* USE_GL */
