--- /dev/null
+/* Juggler3D, Copyright (c) 2005 Brian Apps <brian@jugglesaver.co.uk>
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation. No
+ * representations are made about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty. */
+
+#include <X11/Intrinsic.h>
+
+#undef countof
+#define countof(x) (sizeof((x))/sizeof((*x)))
+
+#define PROGCLASS "Juggler3D"
+#define HACK_INIT Juggler3D_HackInitEvent
+#define HACK_DRAW Juggler3D_HackDrawEvent
+#define HACK_RESHAPE Juggler3D_HackReshapeEvent
+#define HACK_HANDLE_EVENT Juggler3D_HackHandleEvent
+#define EVENT_MASK PointerMotionMask
+#define SWITCH_OPTS xlockmore_opts
+
+#define DEFAULTS \
+ "*JuggleSpeed: 0.15\n*delay: 20000\n*showFPS: False\n*wireframe: False\n"
+
+#include "xlockmore.h"
+#include "gltrackball.h"
+
+#ifdef USE_GL /* whole file */
+#include <GL/glu.h>
+
+/* A selection of macros to make functions from math.h return single precision
+ * numbers. Arguably it's better to work at a higher precision and cast it
+ * back but littering the code with casts makes it less readable -- without
+ * the casts you can get tons of warnings from the compiler (particularily
+ * MSVC which enables loss of precision warnings by default) */
+
+#define cosf(a) (float)(cos((a)))
+#define sinf(a) (float)(sin((a)))
+#define tanf(a) (float)(tan((a)))
+#define sqrtf(a) (float)(sqrt((a)))
+#define powf(a, b) (float)(pow((a), (b)))
+
+#undef max
+#undef min
+
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#define min(a, b) ((a) < (b) ? (a) : (b))
+
+
+/******************************************************************************
+ *
+ * The code is broadly split into the following parts:
+ *
+ * - Engine. The process of determining the position of the juggler and
+ * objects being juggled at an arbitrary point in time. This is
+ * independent from any drawing code.
+ * - Sites. The process of creating a random site swap pattern or parsing
+ * a Juggle Saver compatible siteswap for use by the engine. For an
+ * introduction to juggling site swaps check out
+ * http://www.jugglingdb.com/
+ * - Rendering. OpenGL drawing code that animates the juggler.
+ * - XScreenSaver. Interface code to get thing working as a GLX hack.
+ *
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ *
+ * Data structures
+ *
+ *****************************************************************************/
+
+/* POS is used to represent the position of a hand when it catches or throws
+ * an object; as well as the orientation of the object. The rotation and
+ * elevation are specified in degrees. These angles are not normalised so that
+ * it is possible to specify how the object spins and rotates as it is thrown
+ * from the 'From' position to the 'To' position.
+ *
+ * Because this is the position of the hand some translation is required with
+ * rings and clubs to get the centre of rotation position. */
+
+typedef struct
+{
+ float x;
+ float y;
+ float z;
+ float Rot;
+ float Elev;
+} POS;
+
+
+/* An array of THROW_INFOs are configured with each entry corresponding to the
+ * position in the site swap (In fact we double up odd length patterns to ensure
+ * there is left/right symmetry). It allows us to quickly determine where an
+ * object and the hands are at a given time. The information is specified in
+ * terms of throws, and positions where throws aren't present (0's and 2's) are
+ * simply ignored.
+ *
+ * TotalTime - The count of beats before this object is thrown again. Typically
+ * this is the same as the weight of the throw but where an object is held it
+ * is longer. e.g. the first throw of the site 64242.7. will be 10, 6 for
+ * throw and 4 (two 2's) for the carry.
+ * TimeInAir - The weight of the throw.
+ * PrevThrow - zero based index into array of THROW_INFOs of the previous throw.
+ * e.g. for the throw '8' in the site 345678..... the PrevThrow is 1
+ * (i.e. the 4)
+ * FromPos, FromVelocity, ToPos, ToVelocity - The position and speeds at the
+ * start and end of the throw. These are used to generate a spline while
+ * carrying an object and while moving the hand from a throw to a catch.
+ * NextForHand - Number of beats before the hand that throws this object will
+ * throw another object. This is always going to be at least 2. When there
+ * are gaps in the pattern (0's) or holds (2's) NextForHand increases. */
+
+typedef struct
+{
+ int TotalTime;
+ int TimeInAir;
+ int PrevThrow;
+
+ POS FromPos;
+ POS FromVelocity;
+ POS ToPos;
+ POS ToVelocity;
+
+ int NextForHand;
+} THROW_INFO;
+
+
+/* OBJECT_POSITION works with the array of THROW_INFOs to allow us to determine
+ * exactly where an object or hand is.
+ *
+ * TimeOffset - The total number of beats expired when the object was thrown.
+ * ThrowIndex - The zero based index into the THROW_INFO array for the current
+ * throw.
+ * ObjectType - One of the OBJECT_XX defines.
+ * TotalTwist - Only relevant for OBJECT_BALL, this is the total amount the ball
+ * has twisted while in the air. When segmented balls are drawn you see a
+ * spinning effect similar to what happens when you juggle beanbags. */
+
+#define OBJECT_DEFAULT 0
+#define OBJECT_BALL 1
+#define OBJECT_CLUB 2
+#define OBJECT_RING 3
+
+typedef struct
+{
+ int TimeOffset;
+ int ThrowIndex;
+ float TotalTwist;
+ int ObjectType;
+} OBJECT_POSITION;
+
+
+/* PATTERN_INFO is the main structure that holds the information about a
+ * juggling pattern.
+ *
+ * pThrowInfo is an array of ThrowLen elements that describes each throw in the
+ * pattern.
+ * pObjectInfo gives the current position of all objects at a given instant.
+ * These values are updated as the pattern is animated.
+ * LeftHand and RightHand describe the current positions of each of the
+ * juggler's hands.
+ * MaxWeight is the maximum weight of the all throws in pThrowInfo.
+ * Height and Alpha are parameters that describe how objects fall under the
+ * influence of gravity. See SetHeightAndAlpha() for the gory details. */
+
+typedef struct
+{
+ THROW_INFO* pThrowInfo;
+ int ThrowLen;
+
+ OBJECT_POSITION* pObjectInfo;
+ int Objects;
+
+ OBJECT_POSITION LeftHand;
+ OBJECT_POSITION RightHand;
+
+ int MaxWeight;
+
+ float Height;
+ float Alpha;
+} PATTERN_INFO;
+
+
+/* EXT_SITE_INFO is used to initialise a PATTERN_INFO object using a Juggle
+ * Saver compatible site swap. These contain additional information about the
+ * type of object thrown, the positions of throw and catch etc. */
+
+#define HAS_FROM_POS 1
+#define HAS_TO_POS 2
+#define HAS_SNATCH 4
+#define HAS_SPINS 8
+
+typedef struct
+{
+ unsigned Flags;
+ int Weight;
+ int ObjectType;
+ POS FromPos;
+ POS ToPos;
+ float SnatchX;
+ float SnatchY;
+ int Spins;
+} EXT_SITE_INFO;
+
+
+/* RENDER_STATE is used to co-ordinate the OpenGL rendering of the juggler and
+ * objects:
+ * pPattern - The pattern to be juggled
+ * CameraElev - The elevation angle (in degrees) that the camera is looking
+ * along. 0 is horizontal and a +ve angle is looking down. This value
+ * should be between -90 and +90.
+ * AspectRatio - Window width to height ratio.
+ * DLStart - The number for the first display list created, any others directly
+ * follow this.
+ * Time - Animation time (in beats)
+ * TranslateAngle - Cumulative translation (in degrees) for the juggling figure.
+ * SpinAngle- Cumulative spin (in degrees) for the juggling figure.
+ */
+
+typedef struct
+{
+ PATTERN_INFO* pPattern;
+ float CameraElev;
+ float AspectRatio;
+ int DLStart;
+
+ float Time;
+ float TranslateAngle;
+ float SpinAngle;
+
+ trackball_state *trackball;
+ Bool button_down_p;
+
+} RENDER_STATE;
+
+
+/*****************************************************************************
+ *
+ * Engine
+ *
+ ****************************************************************************
+ *
+ * The main purpose of the engine is to work out the exact position of all the
+ * juggling objects and the juggler's hands at any point in time. The motion
+ * of the objects can be split into two parts: in the air and and being carried.
+ *
+ * While in the air, the motion is governed by a standard parabolic trajectory.
+ * The only minor complication is that the engine has no fixed concept of
+ * gravity, instead it using a term called Alpha that varies according to the
+ * pattern (see SetHeightAndAlpha).
+ *
+ * The motion while an object is carried comes from fitting a spline through the
+ * catch and throw points and maintaining the catch and throw velocities at
+ * each end. In the simplest case this boils down to cubic Bezier spline. The
+ * only wrinkle occurs when a ball is being carried for a long time. The simple
+ * cubic spline maths produces a curve that goes miles away -- here we do a
+ * bit of reparameterisation so things stay within sensible bounds.
+ * (On a related note, this scheme is _much_ simpler than the Juggle Saver
+ * one. Juggle Saver achieves 2nd order continuity and much care is taken
+ * to avoid spline ringing.)
+ *
+ * The motion of the hands is identical to the ball carrying code. It uses two
+ * splines: one while an object is being carried; and another when it moves from
+ * the previous throw to the next catch.
+ */
+
+const float CARRY_TIME = 0.56f;
+const float PI = 3.14159265358979f;
+
+
+/* While a ball is thrown it twists slighty about an axis, this routine gives
+ * the total about of twist for a given ball throw. */
+
+static float GetBallTwistAmount(const THROW_INFO* pThrow)
+{
+ if (pThrow->FromPos.x > pThrow->ToPos.x)
+ return 18.0f * powf(pThrow->TimeInAir, 1.5);
+ else
+ return -18.0f * powf(pThrow->TimeInAir, 1.5);
+}
+
+
+float NormaliseAngle(float Ang)
+{
+ if (Ang >= 0.0f)
+ {
+ int i = (int) (Ang + 180.0f) / 360;
+ return Ang - 360.0f * i;
+ }
+ else
+ {
+ int i = (int)(180.0f - Ang) / 360;
+ return Ang + i * 360.0f;
+ }
+}
+
+
+/* The interpolate routine for ball carrying and hand motion. We are given the
+ * start (P0) and end (P1) points and the velocities at these points, the task
+ * is to form a function P(t) such that:
+ * P(0) = P0
+ * P(TLen) = P1
+ * P'(0) = V0
+ * P'(TLen) = V1
+ */
+
+static POS InterpolatePosition(
+ const POS* pP0, const POS* pV0, const POS* pP1, const POS* pV1,
+ float TLen, float t)
+{
+ POS p;
+ float a, b, c, d, tt, tc;
+
+ /* The interpolation is based on a simple cubic that achieves 1st order
+ * continuity at the end points. However the spline can become too long if
+ * the TLen parameter is large. In this case we cap the curve's length (fix
+ * the shape) and then reparameterise time to achieve the continuity
+ * conditions. */
+
+ tc = CARRY_TIME;
+
+ if (TLen > tc)
+ {
+ /* The reparameterisation tt(t) gives:
+ * tt(0) = 0, tt(TLen) = tc, tt'(0) = 1, tt'(TLen) = 1
+ * and means we can set t = tt(t), TLen = tc and then fall through
+ * to use the normal cubic spline fit.
+ *
+ * The reparameterisation is based on two piecewise quadratics, one
+ * that goes from t = 0 to t = TLen / 2 and the other, mirrored in
+ * tt and t that goes from t = TLen / 2 to t = TLen.
+ * Because TLen > tc we can arrange for tt to be unique in the range if
+ * we specify the quadratic in tt. i.e. t = A * tt ^ 2 + B * tt + C.
+ *
+ * Considering the first piece and applying initial conditions.
+ * tt = 0 when t = 0 => C = 0
+ * tt' = 1 when t = 0 => B = 1
+ * tt = tc / 2 when t = TLen / 2 => A = 2 * (TLen - tc) / tc^2
+ *
+ * writing in terms of t
+ * tt = (-B + (B ^ 2 + 4At) ^ 0.5) / 2A
+ * or
+ * tt = ((1 + 4At) ^ 0.5 - 1) / 2A */
+
+ float A = 2.0f * (TLen - tc) / (tc * tc);
+
+ if (t > TLen / 2.0f)
+ t = tc - (sqrtf(1.0f + 4.0f * A * (TLen - t)) - 1.0f) / (2.0f * A);
+ else
+ t = (sqrtf(1.0f + 4.0f * A * t) - 1.0f) / (2.0f * A);
+
+ TLen = tc;
+ }
+
+ /* The cubic spline takes the form:
+ * P(t) = p0 * a(t) + v0 * b(t) + p1 * c(t) + v1 * d(t)
+ * where p0 is the start point, v0 the start velocity, p1 the end point and
+ * v1 the end velocity. a(t), b(t), c(t) and d(t) are cubics in t.
+ * We can show that:
+ *
+ * a(t) = 2 * (t / TLen) ^ 3 - 3 * (t / TLen) ^ 2 + 1
+ * b(t) = t ^ 3 / TLen ^ 2 - 2 * t ^ 2 / TLen + t
+ * c(t) = -2 * (t / TLen) ^ 3 + 3 * (t / TLen) ^ 2
+ * d(t) = t ^ 3 / TLen ^ 2 - t ^ 2 / TLen
+ *
+ * statisfy the boundary conditions:
+ * P(0) = p0, P(TLen) = p1, P'(0) = v0 and P'(TLen) = v1 */
+
+ tt = t / TLen;
+
+ a = tt * tt * (2.0f * tt - 3.0f) + 1.0f;
+ b = t * tt * (tt - 2.0f) + t;
+ c = tt * tt * (3.0f - 2.0f * tt);
+ d = t * tt * (tt - 1.0f);
+
+ p.x = a * pP0->x + b * pV0->x + c * pP1->x + d * pV1->x;
+ p.y = a * pP0->y + b * pV0->y + c * pP1->y + d * pV1->y;
+ p.z = a * pP0->z + b * pV0->z + c * pP1->z + d * pV1->z;
+
+ p.Rot = a * NormaliseAngle(pP0->Rot) + b * pV0->Rot +
+ c * NormaliseAngle(pP1->Rot) + d * pV1->Rot;
+ p.Elev = a * NormaliseAngle(pP0->Elev) + b * pV0->Elev +
+ c * NormaliseAngle(pP1->Elev) + d * pV1->Elev;
+
+ return p;
+}
+
+
+static POS InterpolateCarry(
+ const THROW_INFO* pThrow, const THROW_INFO* pNext, float t)
+{
+ float CT = CARRY_TIME + pThrow->TotalTime - pThrow->TimeInAir;
+ return InterpolatePosition(&pThrow->ToPos, &pThrow->ToVelocity,
+ &pNext->FromPos, &pNext->FromVelocity, CT, t);
+}
+
+
+/* Determine the position of the hand at a point in time. */
+
+void GetHandPosition(
+ PATTERN_INFO* pPattern, int RightHand, float Time, POS* pPos)
+{
+ OBJECT_POSITION* pObj =
+ RightHand == 0 ? &pPattern->LeftHand : &pPattern->RightHand;
+ THROW_INFO* pLastThrow;
+
+ /* Upon entry, the throw information for the relevant hand may be out of
+ * sync. Therefore we advance through the pattern if required. */
+
+ while (pPattern->pThrowInfo[pObj->ThrowIndex].NextForHand + pObj->TimeOffset
+ <= (int) Time)
+ {
+ int w = pPattern->pThrowInfo[pObj->ThrowIndex].NextForHand;
+ pObj->TimeOffset += w;
+ pObj->ThrowIndex = (pObj->ThrowIndex + w) % pPattern->ThrowLen;
+ }
+
+ pLastThrow = &pPattern->pThrowInfo[pObj->ThrowIndex];
+
+ /* The TimeInAir will only ever be 2 or 0 if no object is ever thrown by
+ * this hand. In normal circumstances, 2's in the site swap are coalesced
+ * and added to TotalTime of the previous throw. 0 is a hole and means that
+ * an object isn't there. In this case we just hold the hand still. */
+ if (pLastThrow->TimeInAir == 2 || pLastThrow->TimeInAir == 0)
+ {
+ pPos->x = pLastThrow->FromPos.x;
+ pPos->y = pLastThrow->FromPos.y;
+ }
+ else
+ {
+ /* The hand is either moving to catch the next object or carrying the
+ * next object to its next throw position. The way THROW_INFO is
+ * structured means the relevant information for the object we're going
+ * to catch is held at the point at which it was thrown
+ * (pNextThrownFrom). We can't go straight for it and instead have to
+ * look at the object we've about to throw next and work out where it
+ * came from. */
+
+ THROW_INFO* pNextThrow = &pPattern->pThrowInfo[
+ (pObj->ThrowIndex + pLastThrow->NextForHand) % pPattern->ThrowLen];
+
+ THROW_INFO* pNextThrownFrom =
+ &pPattern->pThrowInfo[pNextThrow->PrevThrow];
+
+ /* tc is a measure of how long the object we're due to catch is being
+ * carried for. We use this to work out if we've actually caught it at
+ * this moment in time. */
+
+ float tc = CARRY_TIME +
+ pNextThrownFrom->TotalTime - pNextThrownFrom->TimeInAir;
+
+ Time -= pObj->TimeOffset;
+
+ if (Time > pLastThrow->NextForHand - tc)
+ {
+ /* carrying this ball to it's new location */
+ *pPos = InterpolateCarry(pNextThrownFrom,
+ pNextThrow, (Time - (pLastThrow->NextForHand - tc)));
+ }
+ else
+ {
+ /* going for next catch */
+ *pPos = InterpolatePosition(
+ &pLastThrow->FromPos, &pLastThrow->FromVelocity,
+ &pNextThrownFrom->ToPos, &pNextThrownFrom->ToVelocity,
+ pLastThrow->NextForHand - tc, Time);
+ }
+ }
+}
+
+
+static float SinDeg(float AngInDegrees)
+{
+ return sinf(AngInDegrees * PI / 180.0f);
+}
+
+
+static float CosDeg(float AngInDegrees)
+{
+ return cosf(AngInDegrees * PI / 180.0f);
+}
+
+
+/* Offset the specified position to get the centre of the object based on the
+ * the handle length and the current orientation */
+
+static void OffsetHandlePosition(const POS* pPos, float HandleLen, POS* pResult)
+{
+ pResult->x = pPos->x + HandleLen * SinDeg(pPos->Rot) * CosDeg(pPos->Elev);
+ pResult->y = pPos->y + HandleLen * SinDeg(pPos->Elev);
+ pResult->z = pPos->z + HandleLen * CosDeg(pPos->Rot) * CosDeg(pPos->Elev);
+ pResult->Elev = pPos->Elev;
+ pResult->Rot = pPos->Rot;
+}
+
+
+static void GetObjectPosition(
+ PATTERN_INFO* pPattern, int Obj, float Time, float HandleLen, POS* pPos)
+{
+ OBJECT_POSITION* pObj = &pPattern->pObjectInfo[Obj];
+ THROW_INFO* pThrow;
+
+ /* Move through the pattern, if required, such that pThrow corresponds to
+ * the current throw for this object. */
+
+ while (pPattern->pThrowInfo[pObj->ThrowIndex].TotalTime + pObj->TimeOffset
+ <= (int) Time)
+ {
+ int w = pPattern->pThrowInfo[pObj->ThrowIndex].TotalTime;
+ pObj->TimeOffset += w;
+ pObj->TotalTwist = NormaliseAngle(pObj->TotalTwist +
+ GetBallTwistAmount(&pPattern->pThrowInfo[pObj->ThrowIndex]));
+
+ pObj->ThrowIndex = (pObj->ThrowIndex + w) % pPattern->ThrowLen;
+ }
+
+ pThrow = &pPattern->pThrowInfo[pObj->ThrowIndex];
+
+ if (pThrow->TimeInAir == 2 || pThrow->TimeInAir == 0)
+ {
+ *pPos = pThrow->FromPos;
+ OffsetHandlePosition(pPos, HandleLen, pPos);
+ }
+ else
+ {
+ float tc = pThrow->TimeInAir - CARRY_TIME;
+ float BallTwist = GetBallTwistAmount(pThrow);
+ Time -= pObj->TimeOffset;
+ if (Time < tc)
+ {
+ /* object in air */
+ POS From, To;
+ float t, b;
+
+ t = Time / tc;
+
+ OffsetHandlePosition(&pThrow->FromPos, HandleLen, &From);
+ OffsetHandlePosition(&pThrow->ToPos, HandleLen, &To);
+
+ b = (To.y - From.y) / tc + pPattern->Alpha * tc;
+
+ pPos->x = (1.0f - t) * From.x + t * To.x;
+ pPos->z = (1.0f - t) * From.z + t * To.z;
+ pPos->y = -pPattern->Alpha * Time * Time + b * Time + From.y;
+
+ if (pObj->ObjectType == OBJECT_BALL)
+ pPos->Rot = pObj->TotalTwist + t * BallTwist;
+ else
+ {
+ /* We describe the rotation of a club (or ring) with an
+ * elevation and rotation but don't include a twist.
+ * If we ignore twist for the moment, the orientation at a
+ * rotation of r and an elevation of e can be also be expressed
+ * by rotating the object a further 180 degrees and sort of
+ * mirroring the rotation, e.g.:
+ * rot = r + 180 and elev = 180 - e
+ * We can easily show that the maths holds, consider the
+ * x, y ,z position of the end of a unit length club.
+ * y = sin(180 - e) = sin(e)
+ * x = cos(180 - e) * sin(r + 180) = -cos(e) * - sin(r)
+ * z = cos(180 - e) * cos(r + 180) = -cos(e) * - cos(r)
+ * When a club is thrown these two potential interpretations
+ * can produce unexpected results.
+ * The approach we adopt is that we try and minimise the amount
+ * of rotation we give a club -- normally this is what happens
+ * when juggling since it's much easier to spin the club.
+ *
+ * When we come to drawing the object the two interpretations
+ * aren't identical, one causes the object to twist a further
+ * 180 about its axis. We avoid the issue by ensuring our
+ * objects have rotational symmetry of order 2 (e.g. we make
+ * sure clubs have an even number of stripes) this makes the two
+ * interpretations appear identical. */
+
+ float RotAmt = NormaliseAngle(To.Rot - From.Rot);
+
+ if (RotAmt < -90.0f)
+ {
+ To.Elev += 180 - 2 * NormaliseAngle(To.Elev);
+ RotAmt += 180.0f;
+ }
+ else if (RotAmt > 90.0f)
+ {
+ To.Elev += 180 - 2 * NormaliseAngle(To.Elev);
+ RotAmt -= 180.0f;
+ }
+
+ pPos->Rot = From.Rot + t * RotAmt;
+ }
+
+ pPos->Elev = (1.0f - t) * From.Elev + t * To.Elev;
+
+ }
+ else
+ {
+ THROW_INFO* pNextThrow = &pPattern->pThrowInfo[
+ (pObj->ThrowIndex + pThrow->TotalTime) % pPattern->ThrowLen];
+
+ *pPos = InterpolateCarry(pThrow, pNextThrow, Time - tc);
+
+ if (pObj->ObjectType == OBJECT_BALL)
+ pPos->Rot = pObj->TotalTwist + BallTwist;
+
+ OffsetHandlePosition(pPos, HandleLen, pPos);
+ }
+ }
+}
+
+
+/* Alpha is used to represent the acceleration due to gravity (in fact
+ * 2 * Alpha is the acceleration). Alpha is adjusted according to the pattern
+ * being juggled. My preference is to slow down patterns with lots of objects
+ * -- they move too fast in realtime. Also I prefer to see a balance between
+ * the size of the figure and the height of objects thrown -- juggling patterns
+ * with large numbers of objects under real gravity can mean balls are lobbed
+ * severe heights. Adjusting Alpha achieves both these goals.
+ *
+ * Basically we pick a height we'd like to see the biggest throw reach and then
+ * adjust Alpha to meet this. */
+
+static void SetHeightAndAlpha(PATTERN_INFO* pPattern,
+ const int* Site, const EXT_SITE_INFO* pExtInfo, int Len)
+{
+ float H;
+ int MaxW = 5;
+ int i;
+
+ if (Site != NULL)
+ {
+ for (i = 0; i < Len; i++)
+ MaxW = max(MaxW, Site[i]);
+ }
+ else
+ {
+ for (i = 0; i < Len; i++)
+ MaxW = max(MaxW, pExtInfo[i].Weight);
+ }
+
+ /* H is the ideal max height we'd like our objects to reach. The formula
+ * was developed by trial and error and was simply stolen from Juggle Saver.
+ * Alpha is then calculated from the classic displacement formula:
+ * s = 0.5at^2 + ut (where a = 2 * Alpha)
+ * We know u (the velocity) is zero at the peak, and the object should fall
+ * H units in half the time of biggest throw weight.
+ * Finally we determine the proper height the max throw reaches since this
+ * may not be H because capping may be applied (e.g. for max weights less
+ * than 5). */
+
+ H = 8.0f * powf(MaxW / 2.0f, 0.8f) + 5.0f;
+ pPattern->Alpha = (2.0f * H) / powf(max(5, MaxW) - CARRY_TIME, 2.0f);
+ pPattern->Height = pPattern->Alpha * powf((MaxW - CARRY_TIME) * 0.5f, 2);
+}
+
+
+/* Where positions and spin info is not specified, generate suitable default
+ * values. */
+
+static int GetDefaultSpins(int Weight)
+{
+ if (Weight < 3)
+ return 0;
+ else if (Weight < 4)
+ return 1;
+ else if (Weight < 7)
+ return 2;
+ else
+ return 3;
+}
+
+
+static void GetDefaultFromPosition(unsigned char Side, int Weight, POS* pPos)
+{
+ if (Weight > 4 && Weight % 2 != 0)
+ pPos->x = Side ? -0.06f : 0.06f;
+ else if (Weight == 0 || Weight == 2)
+ pPos->x = Side ? 1.6f : -1.6f;
+ else
+ pPos->x = Side? 0.24f : -0.24f;
+
+ pPos->y = (Weight == 2 || Weight == 0) ? -0.25f : 0.0f;
+
+ pPos->Rot = (Weight % 2 == 0 ? -23.5f : 27.0f) * (Side ? -1.0f : 1.0f);
+
+ pPos->Elev = Weight == 1 ? -30.0f : 0.0f;
+ pPos->z = 0.0f;
+}
+
+
+static void GetDefaultToPosition(unsigned char Side, int Weight, POS* pPos)
+{
+ if (Weight == 1)
+ pPos->x = Side ? -1.0f : 1.0f;
+ else if (Weight % 2 == 0)
+ pPos->x = Side ? 2.8f : -2.8f;
+ else
+ pPos->x = Side? -3.1f : 3.1f;
+
+ pPos->y = -0.5f;
+
+ pPos->Rot = (Side ? -35.0f : 35.0f) * (Weight % 2 == 0 ? -1.0f : 1.0f);
+
+ if (Weight < 2)
+ pPos->Elev = -30.0f;
+
+ else if (Weight < 4)
+ pPos->Elev = 360.0f - 50.0f;
+ else if (Weight < 7)
+ pPos->Elev = 720.0f - 50.0f;
+ else
+ pPos->Elev = 360.0f * GetDefaultSpins(Weight) - 50.0f;
+ pPos->z = 0.0f;
+}
+
+
+/* Update the members of PATTERN_INFO for a given juggling pattern. The pattern
+ * can come from an ordinary siteswap (Site != NULL) or from a Juggle Saver
+ * compatible pattern that contains, position and object info etc.
+ * We assume that patterns are valid and have at least one object (a site of
+ * zeros is invalid). The ones we generate randomly are safe. */
+
+static void InitPatternInfo(PATTERN_INFO* pPattern,
+ const int* Site, const EXT_SITE_INFO* pExtInfo, int Len)
+{
+ /* Double up on the length of the site if it's of an odd length.
+ * This way we can store position information: even indices are on one
+ * side and odds are on the other. */
+ int InfoLen = Len % 2 == 1 ? Len * 2 : Len;
+ int i;
+ THROW_INFO* pInfo = (THROW_INFO*) calloc(InfoLen, sizeof(THROW_INFO));
+ int Objects = 0;
+ unsigned char* pUsed;
+
+ pPattern->MaxWeight = 0;
+ pPattern->ThrowLen = InfoLen;
+ pPattern->pThrowInfo = pInfo;
+
+ SetHeightAndAlpha(pPattern, Site, pExtInfo, Len);
+
+ /* First pass through we assign the things we know about for sure just by
+ * looking at the throw weight at this position. This includes TimeInAir;
+ * the throw and catch positions; and throw and catch velocities.
+ * Other information, like the total time for the throw (i.e. when the
+ * object is thrown again) relies on how the rest of the pattern is
+ * structured and we defer this task for successive passes and just make
+ * guesses at this stage. */
+
+ for (i = 0; i < InfoLen; i++)
+ {
+ float t1;
+ int w = pExtInfo != NULL ? pExtInfo[i % Len].Weight : Site[i % Len];
+
+ pInfo[i].TotalTime = pInfo[i].TimeInAir = w;
+ pInfo[(w + i) % Len].PrevThrow = i;
+
+ /* work out where we are throwing this object from and where it's going
+ * to land. */
+
+ if (pExtInfo == NULL || (pExtInfo[i % Len].Flags & HAS_FROM_POS) == 0)
+ GetDefaultFromPosition(i % 2, w, &pInfo[i].FromPos);
+ else
+ pInfo[i].FromPos = pExtInfo[i % Len].FromPos;
+
+ if (pExtInfo == NULL || (pExtInfo[i % Len].Flags & HAS_TO_POS) == 0)
+ GetDefaultToPosition(i % 2, w, &pInfo[i].ToPos);
+ else
+ pInfo[i].ToPos = pExtInfo[i % Len].ToPos;
+
+ /* calculate the velocity the object is moving at the start and end
+ * points -- this information is used to interpolate the hand position
+ * and to determine how the object is moved while it's carried to the
+ * next throw position.
+ *
+ * The throw motion is governed by a parabola of the form:
+ * y(t) = a * t ^ 2 + b * t + c
+ * Assuming at the start of the throw y(0) = y0; when it's caught
+ * y(t1) = y1; and the accelation is -2.0 * alpha the equation can be
+ * rewritten as:
+ * y(t) = -alpha * t ^ 2 + (alpha * t1 + (y1 - y0) / t1) * t + y0
+ * making the velocity:
+ * y'(t) = -2.0 * alpha * t + (alpha * t1 + (y1 - y0) / t1)
+ * To get the y component of velocity first we determine t1, which is
+ * the throw weight minus the time spent carrying the object. Then
+ * perform the relevant substitutions into the above.
+ * (note: y'(t) = y'(0) - 2.0 * alpha * t)
+ *
+ * The velocity in the x direction is constant and can be simply
+ * obtained from:
+ * x' = (x1 - x0) / t1
+ * where x0 and x1 are the start and end x-positions respectively.
+ */
+
+ t1 = w - CARRY_TIME;
+
+ pInfo[i].FromVelocity.y = pPattern->Alpha * t1 +
+ (pInfo[i].ToPos.y - pInfo[i].FromPos.y) / t1;
+ pInfo[i].ToVelocity.y =
+ pInfo[i].FromVelocity.y - 2.0f * pPattern->Alpha * t1;
+ pInfo[i].FromVelocity.x = pInfo[i].ToVelocity.x =
+ (pInfo[i].ToPos.x - pInfo[i].FromPos.x) / t1;
+ pInfo[i].FromVelocity.z = pInfo[i].ToVelocity.z =
+ (pInfo[i].ToPos.z - pInfo[i].FromPos.z) / t1;
+ pInfo[i].FromVelocity.Rot = pInfo[i].ToVelocity.Rot =
+ (pInfo[i].ToPos.Rot - pInfo[i].FromPos.Rot) / t1;
+ pInfo[i].FromVelocity.Elev = pInfo[i].ToVelocity.Elev =
+ (pInfo[i].ToPos.Elev - pInfo[i].FromPos.Elev) / t1;
+
+
+ if (pExtInfo != NULL && (pExtInfo[i % Len].Flags & HAS_SNATCH) != 0)
+ {
+ pInfo[i].ToVelocity.x = pExtInfo[i % Len].SnatchX;
+ pInfo[i].ToVelocity.y = pExtInfo[i % Len].SnatchY;
+ }
+
+ if (pExtInfo != NULL && (pExtInfo[i % Len].Flags & HAS_SPINS) != 0)
+ {
+ pInfo[i].ToPos.Elev = 360.0f * pExtInfo[i % Len].Spins +
+ NormaliseAngle(pInfo[i].ToPos.Elev);
+ }
+
+ Objects += w;
+ if (w > pPattern->MaxWeight)
+ pPattern->MaxWeight = w;
+ }
+
+ Objects /= InfoLen;
+
+ /* Now we go through again and work out exactly how long it is before the
+ * object is thrown again (ie. the TotalTime) typically this is the same
+ * as the time in air, however when we have a throw weight of '2' it's
+ * treated as a hold and we increase the total time accordingly. */
+
+ for (i = 0; i < InfoLen; i++)
+ {
+ if (pInfo[i].TimeInAir != 2)
+ {
+ int Next = pInfo[i].TimeInAir + i;
+ while (pInfo[Next % InfoLen].TimeInAir == 2)
+ {
+ Next += 2;
+ pInfo[i].TotalTime += 2;
+ }
+
+ /* patch up the Prev index. We don't bother to see if this
+ * is different from before since it's always safe to reassign it */
+ pInfo[Next % InfoLen].PrevThrow = i;
+ }
+ }
+
+ /* then we work our way through again figuring out where the hand goes to
+ * catch something as soon as it has thrown the current object. */
+
+ for (i = 0; i < InfoLen; i++)
+ {
+ if (pInfo[i].TimeInAir != 0 && pInfo[i].TimeInAir != 2)
+ {
+ /* what we're trying to calculate is how long the hand that threw
+ * the current object has to wait before it throws another.
+ * Typically this is two beats later. However '0' in the site swap
+ * represents a gap in a catch, and '2' represents a hold. We skip
+ * over these until we reach the point where a ball is actually
+ * thrown. */
+ int Wait = 2;
+ while (pInfo[(i + Wait) % InfoLen].TimeInAir == 2 ||
+ pInfo[(i + Wait) % InfoLen].TimeInAir == 0)
+ {
+ Wait += 2;
+ }
+ pInfo[i].NextForHand = Wait;
+ }
+ else
+ {
+ /* Be careful to ensure the current weight isn't one we're trying
+ * to step over; otherwise we could potentially end up in an
+ * infinite loop. The value we assign may end up being used
+ * in patterns with infinite gaps (e.g. 60) or infinite holds
+ * (e.g. 62) in both cases, setting a wait of 2 ensures things
+ * are well behaved. */
+ pInfo[i].NextForHand = 2;
+ }
+ }
+
+ /* Now work out the starting positions for the objects. To do this we
+ * unweave the initial throws so we can pick out the individual threads. */
+
+ pUsed = (unsigned char*)
+ malloc(sizeof(unsigned char) * pPattern->MaxWeight);
+ pPattern->Objects = Objects;
+ pPattern->pObjectInfo = (OBJECT_POSITION*) calloc(
+ Objects, sizeof(OBJECT_POSITION));
+
+ for (i = 0; i < pPattern->MaxWeight; i++)
+ pUsed[i] = 0;
+
+ for (i = 0; i < pPattern->MaxWeight; i++)
+ {
+ int w = pInfo[i % InfoLen].TimeInAir;
+ if (pUsed[i] == 0 && w != 0)
+ {
+ Objects--;
+ pPattern->pObjectInfo[Objects].TimeOffset = i;
+ pPattern->pObjectInfo[Objects].ThrowIndex = i % InfoLen;
+ pPattern->pObjectInfo[Objects].TotalTwist = 0.0f;
+
+ if (pExtInfo != NULL &&
+ pExtInfo[i % Len].ObjectType != OBJECT_DEFAULT)
+ {
+ pPattern->pObjectInfo[Objects].ObjectType =
+ pExtInfo[i % Len].ObjectType;
+ }
+ else
+ {
+ pPattern->pObjectInfo[Objects].ObjectType = (1 + random() % 3);
+ }
+ }
+
+ if (w + i < pPattern->MaxWeight)
+ pUsed[w + i] = 1;
+
+ }
+
+ pPattern->LeftHand.TimeOffset = pPattern->LeftHand.ThrowIndex = 0;
+ pPattern->RightHand.TimeOffset = pPattern->RightHand.ThrowIndex = 1;
+
+ free(pUsed);
+}
+
+
+static void ReleasePatternInfo(PATTERN_INFO* pPattern)
+{
+ free(pPattern->pObjectInfo);
+ free(pPattern->pThrowInfo);
+}
+
+
+/*****************************************************************************
+ *
+ * Sites
+ *
+ ****************************************************************************/
+
+/* Generate a random site swap. We assume that MaxWeight >= ObjCount and
+ * Len >= MaxWeight. */
+
+static int* Generate(int Len, int MaxWeight, int ObjCount)
+{
+ int* Weight = (int*) calloc(Len, sizeof(int));
+ int* Used = (int*) calloc(Len, sizeof(int));
+ int* Options = (int*) calloc(MaxWeight + 1, sizeof(int));
+ int nOpts;
+ int i, j;
+
+ for (i = 0; i < Len; i++)
+ Weight[i] = Used[i] = -1;
+
+ /* Pick out a unique the starting position for each object. -2 is put in
+ * the Used array to signify this is a starting position. */
+
+ while (ObjCount > 0)
+ {
+ nOpts = 0;
+ for (j = 0; j < MaxWeight; j++)
+ {
+ if (Used[j] == -1)
+ Options[nOpts++] = j;
+ }
+
+ Used[Options[random() % nOpts]] = -2;
+ ObjCount--;
+ }
+
+ /* Now work our way through the pattern moving throws into an available
+ * landing positions. */
+ for (i = 0; i < Len; i++)
+ {
+ if (Used[i] == -1)
+ {
+ /* patch up holes in the pattern to zeros */
+ Used[i] = 1;
+ Weight[i] = 0;
+ }
+ else
+ {
+ /* Work out the possible places where a throw can land and pick a
+ * weight at random. */
+ int w;
+ nOpts = 0;
+
+ for (j = 0 ; j <= MaxWeight; j++)
+ {
+ if (Used[(i + j) % Len] == -1)
+ Options[nOpts++] = j;
+ }
+
+ w = Options[random() % nOpts];
+ Weight[i] = w;
+
+ /* For starting throws make position available for a throw to land.
+ * Because Len >= MaxWeight these positions will only be filled when
+ * a throw wraps around the end of the site swap and therefore we
+ * can guarantee the all the object threads will be tied up. */
+ if (Used[i] == -2)
+ Used[i] = -1;
+
+ Used[(i + w) % Len] = 1;
+ }
+ }
+
+ free(Options);
+ free(Used);
+ return Weight;
+}
+
+
+/* Routines to parse the Juggle Saver patterns. These routines are a bit yucky
+ * and make the big assumption that the patterns are well formed. This is fine
+ * as it stands because only 'good' ones are used but if the code is ever
+ * extended to read arbitrary patterns (say from a file) then these routines
+ * need to be beefed up. */
+
+/* The position text looks something like (x,y,z[,rot[,elev]])
+ * where the stuff in square brackets is optional */
+
+static unsigned char ParsePositionText(const char** ppch, POS* pPos)
+{
+ const char* pch = *ppch;
+ unsigned char OK;
+ char szTemp[32];
+ char* pOut;
+ float* Nums[4];
+ int i;
+
+ Nums[0] = &pPos->x;
+ Nums[1] = &pPos->y;
+ Nums[2] = &pPos->Rot;
+ Nums[3] = &pPos->Elev;
+
+
+ while (*pch == ' ')
+ pch++;
+
+ OK = *pch == '(';
+
+ if (OK)
+ pch++;
+
+ for (i = 0; OK && i < 4; i++)
+ {
+ pOut = szTemp;
+ while (*pch == ' ')
+ pch++;
+ while (*pch != ',' && *pch != '\0' && *pch != ')' && *pch != ' ')
+ *pOut++ = *pch++;
+ *pOut = '\0';
+
+ if (szTemp[0] != '\0')
+ *Nums[i] = (float) atof(szTemp);
+
+ while (*pch == ' ')
+ pch++;
+
+ if (i < 3)
+ {
+ if (*pch == ',')
+ pch++;
+ else if (*pch == ')')
+ break;
+ else
+ OK = 0;
+ }
+ }
+
+ if (OK)
+ {
+ while (*pch == ' ')
+ pch++;
+ if (*pch == ')')
+ pch++;
+ else
+ OK = 0;
+ }
+
+ *ppch = pch;
+
+ return OK;
+}
+
+
+static EXT_SITE_INFO* ParsePattern(const char* Site, int* pLen)
+{
+ const char* pch = Site;
+ int Len = 0;
+ EXT_SITE_INFO* pInfo = NULL;
+ unsigned char OK = 1;
+
+ while (OK && *pch != 0)
+ {
+ EXT_SITE_INFO Info;
+ Info.Flags = 0;
+
+ while (*pch == ' ') pch++;
+
+ OK = *pch != '\0';
+
+ if (OK)
+ Info.Weight = *pch >= 'A' ? *pch + 10 - 'A' : *pch - '0';
+
+ /* parse object type */
+ if (OK)
+ {
+ pch++;
+ while (*pch == ' ') pch++;
+
+ if (*pch == 'b' || *pch == 'B')
+ {
+ Info.ObjectType = OBJECT_BALL;
+ pch++;
+ }
+ else if (*pch == 'c' || *pch == 'C')
+ {
+ Info.ObjectType = OBJECT_CLUB;
+ pch++;
+ }
+ else if (*pch == 'r' || *pch == 'R')
+ {
+ Info.ObjectType = OBJECT_RING;
+ pch++;
+ }
+ else if (*pch == 'd' || *pch == 'D')
+ {
+ Info.ObjectType = OBJECT_DEFAULT;
+ pch++;
+ }
+ else
+ {
+ Info.ObjectType = OBJECT_DEFAULT;
+ }
+ }
+
+ /* Parse from position */
+ if (OK)
+ {
+ while (*pch == ' ') pch++;
+ if (*pch == '@')
+ {
+ pch++;
+ GetDefaultFromPosition(Len % 2, Info.Weight, &Info.FromPos);
+ Info.Flags |= HAS_FROM_POS;
+ OK = ParsePositionText(&pch, &Info.FromPos);
+ }
+ }
+
+ /* Parse to position */
+ if (OK)
+ {
+ while (*pch == ' ') pch++;
+ if (*pch == '>')
+ {
+ pch++;
+ GetDefaultToPosition(Len % 2, Info.Weight, &Info.ToPos);
+ Info.Flags |= HAS_TO_POS;
+ OK = ParsePositionText(&pch, &Info.ToPos);
+ }
+ }
+
+ /* Parse snatch */
+ if (OK)
+ {
+ while (*pch == ' ') pch++;
+ if (*pch == '/')
+ {
+ POS Snatch;
+ pch++;
+ Info.Flags |= HAS_SNATCH;
+ OK = ParsePositionText(&pch, &Snatch);
+ Info.SnatchX = Snatch.x;
+ Info.SnatchY = Snatch.y;
+ }
+ }
+
+ /* Parse Spins */
+ if (OK)
+ {
+ while (*pch == ' ') pch++;
+ if (*pch == '*')
+ {
+ pch++;
+ OK = 0;
+ Info.Spins = 0;
+ while (*pch >= '0' && *pch <= '9')
+ {
+ OK = 1;
+ Info.Spins = Info.Spins * 10 + *pch - '0';
+ pch++;
+ }
+ }
+ else
+ Info.Spins = GetDefaultSpins(Info.Weight);
+
+ Info.Flags |= HAS_SPINS;
+ }
+
+ if (OK)
+ {
+ if (pInfo == NULL)
+ pInfo = (EXT_SITE_INFO*) malloc(sizeof(EXT_SITE_INFO));
+ else
+ pInfo = (EXT_SITE_INFO*) realloc(pInfo, (Len + 1) * sizeof(EXT_SITE_INFO));
+
+ pInfo[Len] = Info;
+ Len++;
+ }
+ }
+
+ if (!OK && pInfo != NULL)
+ {
+ free(pInfo);
+ pInfo = NULL;
+ }
+
+ *pLen = Len;
+
+ return pInfo;
+}
+
+
+/*****************************************************************************
+ *
+ * Juggle Saver Patterns
+ *
+ *****************************************************************************
+ *
+ * This is a selection of some of the more interesting patterns from taken
+ * from the Juggle Saver sites.txt file. I've only used patterns that I
+ * originally created.
+ */
+
+const char* PatternText[] =
+{
+ "9b@(-2.5,0,-70,40)>(2.5,0,70)*2 1b@(1,0,10)>(-1,0,-10)",
+
+ "3B@(1,-0.4)>(2,4.2)/(-2,1)3B@(-1.8,4.4)>(-2.1,0)",
+
+ "7c@(-2,0,-20)>(1.2,0,-5)7c@(2,0,20)>(-1.2,0,5)",
+
+ "3b@(-0.5,0)>(1.5,0) 3b@(0.5,0)>(-1.5,0) 3r@(-2.5,3,-90,80)>(2,1,90,30)"
+ "3b@(0.5,0)>(-1.5,0) 3b@(-0.5,0)>(1.5,0) 3r@(2.5,3,90,80)>(-2,1,-90,30)",
+
+ "5c@(2,1.9,10)>(-1,1,10)5c@(2,1.8,10)>(-0.5,1.6,10)/(5,-1)"
+ "5c@(1.6,0.2,10)>(0,-1,10)/(9,-2)5c@(-2,1.9,-10)>(1,1,-10)"
+ "5c@(-2,1.8,-10)>(0.5,1.6,-10)/(-5,-1)5@(-1.6,0.2,-10)>(0,-1,-10)/(-9,-2)",
+
+ "3c@(-1.5,0,0)>(-1.5,1,0)3c@(1.5,-0.2,0)>(1.5,-0.1,0)3c@(0,-0.5,0)>(0,1,0)"
+ "3@(-1.5,2,0)>(-1.5,-1,0)3@(1.5,0,0)>(1.5,1,0)3@(0,0,0)>(0,-0.5,0)",
+
+ "9c@(-2.5,0,-70,40)>(2.5,0,70)*2 1c@(1,0,10)>(-1,0,-10)*0",
+
+ "3c@(2,0.5,60,0)>(1.5,4,60,80)/(-6,-12)"
+ "3c@(-2,0.5,-60,0)>(-1.5,4,-60,80)/(6,-12)",
+
+ "3c@(-0.2,0)>(1,0)3c@(0.2,0)>(-1,0)3c@(-2.5,2,-85,30)>(2.5,2,85,40)*2 "
+ "3@(0.2,0)>(-1,0) 3@(-0.2,0)>(1,0) 3@(2.5,2,85,30)>(-2.5,2,-85,40)*2",
+
+ "3c@(-0.5,-0.5,20,-30)>(2.6,4.3,60,60)/(0,1)*1 "
+ "3c@(1.6,5.6,60,80)>(-2.6,0,-80)*0",
+
+ "5c@(-0.3,0,10)>(1.2,0,10) 5c@(0.3,0,-10)>(-1.2,0,-10)"
+ "5c@(-0.3,0,10)>(1.2,0,10) 5c@(0.3,0,-10)>(-1.2,0,-10)"
+ "5c@(-3,3.5,-65,80)>(3,2.5,65) 5c@(0.3,0,-10)>(-1.2,0,-10)"
+ "5@(-0.3,0,10)>(1.2,0,10) 5@(0.3,0,-10)>(-1.2,0,-10)"
+ "5@(-0.3,0,10)>(1.2,0,10)5@(3,3.5,65,80)>(-3,2.5,-65)"
+};
+
+
+/*****************************************************************************
+ *
+ * Rendering
+ *
+ *****************************************************************************/
+
+static const float FOV = 70.0f;
+static const float BodyCol[] = {0.6f, 0.6f, 0.45f, 1.0f};
+static const float HandleCol[] = {0.45f, 0.45f, 0.45f, 1.0f};
+static const float LightPos[] = {0.0f, 200.0f, 400.0f, 1.0f};
+static const float LightDiff[] = {1.0f, 1.0f, 1.0f, 0.0f};
+static const float LightAmb[] = {0.02f, 0.02f, 0.02f, 0.0f};
+static const float ShoulderPos[3] = {0.95f, 2.1f, 1.7f};
+static const float DiffCol[] = {1.0f, 0.0f, 0.0f, 1.0f};
+static const float SpecCol[] = {1.0f, 1.0f, 1.0f, 1.0f};
+
+static const float BallRad = 0.34f;
+static const float UArmLen = 1.9f;
+static const float LArmLen = 2.3f;
+
+#define DL_BALL 0
+#define DL_CLUB 1
+#define DL_RING 2
+#define DL_TORSO 3
+#define DL_FOREARM 4
+#define DL_UPPERARM 5
+
+static const float AltCols[][4] =
+{
+ {0.0f, 0.7f, 0.0f, 1.0f},
+ {0.0f, 0.0f, 0.9f, 1.0f},
+ {0.0f, 0.9f, 0.9f, 1.0f},
+ {0.45f, 0.0f, 0.9f, 1.0f},
+ {0.9f, 0.45f, 0.0f, 1.0f},
+ {0.0f, 0.45f, 0.9f, 1.0f},
+ {0.9f, 0.0f, 0.9f, 1.0f},
+ {0.9f, 0.9f, 0.0f, 1.0f},
+ {0.9f, 0.0f, 0.45f, 1.0f},
+ {0.45f, 0.15f, 0.6f, 1.0f},
+ {0.9f, 0.0f, 0.0f, 1.0f},
+ {0.0f, 0.9f, 0.45f, 1.0f},
+};
+
+static const float Cols[][4] =
+{
+ {0.9f, 0.0f, 0.0f, 1.0f}, /* 0 */
+ {0.0f, 0.7f, 0.0f, 1.0f}, /* 1 */
+ {0.0f, 0.0f, 0.9f, 1.0f}, /* 2 */
+ {0.0f, 0.9f, 0.9f, 1.0f}, /* 3 */
+ {0.9f, 0.0f, 0.9f, 1.0f}, /* 4 */
+ {0.9f, 0.9f, 0.0f, 1.0f}, /* 5 */
+ {0.9f, 0.45f, 0.0f, 1.0f}, /* 6 */
+ {0.9f, 0.0f, 0.45f, 1.0f}, /* 7 */
+ {0.45f, 0.9f, 0.0f, 1.0f}, /* 8 */
+ {0.0f, 0.9f, 0.45f, 1.0f}, /* 9 */
+ {0.45f, 0.0f, 0.9f, 1.0f}, /* 10 */
+ {0.0f, 0.45f, 0.9f, 1.0f}, /* 11 */
+};
+
+static int InitGLDisplayLists(void);
+
+
+void InitGLSettings(RENDER_STATE* pState, int WireFrame)
+{
+ memset(pState, 0, sizeof(RENDER_STATE));
+
+ pState->trackball = gltrackball_init ();
+
+ if (WireFrame)
+ glPolygonMode(GL_FRONT, GL_LINE);
+
+ glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+ glLightfv(GL_LIGHT0, GL_POSITION, LightPos);
+ glLightfv(GL_LIGHT0, GL_DIFFUSE, LightDiff);
+ glLightfv(GL_LIGHT0, GL_AMBIENT, LightAmb);
+
+ glEnable(GL_SMOOTH);
+ glEnable(GL_LIGHTING);
+ glEnable(GL_LIGHT0);
+
+ glDepthFunc(GL_LESS);
+ glEnable(GL_DEPTH_TEST);
+
+ glCullFace(GL_BACK);
+ glEnable(GL_CULL_FACE);
+
+ pState->DLStart = InitGLDisplayLists();
+}
+
+
+static void SetCamera(RENDER_STATE* pState)
+{
+ /* Try to work out a sensible place to put the camera so that more or less
+ * the whole juggling pattern fits into the screen. We assume that the
+ * pattern is height limited (i.e. if we get the height right then the width
+ * will be OK). This is a pretty good assumption given that the screen
+ * tends to wider than high, and that a juggling pattern is normally much
+ * higher than wide.
+ *
+ * If I could draw a diagram here then it would be much easier to
+ * understand but my ASCII-art skills just aren't up to it.
+ *
+ * Basically we estimate a bounding volume for the juggler and objects
+ * throughout the pattern. We don't fully account for the fact that the
+ * juggler moves across the stage in an epicyclic-like motion and instead
+ * use the near and far planes in x-y (with z = +/- w). We also
+ * assume that the scene is centred at x=0, this reduces our task to finding
+ * a bounding rectangle. Finally we need to make an estimate of the
+ * height - for this we work out the max height of a standard throw or max
+ * weight from the pattern; we then do a bit of adjustment to account for
+ * a throw occurring at non-zero y values.
+ *
+ * Next we work out the best way to fit this rectangle into the perspective
+ * transform. Based on the angle of elevation (+ve angle looks down) and
+ * the FOV we can work out whether it's the near or far corners that are
+ * the extreme points. And then trace back from them to find the eye
+ * point.
+ *
+ */
+
+ float ElevRad = pState->CameraElev * PI / 180.0f;
+ float w = 3.0f;
+ float cy, cz;
+ float ey, ez;
+ float d;
+ float H = 0.0f;
+ int i;
+ float a;
+
+ float tz, ty, ta;
+ float bz, by, ba;
+ const PATTERN_INFO* pPattern = pState->pPattern;
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+
+ for (i = 0; i < pPattern->ThrowLen; i++)
+ H = max(H, pPattern->pThrowInfo[i].FromPos.y);
+
+ H += pPattern->Height;
+
+ ElevRad = pState->CameraElev * PI / 180.0f;
+
+ /* ta is the angle from a point on the top of the bounding area to the eye
+ * similarly ba is the angle from a point on the bottom. */
+ ta = (pState->CameraElev - (FOV - 10.0f) / 2.0f) * PI / 180.0f;
+ ba = (pState->CameraElev + (FOV - 10.0f) / 2.0f) * PI / 180.0f;
+
+ /* tz and bz hold the z location of the top and bottom extreme points.
+ * For the top, if the angle to the eye location is positive then the
+ * extreme point is with far z corner (the camera looks in -ve z).
+ * The logic is reserved for the bottom. */
+ tz = ta >= 0.0f ? -w : w;
+ bz = ba >= 0.0f ? w : -w;
+
+ ty = H;
+ by = -1.0f;
+
+ /* Solve of the eye location by using a bit of geometry.
+ * We know the eye lies on intersection of two lines. One comes from the
+ * top and other from the bottom. Giving two equations:
+ * ez = tz + a * cos(ta) = bz + b * cos(ba)
+ * ey = ty + a * sin(ta) = by + b * sin(ba)
+ * We don't bother to solve for b and use Crammer's rule to get
+ * | bz-tz -cos(ba) |
+ * | by-ty -sin(ba) |
+ * a = ----------------------
+ * | cos(ta) -cos(ba) |
+ * | sin(ta) -sin(ba) |
+ */
+ d = cosf(ba) * sinf(ta) - cosf(ta) * sinf(ba);
+ a = (cosf(ba) * (by - ty) - sinf(ba) * (bz - tz)) / d;
+
+ ey = ty + a * sinf(ta);
+ ez = tz + a * cosf(ta);
+
+ /* now work back from the eye point to get the lookat location */
+ cz = 0.0;
+ cy = ey - ez * tanf(ElevRad);
+
+ /* use the distance from the eye to the scene centre to get a measure
+ * of what the far clipping should be. We then add on a bit more to be
+ * comfortable */
+ d = sqrtf(ez * ez + (cy - ey) * (cy - ey));
+
+ gluPerspective(FOV, pState->AspectRatio, 0.1f, d + 20.0f);
+ gluLookAt(0.0, ey, ez, 0.0, cy, cz, 0.0, 1.0, 0.0);
+
+ glMatrixMode(GL_MODELVIEW);
+}
+
+
+void ResizeGL(RENDER_STATE* pState, int w, int h)
+{
+ glViewport(0, 0, w, h);
+ pState->AspectRatio = (float) w / h;
+ SetCamera(pState);
+}
+
+
+/* Determine the angle at the vertex of a triangle given the length of the
+ * three sides. */
+
+static double CosineRule(double a, double b, double c)
+{
+ double cosang = (a * a + b * b - c * c) / (2 * a * b);
+ /* If lengths don't form a proper triangle return something sensible.
+ * This typically happens with patterns where the juggler reaches too
+ * far to get hold of an object. */
+ if (cosang < -1.0 || cosang > 1.0)
+ return 0;
+ else
+ return 180.0 * acos(cosang) / PI;
+}
+
+
+/* Spheres for the balls are generated by subdividing each triangle face into
+ * four smaller triangles. We start with an octahedron (8 sides) and repeat the
+ * process a number of times. The result is a mesh that can be split into four
+ * panels (like beanbags) and is smoother than the normal stacks and slices
+ * approach. */
+
+static void InterpolateVertex(
+ const float* v1, const float* v2, float t, float* result)
+{
+ result[0] = v1[0] * (1.0f - t) + v2[0] * t;
+ result[1] = v1[1] * (1.0f - t) + v2[1] * t;
+ result[2] = v1[2] * (1.0f - t) + v2[2] * t;
+}
+
+
+static void SetGLVertex(const float* v, float rad)
+{
+ float Len = sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+
+ if (Len >= 1.0e-10f)
+ {
+ glNormal3f(v[0] / Len, v[1] / Len, v[2] / Len);
+ glVertex3f(rad * v[0] / Len, rad * v[1] / Len, rad * v[2] / Len);
+ }
+ else
+ glVertex3fv(v);
+}
+
+
+static void SphereSegment(
+ const float* v1, const float* v2, const float* v3, float r, int Levels)
+{
+ int i, j;
+
+ for (i = 0; i < Levels; i++)
+ {
+ float A[3], B[3], C[3], D[3];
+
+ InterpolateVertex(v3, v1, (float) i / Levels, D);
+ InterpolateVertex(v3, v1, (float)(i + 1) / Levels, A);
+ InterpolateVertex(v3, v2, (float)(i + 1) / Levels, B);
+ InterpolateVertex(v3, v2, (float) i / Levels, C);
+
+ glBegin(GL_TRIANGLE_STRIP);
+
+ SetGLVertex(B, r);
+ SetGLVertex(C, r);
+
+ for (j = 1; j <= i; j++)
+ {
+ float v[3];
+
+ InterpolateVertex(B, A, (float) j / (i + 1), v);
+ SetGLVertex(v, r);
+
+ InterpolateVertex(C, D, (float) j / i, v);
+ SetGLVertex(v, r);
+ }
+
+ SetGLVertex(A, r);
+
+ glEnd();
+ }
+}
+
+
+/* OK, this function is a bit of misnomer, it only draws half a sphere. Indeed
+ * it draws two panels and allows us to colour this one way, then draw the
+ * same shape again rotated 90 degrees in a different colour. Resulting in what
+ * looks like a four-panel beanbag in two complementary colours. */
+
+static void DrawSphere(float rad)
+{
+ int Levels = 4;
+ float v1[3], v2[3], v3[3];
+
+ v1[0] = 1.0f, v1[1] = 0.0f; v1[2] = 0.0f;
+ v2[0] = 0.0f, v2[1] = 1.0f; v2[2] = 0.0f;
+ v3[0] = 0.0f, v3[1] = 0.0f; v3[2] = 1.0f;
+ SphereSegment(v1, v2, v3, rad, Levels);
+
+ v2[1] = -1.0f;
+ SphereSegment(v2, v1, v3, rad, Levels);
+
+ v1[0] = v3[2] = -1.0f;
+ SphereSegment(v2, v1, v3, rad, Levels);
+
+ v2[1] = 1.0f;
+ SphereSegment(v1, v2, v3, rad, Levels);
+}
+
+
+static void DrawRing(void)
+{
+ const int Facets = 22;
+ const float w = 0.1f;
+ GLUquadric* pQuad = gluNewQuadric();
+ glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
+ glTranslatef(0.0f, 0.0f, -w / 2.0f);
+
+ gluCylinder(pQuad, 1.0f, 1.0f, w, Facets, 1);
+ gluQuadricOrientation(pQuad, GLU_INSIDE);
+
+ gluCylinder(pQuad, 0.7f, 0.7f, w, Facets, 1);
+ gluQuadricOrientation(pQuad, GLU_OUTSIDE);
+
+ glTranslatef(0.0f, 0.0f, w);
+ gluDisk(pQuad, 0.7, 1.0f, Facets, 1);
+
+ glRotatef(180.0f, 0.0f, 1.0f, 0.0f);
+ glTranslatef(0.0f, 0.0f, w);
+ gluDisk(pQuad, 0.7, 1.0f, Facets, 1);
+
+ gluDeleteQuadric(pQuad);
+}
+
+
+/* The club follows a 'circus club' design i.e. it has stripes running down the
+ * body. The club is draw such that the one stripe uses the current material
+ * and the second stripe the standard silver colour. */
+
+void DrawClub(void)
+{
+ const float r[4] = {0.06f, 0.1f, 0.34f, 0.34f / 2.0f};
+ const float z[4] = {-0.4f, 0.6f, 1.35f, 2.1f};
+ float na[4];
+ const int n = 18;
+ int i, j;
+ GLUquadric* pQuad;
+
+ na[0] = (float) atan((r[1] - r[0]) / (z[1] - z[0]));
+ na[1] = (float) atan((r[2] - r[1]) / (z[2] - z[1]));
+ na[2] = (float) atan((r[3] - r[1]) / (z[3] - z[1]));
+ na[3] = (float) atan((r[3] - r[2]) / (z[3] - z[2]));
+
+ for (i = 0; i < n; i += 2)
+ {
+ float a1 = i * PI * 2.0f / n;
+ float a2 = (i + 1) * PI * 2.0f / n;
+
+ glBegin(GL_TRIANGLE_STRIP);
+ for (j = 1; j < 4; j++)
+ {
+ glNormal3f(cosf(na[j]) * cosf(a1),
+ cosf(na[j]) * sinf(a1), sinf(na[j]));
+
+ glVertex3f(r[j] * cosf(a1), r[j] * sinf(a1), z[j]);
+
+ glNormal3f(cosf(na[j]) * cosf(a2),
+ cosf(na[j]) * sinf(a2), sinf(na[j]));
+
+ glVertex3f(r[j] * cosf(a2), r[j] * sinf(a2), z[j]);
+ }
+ glEnd();
+ }
+
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, HandleCol);
+
+ for (i = 1; i < n; i += 2)
+ {
+ float a1 = i * PI * 2.0f / n;
+ float a2 = (i + 1) * PI * 2.0f / n;
+
+ glBegin(GL_TRIANGLE_STRIP);
+ for (j = 1; j < 4; j++)
+ {
+ glNormal3f(cosf(na[j]) * cosf(a1),
+ cosf(na[j]) * sinf(a1), sinf(na[j]));
+
+ glVertex3f(r[j] * cosf(a1), r[j] * sinf(a1), z[j]);
+
+ glNormal3f(cosf(na[j]) * cosf(a2),
+ cosf(na[j]) * sinf(a2), sinf(na[j]));
+
+ glVertex3f(r[j] * cosf(a2), r[j] * sinf(a2), z[j]);
+ }
+ glEnd();
+ }
+
+ pQuad = gluNewQuadric();
+ glTranslatef(0.0f, 0.0f, z[0]);
+ gluCylinder(pQuad, r[0], r[1], z[1] - z[0], n, 1);
+
+ glTranslatef(0.0f, 0.0f, z[3] - z[0]);
+ gluDisk(pQuad, 0.0, r[3], n, 1);
+ glRotatef(180.0f, 0.0f, 1.0f, 0.0f);
+ glTranslatef(0.0f, 0.0f, z[3] - z[0]);
+ gluDisk(pQuad, 0.0, r[0], n, 1);
+ gluDeleteQuadric(pQuad);
+}
+
+
+/* In total 6 display lists are used. There are created based on the DL_
+ * constants defined earlier. The function returns the index of the first
+ * display list, all others can be calculated based on an offset from there. */
+
+static int InitGLDisplayLists(void)
+{
+ int s = glGenLists(6);
+ GLUquadric* pQuad;
+
+ glNewList(s + DL_BALL, GL_COMPILE);
+ DrawSphere(BallRad);
+ glEndList();
+
+ glNewList(s + DL_CLUB, GL_COMPILE);
+ DrawClub();
+ glEndList();
+
+ glNewList(s + DL_RING, GL_COMPILE);
+ DrawRing();
+ glEndList();
+
+ pQuad = gluNewQuadric();
+ gluQuadricNormals(pQuad, GLU_SMOOTH);
+
+ glNewList(s + DL_TORSO, GL_COMPILE);
+ glPushMatrix();
+ glTranslatef(ShoulderPos[0], ShoulderPos[1], -ShoulderPos[2]);
+ glRotatef(-90.0f, 0.0f, 1.0f, 0.0f);
+ gluCylinder(pQuad, 0.3, 0.3, ShoulderPos[0] * 2, 18, 1);
+ glPopMatrix();
+
+ glPushMatrix();
+ glTranslatef(0.0f, -1.0f, -ShoulderPos[2]);
+ glRotatef(-90.0f, 1.0f, 0.0f, 0.0f);
+ gluCylinder(pQuad, 0.3, 0.3, ShoulderPos[1] + 1.0f, 18, 1);
+ glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
+ gluDisk(pQuad, 0.0, 0.3, 18, 1);
+ glPopMatrix();
+
+ /* draw the head */
+ glPushMatrix();
+ glTranslatef(0.0f, ShoulderPos[1] + 1.0f, -ShoulderPos[2]);
+ glRotatef(-30.0f, 1.0f, 0.0f, 0.0f);
+ gluCylinder(pQuad, 0.5, 0.5, 0.3, 15, 1);
+
+ glPushMatrix();
+ glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
+ glRotatef(180.0f, 0.0f, 0.0f, 1.0f);
+ gluDisk(pQuad, 0.0, 0.5, 15, 1);
+ glPopMatrix();
+
+ glTranslatef(0.0f, 0.0f, .3f);
+ gluDisk(pQuad, 0.0, 0.5, 15, 1);
+ glPopMatrix();
+ glEndList();
+
+ glNewList(s + DL_UPPERARM, GL_COMPILE);
+ gluQuadricNormals(pQuad, GLU_SMOOTH);
+ gluQuadricDrawStyle(pQuad, GLU_FILL);
+ gluSphere(pQuad, 0.3, 12, 8);
+
+ gluCylinder(pQuad, 0.3, 0.3, UArmLen, 12, 1);
+ glTranslatef(0.0f, 0.0f, UArmLen);
+ gluSphere(pQuad, 0.3, 12, 8);
+ glEndList();
+
+ glNewList(s + DL_FOREARM, GL_COMPILE);
+ gluCylinder(pQuad, 0.3, 0.3 / 2.0f, LArmLen, 12, 1);
+ glTranslatef(0.0f, 0.0f, LArmLen);
+ gluDisk(pQuad, 0, 0.3 / 2.0f, 18, 1);
+ glEndList();
+
+ gluDeleteQuadric(pQuad);
+ return s;
+}
+
+
+/* Drawing the arm requires connecting the upper and fore arm between the
+ * shoulder and hand position. Thinking about things kinematically by treating
+ * the shoulder and elbow as ball joints then, provided the arm can stretch far
+ * enough, there's a infnite number of ways to position the elbow. Basically
+ * it's possible to fix and hand and shoulder and then rotate the elbow a full
+ * 360 degrees. Clearly human anatomy isn't like this and picking a natural
+ * elbow position can be complex. We chicken out and assume that poking the
+ * elbow out by 20 degrees from the lowest position gives a reasonably looking
+ * orientation. */
+
+void DrawArm(RENDER_STATE* pState, float TimePos, int Left)
+{
+ POS Pos;
+ float x, y, len, len2, ang, ang2;
+
+ GetHandPosition(pState->pPattern, Left, TimePos, &Pos);
+
+ x = Pos.x + (Left ? -ShoulderPos[0] : ShoulderPos[0]);
+ y = Pos.y - ShoulderPos[1];
+
+
+ len = sqrtf(x * x + y * y + ShoulderPos[2] * ShoulderPos[2]);
+ len2 = sqrtf(x * x + ShoulderPos[2] * ShoulderPos[2]);
+
+ ang = (float) CosineRule(UArmLen, len, LArmLen);
+ ang2 = (float) CosineRule(UArmLen, LArmLen, len);
+
+ if (ang == 0.0 && ang2 == 0)
+ ang2 = 180.0;
+
+
+ glPushMatrix();
+ glTranslatef(Left ? ShoulderPos[0] : -ShoulderPos[0], ShoulderPos[1],
+ -ShoulderPos[2]);
+ glRotatef((float)(180.0f * asin(x / len2) / 3.14f), 0.0f, 1.0f, 0.0f);
+ glRotatef((float)(-180.f * asin(y / len) / 3.14), 1.0f, 0.0f, 0.0f);
+ glRotatef(Left ? 20.0f : -20.0f, 0.0f, 0.0f, 1.0f);
+ glRotatef((float) ang, 1.0f, 0.0f, 0.0f);
+ glCallList(DL_UPPERARM + pState->DLStart);
+
+ glRotatef((float)(ang2 - 180.0), 1.0f, 0.0f, 0.f);
+ glCallList(DL_FOREARM + pState->DLStart);
+ glPopMatrix();
+}
+
+
+void DrawGLScene(RENDER_STATE* pState)
+{
+ float Time = pState->Time;
+ int nCols = sizeof(Cols) / sizeof(Cols[0]);
+ int i;
+
+ PATTERN_INFO* pPattern = pState->pPattern;
+
+ glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+ glTranslatef(5.0f * sinf(pState->TranslateAngle), 0.0f, 0.0f);
+
+ gltrackball_rotate (pState->trackball);
+
+ glRotatef(pState->SpinAngle, 0.0f, 1.0f, 0.0f);
+ glTranslatef(0.0, 0.0, -1.0f);
+
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, DiffCol);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, SpecCol);
+ glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0f);
+
+ for (i = 0; i < pPattern->Objects; i++)
+ {
+ POS ObjPos;
+
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Cols[i % nCols]);
+ glPushMatrix();
+
+ switch (pPattern->pObjectInfo[i].ObjectType)
+ {
+ case OBJECT_CLUB:
+ GetObjectPosition(pPattern, i, Time, 1.0f, &ObjPos);
+ glTranslatef(ObjPos.x, ObjPos.y, ObjPos.z);
+ glRotatef(ObjPos.Rot, 0.0f, 1.0f, 0.0f);
+ glRotatef(ObjPos.Elev, -1.0f, 0.0f, 0.0f);
+ glTranslatef(0.0f, 0.0f, -1.0f);
+ glCallList(DL_CLUB + pState->DLStart);
+ break;
+
+ case OBJECT_RING:
+ GetObjectPosition(pPattern, i, Time, 1.0f, &ObjPos);
+ glTranslatef(ObjPos.x, ObjPos.y, ObjPos.z);
+ glRotatef(ObjPos.Rot, 0.0f, 1.0f, 0.0f);
+ glRotatef(ObjPos.Elev, -1.0f, 0.0f, 0.0f);
+ glCallList(DL_RING + pState->DLStart);
+ break;
+
+ default:
+ GetObjectPosition(pPattern, i, Time, 0.0f, &ObjPos);
+ glTranslatef(ObjPos.x, ObjPos.y, ObjPos.z);
+ glRotatef(ObjPos.Rot, 0.6963f, 0.6963f, 0.1742f);
+ glCallList(DL_BALL + pState->DLStart);
+ glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
+ AltCols[i % nCols]);
+ glCallList(DL_BALL + pState->DLStart);
+ break;
+ }
+
+ glPopMatrix();
+ }
+
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, BodyCol);
+ glCallList(DL_TORSO + pState->DLStart);
+ DrawArm(pState, Time, 1);
+ DrawArm(pState, Time, 0);
+}
+
+
+static int RandInRange(int Min, int Max)
+{
+ return Min + random() % (1 + Max - Min);
+}
+
+
+extern void UpdatePattern(
+ RENDER_STATE* pState, int MinBalls, int MaxBalls,
+ int MinHeightInc, int MaxHeightInc)
+{
+ if (pState->pPattern != NULL)
+ ReleasePatternInfo(pState->pPattern);
+
+ pState->pPattern = (PATTERN_INFO*) malloc(sizeof(PATTERN_INFO));
+
+ if ((random() % 3) == 1)
+ {
+ int ExtSiteLen;
+ int n = random() % (sizeof(PatternText) / sizeof(PatternText[0]));
+ EXT_SITE_INFO* pExtInfo = ParsePattern(PatternText[n], &ExtSiteLen);
+ InitPatternInfo(pState->pPattern, NULL, pExtInfo, ExtSiteLen);
+ free(pExtInfo);
+ }
+ else
+ {
+ int* pRand;
+ int ballcount, maxweight;
+ const int RandPatternLen = 1500;
+
+ ballcount = RandInRange(MinBalls, MaxBalls);
+ maxweight = ballcount + RandInRange(MinHeightInc, MaxHeightInc);
+
+ pRand = Generate(RandPatternLen, maxweight, ballcount);
+ InitPatternInfo(pState->pPattern, pRand, NULL, RandPatternLen);
+ free(pRand);
+ }
+
+ pState->CameraElev = 50.0f - random() % 90;
+ pState->TranslateAngle = random() % 360;
+ pState->SpinAngle = random() % 360;
+ pState->Time = 50.0f;
+ SetCamera(pState);
+}
+
+
+/*******************************************************************************
+ *
+ * XScreenSaver Configuration
+ *
+ ******************************************************************************/
+
+extern XtAppContext app;
+
+typedef struct
+{
+ GLXContext* glxContext;
+ RENDER_STATE RenderState;
+ float CurrentFrameRate;
+ unsigned FramesSinceSync;
+ unsigned LastSyncTime;
+} JUGGLER3D_CONFIG;
+
+
+static JUGGLER3D_CONFIG* pConfigInfo = NULL;
+static int MaxObjects;
+static int MinObjects;
+static int MaxHeightInc;
+static int MinHeightInc;
+static float SpinSpeed;
+static float TranslateSpeed;
+static float JuggleSpeed;
+
+static XrmOptionDescRec Options[] =
+{
+ {"-spin", ".spin", XrmoptionSepArg, 0},
+ {"-trans", ".trans", XrmoptionSepArg, 0},
+ {"-speed", ".speed", XrmoptionSepArg, 0},
+ {"-maxobjs", ".maxobjs", XrmoptionSepArg, 0},
+ {"-minobjs", ".minobjs", XrmoptionSepArg, 0},
+ {"-maxhinc", ".maxhinc", XrmoptionSepArg, 0},
+ {"-minhinc", ".minhinc", XrmoptionSepArg, 0},
+};
+
+
+static argtype Vars[] =
+{
+ {&MaxObjects, "maxobjs", "MaxObjs", "8", t_Int},
+ {&MinObjects, "minobjs", "MinObjs", "3", t_Int},
+ {&MaxHeightInc, "maxhinc", "MaxHInc", "6", t_Int},
+ {&MinHeightInc, "minhinc", "MaxHInc", "2", t_Int},
+ {&JuggleSpeed, "speed", "JuggleSpeed", "2.2", t_Float},
+ {&TranslateSpeed, "trans", "TranslateSpeed", "0.1", t_Float},
+ {&SpinSpeed, "spin", "SpinSpeed", "20.0", t_Float},
+};
+
+
+ModeSpecOpt SWITCH_OPTS = {countof(Options), Options, countof(Vars), Vars};
+
+
+void Juggler3D_HackReshapeEvent(ModeInfo *mi, int width, int height)
+{
+ JUGGLER3D_CONFIG* pConfig = &pConfigInfo[MI_SCREEN(mi)];
+ ResizeGL(&pConfig->RenderState, width, height);
+}
+
+
+void Juggler3D_HackInitEvent(ModeInfo* mi)
+{
+ JUGGLER3D_CONFIG* pConfig;
+
+ if (pConfigInfo == NULL)
+ {
+ /* Apply suitable bounds checks to the input parameters */
+ MaxObjects = max(3, min(MaxObjects, 36));
+ MinObjects = max(3, min(MinObjects, MaxObjects));
+
+ MaxHeightInc = max(1, min(MaxHeightInc, 32));
+ MinHeightInc = max(1, min(MinHeightInc, MaxHeightInc));
+
+ pConfigInfo = (JUGGLER3D_CONFIG*) calloc(
+ MI_NUM_SCREENS(mi), sizeof(JUGGLER3D_CONFIG));
+ if (pConfigInfo == NULL)
+ {
+ fprintf(stderr, "%s: out of memory\n", progname);
+ exit(1);
+ }
+ }
+
+ pConfig = &pConfigInfo[MI_SCREEN(mi)];
+ pConfig->glxContext = init_GL(mi);
+ pConfig->CurrentFrameRate = 0.0f;
+ pConfig->FramesSinceSync = 0;
+ pConfig->LastSyncTime = 0;
+ InitGLSettings(&pConfig->RenderState, MI_IS_WIREFRAME(mi));
+
+ UpdatePattern(&pConfig->RenderState, MinObjects, MaxObjects,
+ MinHeightInc, MaxHeightInc);
+
+ Juggler3D_HackReshapeEvent(mi, MI_WIDTH(mi), MI_HEIGHT(mi));
+}
+
+
+void Juggler3D_HackDrawEvent(ModeInfo* mi)
+{
+ JUGGLER3D_CONFIG* pConfig = &pConfigInfo[MI_SCREEN(mi)];
+ Display* pDisplay = MI_DISPLAY(mi);
+ Window hwnd = MI_WINDOW(mi);
+
+ if (pConfig->glxContext == NULL)
+ return;
+
+ /* While drawing, keep track of the rendering speed so we can adjust the
+ * animation speed so things appear consistent. The basis of the this
+ * code comes from the frame rate counter (fps.c) but has been modified
+ * so that it reports the initial frame rate earlier (after 0.02 secs
+ * instead of 1 sec). */
+
+ if (pConfig->FramesSinceSync >= 1 * (int) pConfig->CurrentFrameRate)
+ {
+ struct timeval tvnow;
+ unsigned now;
+
+ # ifdef GETTIMEOFDAY_TWO_ARGS
+ struct timezone tzp;
+ gettimeofday(&tvnow, &tzp);
+ # else
+ gettimeofday(&tvnow);
+ # endif
+
+ now = (unsigned) (tvnow.tv_sec * 1000000 + tvnow.tv_usec);
+ if (pConfig->FramesSinceSync == 0)
+ {
+ pConfig->LastSyncTime = now;
+ }
+ else
+ {
+ unsigned Delta = now - pConfig->LastSyncTime;
+ if (Delta > 20000)
+ {
+ pConfig->LastSyncTime = now;
+ pConfig->CurrentFrameRate =
+ (pConfig->FramesSinceSync * 1.0e6f) / Delta;
+ pConfig->FramesSinceSync = 0;
+ }
+ }
+ }
+
+ pConfig->FramesSinceSync++;
+
+ if (pConfig->RenderState.Time > 150.0f)
+ {
+ UpdatePattern(&pConfig->RenderState, MinObjects, MaxObjects,
+ MinHeightInc, MaxHeightInc);
+ }
+ DrawGLScene(&pConfig->RenderState);
+
+ if (pConfig->CurrentFrameRate > 1.0e-6f)
+ {
+ pConfig->RenderState.Time += JuggleSpeed / pConfig->CurrentFrameRate;
+ pConfig->RenderState.SpinAngle += SpinSpeed / pConfig->CurrentFrameRate;
+ pConfig->RenderState.TranslateAngle +=
+ TranslateSpeed / pConfig->CurrentFrameRate;
+ }
+
+ if (mi->fps_p)
+ do_fps(mi);
+
+ glFinish();
+ glXSwapBuffers(pDisplay, hwnd);
+}
+
+
+Bool Juggler3D_HackHandleEvent(ModeInfo* mi, XEvent* pEvent)
+{
+ JUGGLER3D_CONFIG* pConfig = &pConfigInfo[MI_SCREEN(mi)];
+ RENDER_STATE* pState = &pConfig->RenderState;
+
+ if (pEvent->xany.type == ButtonPress &&
+ pEvent->xbutton.button == Button1)
+ {
+ pState->button_down_p = True;
+ gltrackball_start (pState->trackball,
+ pEvent->xbutton.x, pEvent->xbutton.y,
+ MI_WIDTH (mi), MI_HEIGHT (mi));
+ return True;
+ }
+ else if (pEvent->xany.type == ButtonRelease &&
+ pEvent->xbutton.button == Button1)
+ {
+ pState->button_down_p = False;
+ return True;
+ }
+ else if (pEvent->xany.type == ButtonPress &&
+ (pEvent->xbutton.button == Button4 ||
+ pEvent->xbutton.button == Button5))
+ {
+ gltrackball_mousewheel (pState->trackball, pEvent->xbutton.button, 2,
+ !pEvent->xbutton.state);
+ return True;
+ }
+ else if (pEvent->xany.type == MotionNotify &&
+ pState->button_down_p)
+ {
+ gltrackball_track (pState->trackball,
+ pEvent->xmotion.x, pEvent->xmotion.y,
+ MI_WIDTH (mi), MI_HEIGHT (mi));
+ return True;
+ }
+ else if (pEvent->xany.type == KeyPress)
+ {
+ char str[20];
+ KeySym Key = 0;
+ int count = XLookupString(&pEvent->xkey, str, 20, &Key, 0);
+ str[count] = '\0';
+ if (*str == ' ')
+ {
+ UpdatePattern(&pConfig->RenderState, MinObjects, MaxObjects,
+ MinHeightInc, MaxHeightInc);
+ }
+ }
+
+ return False;
+}
+
+#endif
projects / xscreensaver / blobdiff