QuakeForge  0.7.2.210-815cf
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
Dual and dual quaternion functions

Macros

#define DualAdd(a, b, c)
 
#define DualBlend(d1, d2, b, d)
 
#define DualCompare(x, y)   DualCompCompare (x, ==, y)
 
#define DualCompCompare(x, op, y)   ((x).r op (y).r) && ((x).e op (y).e)
 
#define DualConj(a, b)
 
#define DualExpand(d)   (d).r, (d).e
 
#define DualIsUnit(a)   (((a).r - 1) * ((a).r - 1) < 1e-6 && (a).e * (a).e < 1e-6)
 
#define DualIsZero(a)   ((a).r == 0 && (a).e == 0)
 
#define DualMult(a, b, c)
 
#define DualMultAdd(a, s, b, c)
 
#define DualMultSub(a, s, b, c)
 
#define DualNegate(a, b)
 
#define DualNorm(a)   ((a).r)
 
#define DualQuatAdd(a, b, c)
 
#define DualQuatBlend(dq1, dq2, b, dq)
 
#define DualQuatCompare(x, y)   DualQuatCompCompare (x, ==, y)
 
#define DualQuatCompCompare(x, op, y)
 
#define DualQuatConjE(a, b)
 
#define DualQuatConjQ(a, b)
 
#define DualQuatConjQE(a, b)
 
#define DualQuatExpand(dq)   QuatExpand ((dq).q0.q), QuatExpand ((dq).qe.q)
 
#define DualQuatIsZero(a)   (QuatIsZero ((a).q0.q) && QuatIsZero ((a).qe.q))
 
#define DualQuatMult(a, b, c)
 
#define DualQuatMultAdd(a, s, b, c)
 
#define DualQuatMultSub(a, s, b, c)
 
#define DualQuatNegate(a, b)
 
#define DualQuatNorm(a, b)
 
#define DualQuatRotTrans(rot, trans, dq)
 
#define DualQuatScale(a, b, c)
 
#define DualQuatSetVect(vec, a)
 
#define DualQuatSubtract(a, b, c)
 
#define DualQuatZero(a)
 
#define DualScale(a, b, c)
 
#define DualSet(ar, ae, a)
 
#define DualSubtract(a, b, c)
 
#define DualZero(a)
 

Detailed Description

Macro Definition Documentation

