summaryrefslogtreecommitdiffstats
path: root/sdk/rwsdk/include/d3d8/rtquat.h
diff options
context:
space:
mode:
authorFilip Gawin <filip.gawin@zoho.com>2020-12-29 18:59:40 +0100
committerFilip Gawin <filip.gawin@zoho.com>2020-12-29 18:59:40 +0100
commita73f5340a2d12537437479317bdf351715991c12 (patch)
treea971d86ad2f88dbd7503bf2186080c72221d82ca /sdk/rwsdk/include/d3d8/rtquat.h
parentMore menu error sound fix (diff)
downloadre3-a73f5340a2d12537437479317bdf351715991c12.tar
re3-a73f5340a2d12537437479317bdf351715991c12.tar.gz
re3-a73f5340a2d12537437479317bdf351715991c12.tar.bz2
re3-a73f5340a2d12537437479317bdf351715991c12.tar.lz
re3-a73f5340a2d12537437479317bdf351715991c12.tar.xz
re3-a73f5340a2d12537437479317bdf351715991c12.tar.zst
re3-a73f5340a2d12537437479317bdf351715991c12.zip
Diffstat (limited to 'sdk/rwsdk/include/d3d8/rtquat.h')
-rw-r--r--sdk/rwsdk/include/d3d8/rtquat.h646
1 files changed, 0 insertions, 646 deletions
diff --git a/sdk/rwsdk/include/d3d8/rtquat.h b/sdk/rwsdk/include/d3d8/rtquat.h
deleted file mode 100644
index a0a6e89d..00000000
--- a/sdk/rwsdk/include/d3d8/rtquat.h
+++ /dev/null
@@ -1,646 +0,0 @@
-/*
- * Data structures for Quaternions
- * See http://www-groups.dcs.st-and.ac.uk/~history/Mathematicians/Hamilton.html
- *
- * Copyright (c) Criterion Software Limited
- */
-
-#ifndef RTQUAT_H
-#define RTQUAT_H
-
-/**
- * \defgroup rtquat RtQuat
- * \ingroup mathtools
- *
- * Quaternion Toolkit for RenderWare.
- *
- * See also http://www.gamasutra.com/features/19980703/quaternions_01.htm
- */
-
-/*
- * See http://www-groups.dcs.st-and.ac.uk/~history/Mathematicians/Hamilton.html
- * On 16 October 1843 (a Monday) Hamilton was walking in along the Royal
- * Canal with his wife to preside at a Council meeting of the Royal Irish
- * Academy.
- *
- * Although his wife talked to him now and again Hamilton hardly
- * heard, for the discovery of the quaternions, the first noncommutative
- * algebra to be studied, was taking shape in his mind:-
- *
- * "And here there dawned on me the notion that we must admit, in
- * some sense, a fourth dimension of space for the purpose of calculating
- * with triples ... An electric circuit seemed to close, and a spark
- * flashed forth."
- */
-
-
-/****************************************************************************
- Includes
- */
-
-#include <math.h>
-/* renderware */
-#include "rwcore.h"
-
-#include "rtquat.rpe" /* automatically generated header file */
-
-#define RW_TOL_ORTHONORMAL ((RwReal)0.01)
-
-/****************************************************************************
- Global Types
- */
-
-
-typedef struct RtQuat RtQuat;
-/**
- * \ingroup rtquat
- * \struct RtQuat
- * A structure describing a Quaternion
- *
-*/
-struct RtQuat
-{
- RwV3d imag; /**< The imaginary part(s) */
- RwReal real; /**< The real part */
-};
-
-
-/****************************************************************************
- Defines
- */
-
-#define RtQuatInitMacro( result, _x, _y, _z, _w) \
-MACRO_START \
-{ \
- (result)->real = (_w); \
- (result)->imag.x = (_x); \
- (result)->imag.y = (_y); \
- (result)->imag.z = (_z); \
-} \
-MACRO_STOP
-
-#if (!defined(RtQuatAssignMacro))
-#define RtQuatAssignMacro(_target, _source) \
- ( *(_target) = *(_source) )
-#endif /* (!defined(RtQuatAssignMacro)) */
-
-#define RtQuatAddMacro( result, q1, q2 ) \
-MACRO_START \
-{ \
- (result)->real = (q1)->real + (q2)->real; \
- RwV3dAddMacro(&(result)->imag, &(q1)->imag, &(q2)->imag); \
-} \
-MACRO_STOP
-
-#define RtQuatIncrementRealPartMacro(result, s, q) \
-MACRO_START \
-{ \
- (result)->real = (q)->real + s; \
- (result)->imag.x = (q)->imag.x; \
- (result)->imag.y = (q)->imag.y; \
- (result)->imag.z = (q)->imag.z; \
-} \
-MACRO_STOP
-
-#define RtQuatDecrementRealPartMacro(result, s, q) \
-MACRO_START \
-{ \
- (result)->real = (q)->real - s; \
- (result)->imag.x = (q)->imag.x; \
- (result)->imag.y = (q)->imag.y; \
- (result)->imag.z = (q)->imag.z; \
-} \
-MACRO_STOP
-
-#define RtQuatIncrementMacro( result, dq ) \
-MACRO_START \
-{ \
- (result)->real = (result)->real + (dq)->real; \
- RwV3dAddMacro(&(result)->imag, &(result)->imag, &(dq)->imag); \
-} \
-MACRO_STOP
-
-#define RtQuatSubMacro( result, q1, q2 ) \
-MACRO_START \
-{ \
- (result)->real = (q1)->real - (q2)->real; \
- RwV3dSubMacro(&(result)->imag, &(q1)->imag, &(q2)->imag); \
-} \
-MACRO_STOP
-
-#define RtQuatNegateMacro( result, q ) \
-MACRO_START \
-{ \
- (result)->real = -(q)->real; \
- (result)->imag.x = -(q)->imag.x; \
- (result)->imag.y = -(q)->imag.y; \
- (result)->imag.z = -(q)->imag.z; \
-} \
-MACRO_STOP
-
-#define RtQuatConjugateMacro( result, q) \
-MACRO_START \
-{ \
- (result)->real = (q)->real; \
- (result)->imag.x = -(q)->imag.x; \
- (result)->imag.y = -(q)->imag.y; \
- (result)->imag.z = -(q)->imag.z; \
-} \
-MACRO_STOP
-
-#define RtQuatScaleMacro(result, q, scale ) \
-MACRO_START \
-{ \
- (result)->real = (q)->real * scale; \
- RwV3dScaleMacro(&(result)->imag, &(q)->imag, scale); \
-} \
-MACRO_STOP
-
-#define RtQuatModulusSquaredMacro( q ) \
- ((q)->real * (q)->real + \
- RwV3dDotProductMacro(&(q)->imag, &(q)->imag))
-
-#define RtQuatModulusMacro( result, q ) \
-MACRO_START \
-{ \
- (result) = RtQuatModulusSquaredMacro(q); \
- rwSqrtMacro(&result, result); \
-} \
-MACRO_STOP
-
-#define RtQuatMultiplyMacro( result, q1, q2) \
-MACRO_START \
-{ \
- /* \
- * Assumes q1 != result != q2 \
- */ \
- (result)->real = \
- (q1)->real * (q2)->real - \
- RwV3dDotProductMacro(&(q1)->imag,&(q2)->imag); \
- RwV3dCrossProductMacro(&(result)->imag, &(q1)->imag, &(q2)->imag); \
- RwV3dIncrementScaledMacro(&(result)->imag, &(q2)->imag, (q1)->real); \
- RwV3dIncrementScaledMacro(&(result)->imag, &(q1)->imag, (q2)->real); \
-} \
-MACRO_STOP
-
-#define RtQuatReciprocalMacro( result, q) \
-MACRO_START \
-{ \
- /* \
- * Assumes result != q \
- */ \
- RwReal val = RtQuatModulusSquaredMacro(q); \
- \
- if (val > (RwReal) 0) \
- { \
- val = ((RwReal)1) / val; \
- (result)->real = (q)->real * val; \
- val = -val; \
- RwV3dScaleMacro(&(result)->imag, &(q)->imag, val); \
- } \
-} \
-MACRO_STOP
-
-#define RtQuatSquareMacro( result, q ) \
-MACRO_START \
-{ \
- /* \
- * Assumes result != q \
- */ \
- RwReal val = ((RwReal)2) * (q)->real ; \
- \
- (result)->real = \
- (q)->real * (q)->real - \
- RwV3dDotProductMacro(&(q)->imag, &(q)->imag); \
- RwV3dScaleMacro(&(result)->imag, &(q)->imag, val); \
-} \
-MACRO_STOP
-
-#define RtQuatSquareRootMacro( result, q ) \
-MACRO_START \
-{ \
- /* \
- * Assumes result != q \
- * other root is of course -result \
- */ \
- RwReal val; \
- \
- RtQuatModulusMacro(val,q); \
- val = ((q)->real + val) * ((RwReal) 0.5); \
- \
- if (val > ((RwReal)0)) \
- { \
- rwSqrtMacro(&val, val); \
- (result)->real = val; \
- val = ((RwReal)0.5) / val; \
- RwV3dScale(&(result)->imag, &(q)->imag, val); \
- } \
- else \
- { \
- result->imag.x = -(q)->real; \
- rwSqrtMacro(&(result->imag.x), result->imag.x); \
- result->imag.y = ((RwReal)0); \
- result->imag.x = ((RwReal)0); \
- result->real = ((RwReal)0); \
- } \
-} \
-MACRO_STOP
-
-#define RtQuatLogMacro(result, q) \
-MACRO_START \
-{ \
- /* \
- * Assumes result != q \
- */ \
- const RwReal mod2 = RtQuatModulusSquaredMacro(q); \
- RwReal sin_b; \
- RwReal radians; \
- RwReal factor; \
- \
- sin_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
- rwSqrtMacro(&sin_b, sin_b); \
- radians = (RwReal) RwATan2(sin_b, (q)->real); \
- factor = (sin_b > (RwReal) 0) ? (((RwReal)radians) / sin_b) : 0 ; \
- \
- RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
- (result)->real = ((RwReal) RwLog(mod2)) * ((RwReal) 0.5); \
- \
-} \
-MACRO_STOP
-
-#define RtQuatExpMacro(result, q) \
-MACRO_START \
-{ \
- /* \
- * Assumes result != q \
- */ \
- const RwReal exp_a = (RwReal)RwExp((q)->real); \
- RwReal mod_b; \
- RwReal factor; \
- \
- mod_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
- rwSqrtMacro(&mod_b, mod_b); \
- factor = ( (mod_b > (RwReal) 0) ? \
- (exp_a * ((RwReal)RwSin(mod_b)) / mod_b) : \
- 0 ) ; \
- \
- RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
- (result)->real = exp_a * (RwReal)RwCos(mod_b); \
-} \
-MACRO_STOP
-
-#define RtQuatPowMacro( result, q, e) \
-MACRO_START \
-{ \
- RtQuat qLog; \
- \
- RtQuatLogMacro(&qLog, q); \
- RtQuatScaleMacro(&qLog, &qLog, e); \
- RtQuatExpMacro(result, &qLog); \
-} \
-MACRO_STOP
-
-#define RtQuatUnitLogMacro(result, q) \
-MACRO_START \
-{ \
- /* \
- * Assumes result != q \
- */ \
- RwReal sin_b ; \
- RwReal radians ; \
- RwReal factor ; \
- \
- sin_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
- rwSqrtMacro(&sin_b, sin_b); \
- radians = (RwReal)RwATan2(sin_b, (q)->real); \
- factor = (sin_b > (RwReal) 0) ? (((RwReal)radians) / sin_b) : 0 ; \
- \
- RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
- (result)->real = (RwReal)0; \
- \
-} \
-MACRO_STOP
-
-#define RtQuatUnitExpMacro(result, q) \
-MACRO_START \
-{ \
- /* \
- * Assumes result != q \
- */ \
- RwReal mod_b; \
- RwReal factor; \
- \
- mod_b = RwV3dDotProduct(&(q)->imag, &(q)->imag); \
- rwSqrtMacro(&mod_b, mod_b); \
- factor = (mod_b > (RwReal) 0) ? (((RwReal)RwSin(mod_b)) / mod_b) : 0 ; \
- \
- RwV3dScaleMacro(&(result)->imag, &(q)->imag, factor); \
- (result)->real = (RwReal)RwCos(mod_b); \
- \
-} \
-MACRO_STOP
-
-#define RtQuatUnitPowMacro( result, q, e) \
-MACRO_START \
-{ \
- RtQuat qLog; \
- \
- RtQuatUnitLogMacro(&qLog, q); \
- RwV3dScaleMacro(&qLog.imag, &qLog.imag, e); \
- RtQuatUnitExpMacro(result, &qLog); \
-} \
-MACRO_STOP
-
-#define RtQuatConvertToMatrixMacro(qpQuat, mpMatrix) \
-MACRO_START \
-{ \
- RwReal rS; \
- RwV3d rV; \
- RwV3d rW; \
- RwV3d square; \
- RwV3d cross; \
- \
- rS = ((RwReal) 2) / RtQuatModulusSquaredMacro((qpQuat)); \
- \
- RwV3dScale(&rV, &(qpQuat)->imag, rS); \
- RwV3dScale(&rW, &rV, (qpQuat)->real); \
- \
- square.x = (qpQuat)->imag.x * rV.x; \
- square.y = (qpQuat)->imag.y * rV.y; \
- square.z = (qpQuat)->imag.z * rV.z; \
- \
- cross.x = (qpQuat)->imag.y * rV.z; \
- cross.y = (qpQuat)->imag.z * rV.x; \
- cross.z = (qpQuat)->imag.x * rV.y; \
- \
- (mpMatrix)->right.x = ((RwReal) 1) - (square.y + square.z); \
- (mpMatrix)->right.y = cross.z + rW.z; \
- (mpMatrix)->right.z = cross.y - rW.y; \
- \
- (mpMatrix)->up.x = cross.z - rW.z; \
- (mpMatrix)->up.y = ((RwReal) 1) - (square.z + square.x); \
- (mpMatrix)->up.z = cross.x + rW.x; \
- \
- (mpMatrix)->at.x = cross.y + rW.y; \
- (mpMatrix)->at.y = cross.x - rW.x; \
- (mpMatrix)->at.z = ((RwReal) 1) - (square.x + square.y); \
- \
- /* Set position */ \
- (mpMatrix)->pos.x = ((RwReal) 0); \
- (mpMatrix)->pos.y = ((RwReal) 0); \
- (mpMatrix)->pos.z = ((RwReal) 0); \
- \
- /* Matrix is orthogonal */ \
- rwMatrixSetFlags((mpMatrix), \
- (rwMATRIXTYPEORTHOGONAL & \
- ~rwMATRIXINTERNALIDENTITY) ); \
- \
-} \
-MACRO_STOP
-
-#define RtQuatUnitConvertToMatrixMacro(qpQuat, mpMatrix) \
-MACRO_START \
-{ \
- const RwReal x = (qpQuat)->imag.x; \
- const RwReal y = (qpQuat)->imag.y; \
- const RwReal z = (qpQuat)->imag.z; \
- const RwReal w = (qpQuat)->real; \
- RwV3d square; \
- RwV3d cross; \
- RwV3d wimag; \
- \
- square.x = x * x; \
- square.y = y * y; \
- square.z = z * z; \
- \
- cross.x = y * z; \
- cross.y = z * x; \
- cross.z = x * y; \
- \
- wimag.x = w * x; \
- wimag.y = w * y; \
- wimag.z = w * z; \
- \
- (mpMatrix)->right.x = 1 - 2 * (square.y + square.z); \
- (mpMatrix)->right.y = 2 * (cross.z + wimag.z); \
- (mpMatrix)->right.z = 2 * (cross.y - wimag.y); \
- \
- (mpMatrix)->up.x = 2 * (cross.z - wimag.z); \
- (mpMatrix)->up.y = 1 - 2 * (square.x + square.z); \
- (mpMatrix)->up.z = 2 * (cross.x + wimag.x); \
- \
- (mpMatrix)->at.x = 2 * (cross.y + wimag.y); \
- (mpMatrix)->at.y = 2 * (cross.x - wimag.x); \
- (mpMatrix)->at.z = (1 - 2 * (square.x + square.y)); \
- \
- /* Set position */ \
- (mpMatrix)->pos.x = ((RwReal) 0); \
- (mpMatrix)->pos.y = ((RwReal) 0); \
- (mpMatrix)->pos.z = ((RwReal) 0); \
- \
- /* Matrix is orthonormal */ \
- rwMatrixSetFlags((mpMatrix), \
- (rwMATRIXTYPEORTHONORMAL & \
- ~rwMATRIXINTERNALIDENTITY) ); \
-} \
-MACRO_STOP
-
-#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
-
-#define RtQuatInit( result, _x, _y, _z, _w) \
- RtQuatInitMacro( result, _x, _y, _z, _w)
-
-#define RtQuatAssign( to, from ) \
- RtQuatAssignMacro( to, from )
-
-#define RtQuatAdd( result, q1, q2 ) \
- RtQuatAddMacro( result, q1, q2 )
-
-#define RtQuatIncrementRealPart(result, s, q) \
- RtQuatIncrementRealPartMacro(result, s, q)
-
-#define RtQuatDecrementRealPart(result, s, q) \
- RtQuatDecrementRealPartMacro(result, s, q)
-
-#define RtQuatIncrement( result, dq ) \
- RtQuatIncrementMacro( result, dq )
-
-#define RtQuatSub( result, q1, q2 ) \
- RtQuatSubMacro( result, q1, q2 )
-
-#define RtQuatNegate( result, q ) \
- RtQuatNegateMacro( result, q )
-
-#define RtQuatConjugate( result, q) \
- RtQuatConjugateMacro( result, q)
-
-#define RtQuatScale(result, q, scale ) \
- RtQuatScaleMacro(result, q, scale )
-
-#define RtQuatModulusSquared( q ) \
- RtQuatModulusSquaredMacro( q )
-
-#define RtQuatMultiply( result, q1, q2) \
- RtQuatMultiplyMacro( result, q1, q2)
-
-#define RtQuatReciprocal( result, q) \
- RtQuatReciprocalMacro( result, q)
-
-#define RtQuatSquare( result, q ) \
- RtQuatSquareMacro( result, q )
-
-#define RtQuatSquareRoot( result, q ) \
- RtQuatSquareRootMacro( result, q )
-
-#define RtQuatLog( result, q ) \
- RtQuatLogMacro( result, q )
-
-#define RtQuatExp( result, q ) \
- RtQuatExpMacro( result, q )
-
-#define RtQuatPow( result, q, e ) \
- RtQuatPowMacro( result, q, e )
-
-#define RtQuatUnitLog( result, q ) \
- RtQuatUnitLogMacro( result, q )
-
-#define RtQuatUnitExp( result, q ) \
- RtQuatUnitExpMacro( result, q )
-
-#define RtQuatUnitPow( result, q, e ) \
- RtQuatUnitPowMacro( result, q, e )
-
-#define RtQuatConvertToMatrix(qpQuat, mpMatrix) \
- RtQuatConvertToMatrixMacro(qpQuat, mpMatrix)
-
-#define RtQuatUnitConvertToMatrix(qpQuat, mpMatrix) \
- RtQuatUnitConvertToMatrixMacro(qpQuat, mpMatrix)
-
-#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */
-
-/****************************************************************************
- Function prototypes
- */
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-extern RwBool
-RtQuatConvertFromMatrix(RtQuat * const qpQuat,
- const RwMatrix * const mpMatrix);
-
-extern RtQuat *
-RtQuatRotate(RtQuat * quat,
- const RwV3d * axis,
- RwReal angle,
- RwOpCombineType combineOp);
-
-extern const RtQuat *
-RtQuatQueryRotate(const RtQuat *quat,
- RwV3d * unitAxis,
- RwReal * angle);
-
-extern RwV3d *
-RtQuatTransformVectors(RwV3d * vectorsOut,
- const RwV3d * vectorsIn,
- const RwInt32 numPoints,
- const RtQuat *quat);
-
-extern RwReal
-RtQuatModulus(RtQuat * q);
-
-#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
-
-extern void
-RtQuatInit(RtQuat * result, RwReal x, RwReal y, RwReal z, RwReal w);
-
-extern void
-RtQuatAssign(RtQuat * to, RtQuat * from);
-
-extern void
-RtQuatAdd(RtQuat * result, RtQuat * q1, RtQuat * q2);
-
-extern void
-RtQuatIncrementRealPart(RtQuat * result, RwReal s, RtQuat * q);
-
-extern void
-RtQuatDecrementRealPart(RtQuat * result, RwReal s, RtQuat * q);
-
-extern void
-RtQuatIncrement(RtQuat * result, RtQuat * dq);
-
-extern void
-RtQuatSub(RtQuat * result, RtQuat * q1, RtQuat * q2);
-
-extern void
-RtQuatNegate(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatConjugate(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatScale(RtQuat * result, RtQuat * q, RwReal scale);
-
-extern RwReal
-RtQuatModulusSquared(RtQuat * q);
-
-extern void
-RtQuatMultiply(RtQuat * result, RtQuat * q1, RtQuat * q2);
-
-extern void
-RtQuatReciprocal(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatSquare(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatSquareRoot(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatLog(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatExp(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatPow(RtQuat * result, RtQuat * q, RwReal e);
-
-extern void
-RtQuatUnitLog(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatUnitExp(RtQuat * result, RtQuat * q);
-
-extern void
-RtQuatUnitPow(RtQuat * result, RtQuat * q, RwReal e);
-
-extern void
-RtQuatConvertToMatrix(const RtQuat * const qpQuat,
- RwMatrix * const mpMatrix);
-
-extern void
-RtQuatUnitConvertToMatrix(const RtQuat * const qpQuat,
- RwMatrix * const mpMatrix);
-
-#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-/*
- * Backwards compatibility code
- */
-
-typedef RtQuat RpQuat;
-
-#define RpAnimQuatConvertFromMatrix(qpQuat, mpMatrix) \
- RtQuatConvertFromMatrix(qpQuat, mpMatrix)
-
-#define RpAnimQuatConvertToMatrix(qpQuat,mpMatrix) \
- RtQuatUnitConvertToMatrix(qpQuat,mpMatrix)
-
-
-#endif /* RTQUAT_H */
-