Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 515 insertions, 0 deletions

diff --git a/plug-ins/map-object/arcball.c b/plug-ins/map-object/arcball.c
new file mode 100644
index 0000000..1f509d4
--- /dev/null
+++ b/plug-ins/map-object/arcball.c
@@ -0,0 +1,515 @@
+/************************************/
+/* ArcBall.c (c) Ken Shoemake, 1993 */
+/* Modified by Tom Bech, 1996       */
+/************************************/
+
+#include "config.h"
+
+#include <libgimp/gimp.h>
+
+#include "arcball.h"
+
+/* Global variables */
+/* ================ */
+
+Quat qOne = { 0, 0, 0, 1 };
+
+static HVect         center;
+static double        radius;
+static Quat          qNow, qDown, qDrag;
+static HVect         vNow, vDown, vFrom, vTo, vrFrom, vrTo;
+static HMatrix       mNow, mDown;
+static unsigned int  showResult, dragging;
+static ConstraintSet sets[NSets];
+static int           setSizes[NSets];
+static AxisSet       axisSet;
+static int           axisIndex;
+
+static HMatrix mId =
+{
+  { 1, 0, 0, 0 },
+  { 0, 1, 0, 0 },
+  { 0, 0, 1, 0 },
+  { 0, 0, 0, 1 }
+};
+
+static double otherAxis[][4] =
+{
+  {-0.48, 0.80, 0.36, 1}
+};
+
+/* Internal methods */
+/* ================ */
+
+static void     Qt_ToMatrix(Quat q,HMatrix out);
+static Quat     Qt_Conj(Quat q);
+static Quat     Qt_Mul(Quat qL, Quat qR);
+static Quat     Qt_FromBallPoints(HVect from, HVect to);
+static void     Qt_ToBallPoints(Quat q, HVect *arcFrom, HVect *arcTo);
+
+static HVect    V3_(double x, double y, double z);
+static double   V3_Norm(HVect v);
+static HVect    V3_Unit(HVect v);
+static HVect    V3_Scale(HVect v, double s);
+static HVect    V3_Negate(HVect v);
+/*
+static HVect    V3_Add(HVect v1, HVect v2);
+*/
+static HVect    V3_Sub(HVect v1, HVect v2);
+static double   V3_Dot(HVect v1, HVect v2);
+/*
+static HVect    V3_Cross(HVect v1, HVect v2);
+static HVect    V3_Bisect(HVect v0, HVect v1);
+*/
+
+static HVect    MouseOnSphere(HVect mouse, HVect ballCenter, double ballRadius);
+static HVect    ConstrainToAxis(HVect loose, HVect axis);
+static int      NearestConstraintAxis(HVect loose, HVect *axes, int nAxes);
+
+/* Establish reasonable initial values for controller. */
+/* =================================================== */
+
+void
+ArcBall_Init (void)
+{
+  int i;
+
+  center = qOne;
+  radius = 1.0;
+  vDown = vNow = qOne;
+  qDown = qNow = qOne;
+  for (i=15; i>=0; i--)
+    ((double *)mNow)[i] = ((double *)mDown)[i] = ((double *)mId)[i];
+
+  showResult = dragging = FALSE;
+  axisSet = NoAxes;
+  sets[CameraAxes] = mId[X];
+  setSizes[CameraAxes] = 3;
+  sets[BodyAxes] = mDown[X];
+  setSizes[BodyAxes] = 3;
+  sets[OtherAxes] = otherAxis[X];
+  setSizes[OtherAxes] = 1;
+}
+
+/* Set the center and size of the controller. */
+/* ========================================== */
+
+void
+ArcBall_Place (HVect  Center,
+               double Radius)
+{
+  center = Center;
+  radius = Radius;
+}
+
+/* Incorporate new mouse position. */
+/* =============================== */
+
+void
+ArcBall_Mouse (HVect v_Now)
+{
+  vNow = v_Now;
+}
+
+/* Choose a constraint set, or none. */
+/* ================================= */
+
+void
+ArcBall_UseSet (AxisSet axis_Set)
+{
+  if (!dragging) axisSet = axis_Set;
+}
+
+/* Using vDown, vNow, dragging, and axisSet, compute rotation etc. */
+/* =============================================================== */
+
+void
+ArcBall_Update (void)
+{
+  int setSize = setSizes[axisSet];
+  HVect *set = (HVect *)(sets[axisSet]);
+
+  vFrom = MouseOnSphere(vDown, center, radius);
+  vTo = MouseOnSphere(vNow, center, radius);
+  if (dragging)
+    {
+      if (axisSet!=NoAxes)
+        {
+          vFrom = ConstrainToAxis(vFrom, set[axisIndex]);
+          vTo = ConstrainToAxis(vTo, set[axisIndex]);
+        }
+      qDrag = Qt_FromBallPoints(vFrom, vTo);
+      qNow = Qt_Mul(qDrag, qDown);
+    }
+  else
+    {
+      if (axisSet!=NoAxes) axisIndex = NearestConstraintAxis(vTo, set, setSize);
+    }
+  Qt_ToBallPoints(qDown, &vrFrom, &vrTo);
+  Qt_ToMatrix(Qt_Conj(qNow), mNow); /* Gives transpose for GL. */
+}
+
+/* Return rotation matrix defined by controller use. */
+/* ================================================= */
+
+void
+ArcBall_Value (HMatrix m_Now)
+{
+  ArcBall_CopyMat (mNow, m_Now);
+}
+
+/* Extract rotation angles from matrix */
+/* =================================== */
+
+void
+ArcBall_Values (double *alpha,
+                double *beta,
+                double *gamma)
+{
+  if ((*beta=asin(-mNow[0][2]))!=0.0)
+    {
+      *gamma=atan2(mNow[1][2],mNow[2][2]);
+      *alpha=atan2(mNow[0][1],mNow[0][0]);
+    }
+  else
+    {
+      *gamma=atan2(mNow[1][0],mNow[1][1]);
+      *alpha=0.0;
+    }
+}
+
+/* Begin drag sequence. */
+/* ==================== */
+
+void
+ArcBall_BeginDrag (void)
+{
+  dragging = TRUE;
+  vDown = vNow;
+}
+
+/* Stop drag sequence. */
+/* =================== */
+
+void
+ArcBall_EndDrag (void)
+{
+  dragging = FALSE;
+  qDown = qNow;
+
+  ArcBall_CopyMat (mNow, mDown);
+}
+
+/*===================*/
+/***** BallAux.c *****/
+/*===================*/
+
+/* Return quaternion product qL * qR.  Note: order is important! */
+/* To combine rotations, use the product Mul(qSecond, qFirst),   */
+/* which gives the effect of rotating by qFirst then qSecond.    */
+/* ============================================================= */
+
+static Quat
+Qt_Mul (Quat qL,
+        Quat qR)
+{
+  Quat qq;
+  qq.w = qL.w*qR.w - qL.x*qR.x - qL.y*qR.y - qL.z*qR.z;
+  qq.x = qL.w*qR.x + qL.x*qR.w + qL.y*qR.z - qL.z*qR.y;
+  qq.y = qL.w*qR.y + qL.y*qR.w + qL.z*qR.x - qL.x*qR.z;
+  qq.z = qL.w*qR.z + qL.z*qR.w + qL.x*qR.y - qL.y*qR.x;
+  return (qq);
+}
+
+/* Construct rotation matrix from (possibly non-unit) quaternion. */
+/* Assumes matrix is used to multiply column vector on the left:  */
+/* vnew = mat vold.  Works correctly for right-handed coordinate  */
+/* system and right-handed rotations.                             */
+/* ============================================================== */
+
+static void
+Qt_ToMatrix (Quat    q,
+             HMatrix out)
+{
+  double Nq = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w;
+  double s = (Nq > 0.0) ? (2.0 / Nq) : 0.0;
+  double xs = q.x*s,              ys = q.y*s,          zs = q.z*s;
+  double wx = q.w*xs,              wy = q.w*ys,          wz = q.w*zs;
+  double xx = q.x*xs,              xy = q.x*ys,          xz = q.x*zs;
+  double yy = q.y*ys,              yz = q.y*zs,          zz = q.z*zs;
+  out[X][X] = 1.0 - (yy + zz); out[Y][X] = xy + wz; out[Z][X] = xz - wy;
+  out[X][Y] = xy - wz; out[Y][Y] = 1.0 - (xx + zz); out[Z][Y] = yz + wx;
+  out[X][Z] = xz + wy; out[Y][Z] = yz - wx; out[Z][Z] = 1.0 - (xx + yy);
+  out[X][W] = out[Y][W] = out[Z][W] = out[W][X] = out[W][Y] = out[W][Z] = 0.0;
+  out[W][W] = 1.0;
+}
+
+/* Return conjugate of quaternion. */
+/* =============================== */
+
+static Quat
+Qt_Conj (Quat q)
+{
+  Quat qq;
+  qq.x = -q.x; qq.y = -q.y; qq.z = -q.z; qq.w = q.w;
+  return (qq);
+}
+
+/* Return vector formed from components */
+/* ==================================== */
+
+static HVect
+V3_ (double x,
+     double y,
+     double z)
+{
+  HVect v;
+  v.x = x; v.y = y; v.z = z; v.w = 0;
+  return (v);
+}
+
+/* Return norm of v, defined as sum of squares of components */
+/* ========================================================= */
+
+static double
+V3_Norm (HVect v)
+{
+  return ( v.x*v.x + v.y*v.y + v.z*v.z );
+}
+
+/* Return unit magnitude vector in direction of v */
+/* ============================================== */
+
+static HVect
+V3_Unit (HVect v)
+{
+  static HVect u = {0, 0, 0, 0};
+  double vlen = sqrt(V3_Norm(v));
+
+  if (vlen != 0.0)
+    {
+      u.x = v.x/vlen;
+      u.y = v.y/vlen;
+      u.z = v.z/vlen;
+    }
+  return (u);
+}
+
+/* Return version of v scaled by s */
+/* =============================== */
+
+static HVect
+V3_Scale (HVect v,
+          double s)
+{
+  HVect u;
+  u.x = s*v.x; u.y = s*v.y; u.z = s*v.z; u.w = v.w;
+  return (u);
+}
+
+/* Return negative of v */
+/* ==================== */
+
+static HVect
+V3_Negate (HVect v)
+{
+  static HVect u = {0, 0, 0, 0};
+  u.x = -v.x; u.y = -v.y; u.z = -v.z;
+  return (u);
+}
+
+/* Return sum of v1 and v2 */
+/* ======================= */
+/*
+static HVect
+V3_Add (HVect v1,
+        HVect v2)
+{
+  static HVect v = {0, 0, 0, 0};
+  v.x = v1.x+v2.x; v.y = v1.y+v2.y; v.z = v1.z+v2.z;
+  return (v);
+}
+*/
+/* Return difference of v1 minus v2 */
+/* ================================ */
+
+static HVect
+V3_Sub (HVect v1,
+        HVect v2)
+{
+  static HVect v = {0, 0, 0, 0};
+  v.x = v1.x-v2.x; v.y = v1.y-v2.y; v.z = v1.z-v2.z;
+  return (v);
+}
+
+/* Halve arc between unit vectors v0 and v1. */
+/* ========================================= */
+/*
+static HVect
+V3_Bisect (HVect v0,
+           HVect v1)
+{
+  HVect v = {0, 0, 0, 0};
+  double Nv;
+
+  v = V3_Add(v0, v1);
+  Nv = V3_Norm(v);
+  if (Nv < 1.0e-5) v = V3_(0, 0, 1);
+  else v = V3_Scale(v, 1/sqrt(Nv));
+  return (v);
+}
+*/
+
+/* Return dot product of v1 and v2 */
+/* =============================== */
+
+static double
+V3_Dot (HVect v1,
+        HVect v2)
+{
+  return (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
+}
+
+
+/* Return cross product, v1 x v2 */
+/* ============================= */
+/*
+static HVect
+V3_Cross (HVect v1,
+          HVect v2)
+{
+  static HVect v = {0, 0, 0, 0};
+  v.x = v1.y*v2.z-v1.z*v2.y;
+  v.y = v1.z*v2.x-v1.x*v2.z;
+  v.z = v1.x*v2.y-v1.y*v2.x;
+  return (v);
+}
+*/
+
+void
+ArcBall_CopyMat (HMatrix inm,
+                 HMatrix outm)
+{
+  int x=0,y=0;
+
+  for (x=0;x<4;x++)
+    {
+      for (y=0;y<4;y++)
+        {
+          outm[y][x]=inm[y][x];
+        }
+    }
+}
+
+/*=====================================================*/
+/**** BallMath.c - Essential routines for ArcBall.  ****/
+/*=====================================================*/
+
+/* Convert window coordinates to sphere coordinates. */
+/* ================================================= */
+
+static HVect
+MouseOnSphere (HVect  mouse,
+               HVect  ballCenter,
+               double ballRadius)
+{
+  HVect ballMouse;
+  register double mag;
+
+  ballMouse.x = (mouse.x - ballCenter.x) / ballRadius;
+  ballMouse.y = (mouse.y - ballCenter.y) / ballRadius;
+  mag = ballMouse.x*ballMouse.x + ballMouse.y*ballMouse.y;
+  if (mag > 1.0)
+    {
+      register double scale = 1.0/sqrt(mag);
+      ballMouse.x *= scale; ballMouse.y *= scale;
+      ballMouse.z = 0.0;
+    }
+  else ballMouse.z = sqrt(1 - mag);
+  ballMouse.w = 0.0;
+  return (ballMouse);
+}
+
+/* Construct a unit quaternion from two points on unit sphere */
+/* ========================================================== */
+
+static Quat
+Qt_FromBallPoints (HVect from,
+                   HVect to)
+{
+  Quat qu;
+  qu.x = from.y*to.z - from.z*to.y;
+  qu.y = from.z*to.x - from.x*to.z;
+  qu.z = from.x*to.y - from.y*to.x;
+  qu.w = from.x*to.x + from.y*to.y + from.z*to.z;
+  return (qu);
+}
+
+/* Convert a unit quaternion to two points on unit sphere */
+/* ====================================================== */
+
+static void
+Qt_ToBallPoints (Quat   q,
+                 HVect *arcFrom,
+                 HVect *arcTo)
+{
+  double s;
+
+  s = sqrt(q.x*q.x + q.y*q.y);
+  if (s == 0.0) *arcFrom = V3_(0.0, 1.0, 0.0);
+  else          *arcFrom = V3_(-q.y/s, q.x/s, 0.0);
+  arcTo->x = q.w*arcFrom->x - q.z*arcFrom->y;
+  arcTo->y = q.w*arcFrom->y + q.z*arcFrom->x;
+  arcTo->z = q.x*arcFrom->y - q.y*arcFrom->x;
+  if (q.w < 0.0) *arcFrom = V3_(-arcFrom->x, -arcFrom->y, 0.0);
+}
+
+/* Force sphere point to be perpendicular to axis. */
+/* =============================================== */
+
+static HVect
+ConstrainToAxis (HVect loose,
+                 HVect axis)
+{
+  HVect onPlane;
+  register double norm;
+
+  onPlane = V3_Sub(loose, V3_Scale(axis, V3_Dot(axis, loose)));
+  norm = V3_Norm(onPlane);
+  if (norm > 0.0)
+    {
+      if (onPlane.z < 0.0) onPlane = V3_Negate(onPlane);
+      return ( V3_Scale(onPlane, 1/sqrt(norm)) );
+    }
+  /* else drop through */
+  /* ================= */
+
+  if (axis.z == 1) onPlane = V3_(1.0, 0.0, 0.0);
+  else             onPlane = V3_Unit(V3_(-axis.y, axis.x, 0.0));
+  return (onPlane);
+}
+
+/* Find the index of nearest arc of axis set. */
+/* ========================================== */
+
+static int
+NearestConstraintAxis (HVect  loose,
+                       HVect *axes,
+                       int    nAxes)
+{
+  HVect onPlane;
+  register double max, dot;
+  register int i, nearest;
+  max = -1; nearest = 0;
+
+  for (i=0; i<nAxes; i++)
+    {
+      onPlane = ConstrainToAxis(loose, axes[i]);
+      dot = V3_Dot(onPlane, loose);
+      if (dot>max)
+        {
+          max = dot; nearest = i;
+        }
+    }
+  return (nearest);
+}