#define DualAdd (   a,
  b,
 
)
Value:
do { \
(c).r = (a).r + (b).r; \
(c).e = (a).e + (b).e; \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualBlend (   d1,
  d2,
  b,
 
)
Value:
do { \
(d).r = (d1).r * (1 - (b)) + (d2).r * (b); \
(d).e = (d1).e * (1 - (b)) + (d2).e * (b); \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualCompare (   x,
 
)    DualCompCompare (x, ==, y)
#define DualCompCompare (   x,
  op,
 
)    ((x).r op (y).r) && ((x).e op (y).e)
#define DualConj (   a,
 
)
Value:
do { \
(b).r = (a).r; \
(b).e = -(a).e; \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualExpand (   d)    (d).r, (d).e
#define DualIsUnit (   a)    (((a).r - 1) * ((a).r - 1) < 1e-6 && (a).e * (a).e < 1e-6)
#define DualIsZero (   a)    ((a).r == 0 && (a).e == 0)
#define DualMult (   a,
  b,
 
)
Value:
do { \
(c).e = (a).r * (b).e + (a).e * (b).r; \
(c).r = (a).r * (b).r; \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualMultAdd (   a,
  s,
  b,
 
)
Value:
do { \
(c).r = (a).r + (s) * (b).r; \
(c).e = (a).e + (s) * (b).e; \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualMultSub (   a,
  s,
  b,
 
)
Value:
do { \
(c).r = (a).r - (s) * (b).r; \
(c).e = (a).e - (s) * (b).e; \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualNegate (   a,
 
)
Value:
do { \
(b).r = -(a).r; \
(b).e = -(a).e; \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualNorm (   a)    ((a).r)
#define DualQuatAdd (   a,
  b,
 
)
Value:
do { \
QuatAdd ((a).q0.q, (b).q0.q, (c).q0.q); \
QuatAdd ((a).qe.q, (b).qe.q, (c).qe.q); \
} while (0)
#define QuatAdd(a, b, c)
Definition: quaternion.h:66
#define DualQuatBlend (   dq1,
  dq2,
  b,
  dq 
)
Value:
do { \
QuatBlend ((dq1).q0.q, (dq2).q0.q, (b), (dq).q0.q); \
QuatBlend ((dq1).qe.q, (dq2).qe.q, (b), (dq).qe.q); \
} while (0)
#define QuatBlend(q1, q2, b, q)
Definition: quaternion.h:154
#define DualQuatCompare (   x,
 
)    DualQuatCompCompare (x, ==, y)
#define DualQuatCompCompare (   x,
  op,
 
)
Value:
(QuatCompCompare ((x).q0.q, op, (y).q0.q) \
&&QuatCompCompare ((x).qe.q, op, (y).qe.q))
vec_t * x
Definition: test-bary.c:27
int op
Definition: net_main.c:437
#define QuatCompCompare(x, op, y)
Definition: quaternion.h:118
#define DualQuatConjE (   a,
 
)
Value:
do { \
(b).q0 = (a).q0; \
QuatNegate ((a).qe.q, (b).qe.q); \
} while (0)
#define QuatNegate(a, b)
Definition: quaternion.h:52
#define DualQuatConjQ (   a,
 
)
Value:
do { \
QuatConj ((a).q0.q, (b).q0.q); \
QuatConj ((a).qe.q, (b).qe.q); \
} while (0)
#define QuatConj(a, b)
Definition: quaternion.h:59
#define DualQuatConjQE (   a,
 
)
Value:
do { \
QuatConj ((a).q0.q, (b).q0.q); \
(b).qe.sv.s = -(a).qe.sv.s; \
VectorCopy ((a).qe.sv.v, (b).qe.sv.v); \
} while (0)
#define QuatConj(a, b)
Definition: quaternion.h:59
#define VectorCopy(a, b)
Definition: vector.h:59
#define DualQuatExpand (   dq)    QuatExpand ((dq).q0.q), QuatExpand ((dq).qe.q)
#define DualQuatIsZero (   a)    (QuatIsZero ((a).q0.q) && QuatIsZero ((a).qe.q))
#define DualQuatMult (   a,
  b,
 
)
Value:
do { \
Quat_t t; \
QuatMult ((a).q0.q, (b).qe.q, t.q); \
QuatMult ((a).qe.q, (b).q0.q, (c).qe.q); \
QuatAdd (t.q, (c).qe.q, (c).qe.q); \
QuatMult ((a).q0.q, (b).q0.q, (c).q0.q); \
} while (0);
void QuatMult(const quat_t q1, const quat_t q2, quat_t out)
Definition: mathlib.c:246
#define QuatAdd(a, b, c)
Definition: quaternion.h:66
#define DualQuatMultAdd (   a,
  s,
  b,
 
)
Value:
do { \
QuatMultAdd ((a).q0.q, s, (b).q0.q, (c).q0.q); \
QuatMultAdd ((a).qe.q, s, (b).qe.q, (c).qe.q); \
} while (0)
#define QuatMultAdd(a, s, b, c)
Definition: quaternion.h:80
#define DualQuatMultSub (   a,
  s,
  b,
 
)
Value:
do { \
QuatMultSub ((a).q0.q, s, (b).q0.q, (c).q0.q); \
QuatMultSub ((a).qe.q, s, (b).qe.q, (c).qe.q); \
} while (0)
#define QuatMultSub(a, s, b, c)
Definition: quaternion.h:87
#define DualQuatNegate (   a,
 
)
Value:
do { \
QuatNegate ((a).q0.q, (b).q0.q); \
QuatNegate ((a).qe.q, (b).qe.q); \
} while (0)
#define QuatNegate(a, b)
Definition: quaternion.h:52
#define DualQuatNorm (   a,
 
)
Value:
do { \
(b).r = QuatLength ((a).q0.q); \
(b).e = 2 * QDotProduct ((a).q0.q, (a).qe.q); \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define QuatLength(a)
Definition: quaternion.h:94
#define QDotProduct(a, b)
Definition: quaternion.h:43
#define DualQuatRotTrans (   rot,
  trans,
  dq 
)
Value:
do { \
QuatCopy (rot, (dq).q0.q); \
(dq).qe.sv.s = 0; \
VectorScale (trans, 0.5, (dq).qe.sv.v); \
QuatMult ((dq).qe.q, (dq).q0.q, (dq).qe.q); \
} while (0)
void QuatMult(const quat_t q1, const quat_t q2, quat_t out)
Definition: mathlib.c:246
shaderparam_t trans
Definition: glsl_bsp.c:202
#define QuatCopy(a, b)
Definition: quaternion.h:73
#define VectorScale(a, b, c)
Definition: vector.h:79
#define DualQuatScale (   a,
  b,
 
)
Value:
do { \
QuatSub ((a).q0.q, (b), (c).q0.q); \
QuatSub ((a).qe.q, (b), (c).qe.q); \
} while (0)
#define DualQuatSetVect (   vec,
 
)
Value:
do { \
(a).q0.sv.s = 1; \
VectorZero ((a).q0.sv.v); \
(a).qe.sv.s = 0; \
VectorCopy (vec, (a).qe.sv.v); \
} while (0)
#define VectorCopy(a, b)
Definition: vector.h:59
#define VectorZero(a)
Definition: vector.h:145
#define DualQuatSubtract (   a,
  b,
 
)
Value:
do { \
QuatSub ((a).q0.q, (b).q0.q, (c).q0.q); \
QuatSub ((a).qe.q, (b).qe.q, (c).qe.q); \
} while (0)
#define DualQuatZero (   a)
Value:
do { \
QuatZero ((a).q0.q); \
QuatZero ((a).qe.q); \
} while (0)
#define QuatZero(a)
Definition: quaternion.h:145
#define DualScale (   a,
  b,
 
)
Value:
do { \
(c).r = (a).r * (b); \
(c).e = (a).e * (b); \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualSet (   ar,
  ae,
 
)
Value:
do { \
(a).ar = r; \
(a).er = r; \
} while (0)
int r
Definition: net_main.c:569
#define DualSubtract (   a,
  b,
 
)
Value:
do { \
(c).r = (a).r - (b).r; \
(c).e = (a).e - (b).e; \
} while (0)
vrect_t e
Definition: test-vrect.c:54
int r
Definition: net_main.c:569
#define DualZero (   a)
Value:
do { \
(a).e = (a).r = 0; \
} while (0)
vrect_t e
Definition: test-vrect.c:54