From a786dd45a4ebc6b91936b5e46d0ef0a9befc05af Mon Sep 17 00:00:00 2001 From: Sergeanur Date: Sun, 2 Aug 2020 19:36:50 +0300 Subject: Move sdk and eax --- sdk/rwsdk/include/d3d8/rtquat.h | 646 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 646 insertions(+) create mode 100644 sdk/rwsdk/include/d3d8/rtquat.h (limited to 'sdk/rwsdk/include/d3d8/rtquat.h') diff --git a/sdk/rwsdk/include/d3d8/rtquat.h b/sdk/rwsdk/include/d3d8/rtquat.h new file mode 100644 index 00000000..05e971d0 --- /dev/null +++ b/sdk/rwsdk/include/d3d8/rtquat.h @@ -0,0 +1,646 @@ +/* + * 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 rttool + * + * 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 +/* 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), \ + (rwMATRIXTYPEORTHOGANAL & \ + ~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 */ + -- cgit v1.2.3