diff options
Diffstat (limited to 'rwsdk/include/d3d8/rphanim.h')
| -rw-r--r-- | rwsdk/include/d3d8/rphanim.h | 873 |
1 files changed, 873 insertions, 0 deletions
diff --git a/rwsdk/include/d3d8/rphanim.h b/rwsdk/include/d3d8/rphanim.h new file mode 100644 index 00000000..a9b0438a --- /dev/null +++ b/rwsdk/include/d3d8/rphanim.h @@ -0,0 +1,873 @@ +/****************************************** + * * + * RenderWare(TM) Graphics Library * + * * + ******************************************/ + +/* + * This file is a product of Criterion Software Ltd. + * + * This file is provided as is with no warranties of any kind and is + * provided without any obligation on Criterion Software Ltd. + * or Canon Inc. to assist in its use or modification. + * + * Criterion Software Ltd. and Canon Inc. will not, under any + * circumstances, be liable for any lost revenue or other damages + * arising from the use of this file. + * + * Copyright (c) 1998. Criterion Software Ltd. + * All Rights Reserved. + */ + +/*************************************************************************** + * * + * Module : rpanim.h * + * * + * Purpose : Hierarchical animation * + * * + **************************************************************************/ + +#ifndef RPHANIM_H +#define RPHANIM_H + +/** + * Hierarchal animation plugin + */ + +/* Doxygen plugin groups. */ + +/** + * \defgroup rphanim RpHAnim + * \ingroup rpplugin + * + * Hierarchical Animation Plugin for RenderWare Graphics. + */ + +/** + * \defgroup rphanimchanges RpHAnim Changes + * \ingroup rphanim + * + */ + +/**************************************************************************** + Includes + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <rwcore.h> +#include <rpworld.h> + +#include <rpcriter.h> /* Note: each vendor can choose their own method for + * allocation of unique ID's. This file defines + * the ID's used by Criterion. + */ +#include <rphanim.rpe> /* automatically generated header file */ +#include <rtquat.h> + +#define rpHANIMSTREAMCURRENTVERSION 0x100 + +/** + * \ingroup rphanim + * \ref RpHAnimAtomicGlobalVars typedef for struct RpHAnimAtomicGlobalVars + */ +typedef struct RpHAnimAtomicGlobalVars RpHAnimAtomicGlobalVars; + +/** + * \ingroup rphanim + * \struct RpHAnimAtomicGlobalVars + */ +struct RpHAnimAtomicGlobalVars +{ + RwInt32 engineOffset ; /* Offset into global data */ + RwFreeList *HAnimFreeList; + RwFreeList *HAnimAnimationFreeList; +}; + +extern RpHAnimAtomicGlobalVars RpHAnimAtomicGlobals; + +#define rpHANIMSTDKEYFRAMESIZE sizeof(RpHAnimStdKeyFrame) +#define rpHANIMSTDKEYFRAMETYPEID 0x1 + +#define RwAnimMalloc() \ + RwFreeListAlloc(RpHAnimAtomicGlobals.HAnimFreeList) + +#define RwAnimFree(_anim) \ + RwFreeListFree(RpHAnimAtomicGlobals.HAnimFreeList, (_anim)) + +#define RwAnimAnimationMalloc() \ + RwFreeListAlloc(RpHAnimAtomicGlobals.HAnimAnimationFreeList) + +#define RwAnimAnimationFree(_animAnimation) \ + RwFreeListFree(RpHAnimAtomicGlobals.HAnimAnimationFreeList, \ + (_animAnimation)) + +#define RpV3dInterpolate(o, a, s, b) \ +MACRO_START \ +{ \ + (o)->x = (((a)->x) + ((s)) * (((b)->x) - ((a)->x))); \ + (o)->y = (((a)->y) + ((s)) * (((b)->y) - ((a)->y))); \ + (o)->z = (((a)->z) + ((s)) * (((b)->z) - ((a)->z))); \ +} \ +MACRO_STOP + +/** + * \ingroup rphanim + * \ref RpHAnimHierarchy typedef for struct RpHAnimHierarchy + */ +typedef struct RpHAnimHierarchy RpHAnimHierarchy; + +/** + * \ingroup rphanim + * \ref RpHAnimAnimation typedef for struct RpHAnimAnimation + */ +typedef struct RpHAnimAnimation RpHAnimAnimation; + +/** + * \ingroup rphanim + * \ref RpHAnimHierarchyCallBack + * This typedef defines a callback function for use with the + * \ref RpHAnimHierarchySetAnimCallBack and + * \ref RpHAnimHierarchySetAnimLoopCallBack functions. + * + * \param hierarchy + * A pointer to the AnimHierarchy structure. + * + * \param data User-defined data. + * You can use this to pass your own data + * structure(s) to the callback function. + * + * \see RpHAnimHierarchySetAnimCallBack + * \see RpHAnimHierarchySetAnimLoopCallBack + * + */ + +typedef RpHAnimHierarchy * (*RpHAnimHierarchyCallBack) (RpHAnimHierarchy *hierarchy, + void *data); + +/* + * The following CallBacks are needed for each overloaded interpolation + * scheme. See RpHAnimInterpolatorInfo. + */ + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameToMatrixCallBack + * This typedef defines a callback function for converting + * an animation keyframe into a modeling matrix. The output matrix will be + * used to construct the array of world or local space matrices for the + * hierarchy as obtained with \ref RpHAnimHierarchyGetMatrixArray, and + * possibly used for updating an external \ref RwFrame hierarchy. + * + * \param matrix This is the matrix to store the output of the conversion + * \param voidIFrame This is a void pointer to the keyframe and should be cast + * to the keyframe type this callback is for. + */ +typedef void (*RpHAnimKeyFrameToMatrixCallBack) (RwMatrix *matrix, void *voidIFrame); + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameBlendCallBack + * This typedef defines a callback function for blending between two animation + * keyframes by the given blend factor. + * + * \param voidOut This is the void pointer for the output of the blend + * \param voidIn1 First input keyframe + * \param voidIn2 Second input keyframe + * \param alpha Blend factor + */ +typedef void (*RpHAnimKeyFrameBlendCallBack) (void *voidOut, void *voidIn1, + void *voidIn2, RwReal alpha); + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameInterpolateCallBack + * This typedef defines a callback function for interpolating between two + * animation keyframes according to the given time. + * + * \param voidOut This is the void pointer for the output of the + * interpolation + * \param voidIn1 First input keyframe + * \param voidIn2 Second input keyframe + * \param time Time at which to interpolate + */ +typedef void (*RpHAnimKeyFrameInterpolateCallBack) (void *voidOut, void *voidIn1, + void *voidIn2, RwReal time); + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameAddCallBack + * This typedef defines a callback function for adding together two animation + * keyframes. One of the keyframes would usually be a delta. + * + * \param voidOut This is the void pointer for the output summed keyframe + * \param voidIn1 First input keyframe + * \param voidIn2 Second input keyframe + */ +typedef void (*RpHAnimKeyFrameAddCallBack) (void *voidOut, void *voidIn1, + void *voidIn2); + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameMulRecipCallBack + * This typedef defines a callback function for multiplying a keyframe + * by the inverse of another keyframe + * + * \param voidFrame This is the void pointer for the keyframe to be modified + * \param voidStart First start keyframe to take the reciprocal of. + */ +typedef void (*RpHAnimKeyFrameMulRecipCallBack) (void *voidFrame, void *voidStart); + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameStreamReadCallBack + * This typedef defines a callback function for reading in keyframes + * from an \ref RwStream for the given animation. + * + * \param stream The stream to read the keyframes from + * \param animation The animation to read the keyframes into + * + * \return Pointer to the animation. + */ +typedef RpHAnimAnimation * (*RpHAnimKeyFrameStreamReadCallBack) (RwStream *stream, RpHAnimAnimation *animation); + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameStreamWriteCallBack + * This typedef defines a callback function for writing keyframes from the + * given animation to an \ref RwStream. + * + * \param animation The animation to write out from + * \param stream The stream to write the keyframes to + * + * \return TRUE if successful. + */ +typedef RwBool (*RpHAnimKeyFrameStreamWriteCallBack) (RpHAnimAnimation *animation, RwStream *stream); + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameStreamGetSizeCallBack + * This typedef defines a callback function for calculating the binary stream + * size of keyframe data within an animation. + * + * \param animation The animation to calculate sizes of + * + * \return Size in bytes of the keyframe data. + */ +typedef RwInt32 (*RpHAnimKeyFrameStreamGetSizeCallBack) (RpHAnimAnimation *animation); + +/** + * \ingroup rphanim + * \ref RpHAnimInterpolatorInfo + * typedef for struct \ref RpHAnimInterpolatorInfo + */ +typedef struct RpHAnimInterpolatorInfo RpHAnimInterpolatorInfo; + +/** + * \ingroup rphanim + * \struct RpHAnimInterpolatorInfo + * This is used to hold information for a keyframe interpolation scheme. + * + * \see RpHAnimRegisterInterpolationScheme + * \see RpHAnimGetInterpolatorInfo + */ +struct RpHAnimInterpolatorInfo +{ + RwInt32 typeID; /**< The ID of the interpolation scheme */ + RwInt32 keyFrameSize; /**< Size in bytes of the keyframe structure */ + RpHAnimKeyFrameToMatrixCallBack keyFrameToMatrixCB; /**< Pointer to a function that converts a keyframe to a matrix */ + RpHAnimKeyFrameBlendCallBack keyFrameBlendCB; /**< Pointer to a function that blends between a pair of keyframes for a given delta value */ + RpHAnimKeyFrameInterpolateCallBack keyFrameInterpolateCB; /**< Pointer to a function that interpolates between two keyframes for a given time in between */ + RpHAnimKeyFrameAddCallBack keyFrameAddCB; /**< Pointer to a function that adds two keyframes (one of which may be a delta) */ + RpHAnimKeyFrameMulRecipCallBack keyFrameMulRecipCB; /**< Pointer to a function that multiplies a keyframe by the reciprocal of another */ + RpHAnimKeyFrameStreamReadCallBack keyFrameStreamReadCB; /**< Pointer to a function that reads the keyframes from a stream for a given animation */ + RpHAnimKeyFrameStreamWriteCallBack keyFrameStreamWriteCB; /**< Pointer to a function that writes the keyframes to a stream for a given animation */ + RpHAnimKeyFrameStreamGetSizeCallBack keyFrameStreamGetSizeCB; /**< Pointer to a function that returns the binary stream size of the keyframes for a given animation */ +}; + +/** + * \ingroup rphanim + * \ref RpHAnimKeyFrameHeader + * typedef for struct RpHAnimKeyFrameHeader + */ +typedef struct RpHAnimKeyFrameHeader RpHAnimKeyFrameHeader; + +/** + * \ingroup rphanim + * \struct RpHAnimKeyFrameHeader + * Holds header information for a keyframe. All keyframe structures used with + * the overloadable interpolation system should start with this data. + * + * \see RpHAnimStdKeyFrame + * \see RpHAnimRegisterInterpolationScheme + */ +struct RpHAnimKeyFrameHeader +{ + void *prevFrame; /**< Previous keyframe for particular hierarchy node */ + RwReal time; /**< Time at keyframe */ +}; + +/** + * \ingroup rphanim + * \ref RpHAnimStdKeyFrame + * typedef for struct RpHAnimStdKeyFrame + */ +typedef struct RpHAnimStdKeyFrame RpHAnimStdKeyFrame; + +/** + * \ingroup rphanim + * \struct RpHAnimStdKeyFrame + * A structure representing the standard keyframe data. Sequences of + * such keyframes in an \ref RpHAnimAnimation defines the animation of each + * node in a hierarchy. + */ +struct RpHAnimStdKeyFrame +{ + RpHAnimStdKeyFrame *prevFrame; /**< Previous keyframe for particular hierarchy node */ + RwReal time; /**< Time at keyframe */ + RtQuat q; /**< Quaternion rotation at keyframe */ + RwV3d t; /**< Translation at keyframe */ +}; + +/* Flags for FrameInfos */ + +#define rpHANIMPOPPARENTMATRIX 0x01 +#define rpHANIMPUSHPARENTMATRIX 0x02 + +/** + * \ingroup rphanim + * \ref RpHAnimNodeInfo + * typedef for struct RpHAnimNodeInfo + */ +typedef struct RpHAnimNodeInfo RpHAnimNodeInfo; + +/** + * \ingroup rphanim + * \struct RpHAnimNodeInfo + * + */ +struct RpHAnimNodeInfo +{ + RwInt32 nodeID; /**< User defined ID for this node */ + RwInt32 nodeIndex; /**< Array index of node */ + RwInt32 flags; /**< Matrix push/pop flags */ + RwFrame * pFrame; /**< Pointer to an attached RwFrame (see \ref RpHAnimHierarchyAttach) */ +}; + +/** + * \ingroup rphanim + * \struct RpHAnimAnimation + * A hierarchical animation consists of an array of keyframe structures, + * along with some flags and a duration. + * + * The keyframes should be presented in the order they are needed + * to animate forwards through time. Pointers link all of the keyframes + * for a particular node backwards through time in a list. + * + * For example, a 3 node animation, with keyframes at the following times: + * + * Node 1: 0.0, 1.0, 2.0, 3.0 + * Node 2: 0.0, 3.0 + * Node 3: 0.0, 2.0, 2.5, 3.0 + * + * should be formatted in an RpHAnimAnimation animation like this: + * + * B1,0.0 B2,0.0 B3,0.0 B1,1.0, B2,3.0, B3,2.0, B1,2.0, B1,3.0, B3,2.5 B3,3.0 + * + * Each node MUST start at time = 0.0, and each node must terminate with a keyframe + * at time = duration of animation. + * + * \see RpHAnimAnimationCreate + */ +struct RpHAnimAnimation +{ + RpHAnimInterpolatorInfo *interpInfo; /**< Pointer to interpolation scheme information */ + RwInt32 numFrames; /**< Number of keyframes in the animation */ + RwInt32 flags; /**< Specifies details about animation, relative translation modes etc */ + RwReal duration; /**< Duration of animation in seconds */ + void *pFrames; /**< Pointer to the animation keyframes */ +}; + +/** + * \ingroup rphanim + * \ref RpHAnimHierarchyFlag defines type and update modes in HAnimHierarchies + * + * \see RpAnimHierarchyFlag + */ +enum RpHAnimHierarchyFlag +{ + /* creation flags */ + rpHANIMHIERARCHYSUBHIERARCHY = 0x01, /**< This hierarchy is a sub-hierarchy */ + rpHANIMHIERARCHYNOMATRICES = 0x02, /**< This hierarchy has no local matrices */ + + /* update flags */ + rpHANIMHIERARCHYUPDATEMODELLINGMATRICES = 0x1000, /**< This hierarchy updates modeling matrices */ + rpHANIMHIERARCHYUPDATELTMS = 0x2000, /**< This hierarchy updates LTMs */ + rpHANIMHIERARCHYLOCALSPACEMATRICES = 0x4000, /**< This hierarchy calculates matrices in a space + relative to its root */ + + rpHANIMHIERARCHYFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; + +/** + * \ingroup rphanim + * \typedef RpHAnimHierarchyFlag + * These flags are used to control the creation and + * update status of the hierarchy + */ +typedef enum RpHAnimHierarchyFlag RpHAnimHierarchyFlag; + +/** + * \ingroup rphanim + * \struct RpHAnimHierarchy + * An RpHAnimHierarchy is used to "play back" an animation - it holds the + * interpolated keyframe data for the current state of an animation + * concatenated on the end of the structure. + * + * The rpHANIMHIERARCHYGETINTERPFRAME() macro can be used to access the current + * interpolated data, for the current time or to write to this data to override + * it with procedural animation. + * + * The structure of a hierarchy is defined by an array + * of \ref RpHAnimNodeInfo structures. + * + * The hierarchy is defined by running through the node array in order, + * pushing the parent-node's matrix whenever a child is reached that has + * more than one sibling, and popping the parent matrix when a "leaf" + * node is encountered. + * + */ +struct RpHAnimHierarchy +{ + RwInt32 flags; /**< Flags for the hierarchy */ + RwInt32 numNodes; /**< Number of nodes in the hierarchy */ + RpHAnimAnimation *pCurrentAnim; /**< Current animation applied to hierarchy */ + RwReal currentTime; /**< Current animation time */ + void *pNextFrame; /**< Next animation keyframe to be played */ + RpHAnimHierarchyCallBack pAnimCallBack; /**< Animation callback function pointer */ + void *pAnimCallBackData; /**< Animation callback function user data */ + RwReal animCallBackTime; /**< Trigger time for callback function */ + RpHAnimHierarchyCallBack pAnimLoopCallBack; /**< Animation loop callback function pointer */ + void *pAnimLoopCallBackData; /**< Animation loop callback function data */ + RwMatrix *pMatrixArray; /**< Pointer to node matrices*/ + void *pMatrixArrayUnaligned; /**< Pointer to memory used for node matrices + * from which the aligned pMatrixArray is allocated */ + RpHAnimNodeInfo *pNodeInfo; /**< Array of node information (push/pop flags etc) */ + RwFrame *parentFrame; /**< Pointer to the Root RwFrame of the hierarchy this + * RpHAnimHierarchy represents */ + RwInt32 maxKeyFrameSize; /**< Maximum size of keyframes usable on this hierarhcy + * (set at creation time) */ + RwInt32 currentKeyFrameSize; /**< Size of keyframes in the current animation */ + RpHAnimKeyFrameToMatrixCallBack keyFrameToMatrixCB; /**< Internal use */ + RpHAnimKeyFrameBlendCallBack keyFrameBlendCB; /**< Internal use */ + RpHAnimKeyFrameInterpolateCallBack keyFrameInterpolateCB; /**< Internal use */ + RpHAnimKeyFrameAddCallBack keyFrameAddCB; /**< Internal use */ + RpHAnimHierarchy *parentHierarchy; /**< Internal use */ + RwInt32 offsetInParent; /**< Internal use */ + RwInt32 rootParentOffset; /**< Internal use */ +}; + +#define rpHANIMHIERARCHYGETINTERPFRAME( hierarchy, nodeIndex ) \ + ( (void *)( ( (RwUInt8 *)&(hierarchy[1]) + \ + ((nodeIndex) * \ + hierarchy->currentKeyFrameSize) ) ) ) + +#define rpHANIMHIERARCHYGETINTERPFRAME1( hierarchy, nodeIndex ) \ + ( (void *)( ( (RwUInt8 *)&(hierarchy[1]) + \ + ((hierarchy->numNodes + \ + (nodeIndex)) * \ + hierarchy->currentKeyFrameSize) ) ) ) + +#define rpHANIMHIERARCHYGETINTERPFRAME2( hierarchy, nodeIndex ) \ + ( (void *)( ( (RwUInt8 *)&(hierarchy[1]) + \ + ((hierarchy->numNodes * 2 + \ + (nodeIndex)) * \ + hierarchy->currentKeyFrameSize) ) ) ) + +/** + * \ingroup rphanim + * \ref RpHAnimFrameExtension typedef for struct RpHAnimFrameExtension + */ + +typedef struct RpHAnimFrameExtension RpHAnimFrameExtension; + +/** + * \ingroup rphanim + * \struct RpHAnimFrameExtension + */ +struct RpHAnimFrameExtension +{ + RwInt32 id; /**< ID given to this RwFrame (default of -1) */ + RpHAnimHierarchy *hierarchy; /**< Pointer to Animation hierarchy attached to this RwFrame */ +}; + +/*--- Plugin API Functions ---*/ + +#define RpHAnimHierarchySetFlagsMacro(hierarchy, _flags) \ +MACRO_START \ +{ \ + (hierarchy)->flags = _flags; \ +} \ +MACRO_STOP + +#define RpHAnimHierarchyGetFlagsMacro(hierarchy) \ + ((hierarchy)->flags) + +#define RpHAnimStdKeyFrameToMatrixMacro(_matrix, _voidIFrame) \ +MACRO_START \ +{ \ + RpHAnimStdKeyFrame * iFrame = (RpHAnimStdKeyFrame *)(_voidIFrame); \ + \ + /* \ + * RpHAnim uses the same types of quaternion as RtQuat \ + * hence no conjugate call as in RpSkin \ + */ \ + \ + RtQuatUnitConvertToMatrix(&iFrame->q, (_matrix)); \ + \ + (_matrix)->pos.x = iFrame->t.x; \ + (_matrix)->pos.y = iFrame->t.y; \ + (_matrix)->pos.z = iFrame->t.z; \ +} \ +MACRO_STOP + + +#if (! defined(RWDEBUG)) + +#define RpHAnimHierarchySetFlags(hierarchy, _flags) \ + RpHAnimHierarchySetFlagsMacro(hierarchy, _flags) + +#define RpHAnimHierarchyGetFlags(hierarchy) \ + (RpHAnimHierarchyFlag)RpHAnimHierarchyGetFlagsMacro(hierarchy) + +#endif /* (! defined(RWDEBUG)) */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#if (defined(RWDEBUG)) + +extern RpHAnimHierarchy * +RpHAnimHierarchySetFlags(RpHAnimHierarchy *hierarchy, + RpHAnimHierarchyFlag flags); + +extern RpHAnimHierarchyFlag +RpHAnimHierarchyGetFlags(RpHAnimHierarchy *hierarchy); + +#endif /* (defined(RWDEBUG)) */ + +/* Keyframe Interpolator Types */ + +extern RwBool +RpHAnimRegisterInterpolationScheme(RpHAnimInterpolatorInfo *interpolatorInfo); + +extern RpHAnimInterpolatorInfo * +RpHAnimGetInterpolatorInfo(RwInt32 typeID); + +/* Animation hierarchy creation */ + +extern RpHAnimHierarchy * +RpHAnimHierarchyCreate(RwInt32 numNodes, + RwUInt32 *nodeFlags, + RwInt32 *nodeIDs, + RpHAnimHierarchyFlag flags, + RwInt32 maxKeyFrameSize); + +extern RpHAnimHierarchy * +RpHAnimHierarchyCreateFromHierarchy(RpHAnimHierarchy *hierarchy, + RpHAnimHierarchyFlag flags, + RwInt32 maxKeyFrameSize); + +extern RpHAnimHierarchy * +RpHAnimHierarchyDestroy(RpHAnimHierarchy *hierarchy); + +extern RpHAnimHierarchy * +RpHAnimHierarchyCreateSubHierarchy(RpHAnimHierarchy *parentHierarchy, + RwInt32 startNode, + RpHAnimHierarchyFlag flags, + RwInt32 maxKeyFrameSize); + +extern RpHAnimHierarchy * +RpHAnimHierarchyAttach(RpHAnimHierarchy *hierarchy); + +extern RpHAnimHierarchy * +RpHAnimHierarchyDetach(RpHAnimHierarchy *hierarchy); + +extern RpHAnimHierarchy * +RpHAnimHierarchyAttachFrameIndex(RpHAnimHierarchy *hierarchy, + RwInt32 nodeIndex); + +extern RpHAnimHierarchy * +RpHAnimHierarchyDetachFrameIndex(RpHAnimHierarchy *hierarchy, + RwInt32 nodeIndex); + +extern RwBool +RpHAnimFrameSetHierarchy(RwFrame *frame, + RpHAnimHierarchy *hierarchy); + +extern RpHAnimHierarchy * +RpHAnimFrameGetHierarchy(RwFrame *frame); + +/* Macros for legacy support of old function names */ +#define RpHAnimSetHierarchy(frame, hierarchy) \ + RpHAnimFrameSetHierarchy(frame, hierarchy) +#define RpHAnimGetHierarchy(frame) RpHAnimFrameGetHierarchy(frame) + +extern RwBool +RpHAnimHierarchySetKeyFrameCallBacks(RpHAnimHierarchy *hierarchy, + RwInt32 keyFrameTypeID); + +extern RwBool +RpHAnimHierarchySetCurrentAnim(RpHAnimHierarchy *hierarchy, + RpHAnimAnimation *anim); + +extern RwBool +RpHAnimHierarchySetCurrentAnimTime(RpHAnimHierarchy *hierarchy, + RwReal time); + +extern RwBool +RpHAnimHierarchySubAnimTime(RpHAnimHierarchy *hierarchy, + RwReal time); + +extern RwBool +RpHAnimHierarchyStdKeyFrameAddAnimTime(RpHAnimHierarchy *hierarchy, + RwReal time); + +extern RwBool +RpHAnimHierarchyAddAnimTime(RpHAnimHierarchy *hierarchy, + RwReal time); + +extern RpHAnimHierarchy * +RpHAnimHierarchySetAnimCallBack(RpHAnimHierarchy *hierarchy, + RpHAnimHierarchyCallBack callBack, + RwReal time, + void *data ); + +extern RpHAnimHierarchy * +RpHAnimHierarchySetAnimLoopCallBack(RpHAnimHierarchy *hierarchy, + RpHAnimHierarchyCallBack callBack, + void *data ); + +extern RwMatrix * +RpHAnimHierarchyGetMatrixArray(RpHAnimHierarchy *hierarchy); + +extern RwBool +RpHAnimHierarchyUpdateMatrices(RpHAnimHierarchy *hierarchy); + +/* Macro for legacy support of old function name */ +#define RpHAnimUpdateHierarchyMatrices RpHAnimHierarchyUpdateMatrices + +extern RwInt32 +RpHAnimIDGetIndex(RpHAnimHierarchy *hierarchy, + RwInt32 ID); + +/* Animations */ + +extern RpHAnimAnimation * +RpHAnimAnimationCreate(RwInt32 typeID, + RwInt32 numFrames, + RwInt32 flags, + RwReal duration); + +extern RpHAnimAnimation * +RpHAnimAnimationDestroy(RpHAnimAnimation *animation); + +#ifdef RWDEBUG + +extern RwInt32 +RpHAnimAnimationGetTypeID(RpHAnimAnimation *animation); + +#else /* RWDEBUG */ + +#define RpHAnimAnimationGetTypeID(animation) \ + (animation->interpInfo->typeID) + +#endif /* RWDEBUG */ + +extern RpHAnimAnimation * +RpHAnimAnimationRead(const RwChar * filename); + +extern RwBool +RpHAnimAnimationWrite(RpHAnimAnimation *animation, + const RwChar * filename); + +extern RpHAnimAnimation * +RpHAnimAnimationStreamRead(RwStream *stream); + +extern RwBool +RpHAnimAnimationStreamWrite(RpHAnimAnimation *animation, + RwStream *stream); + +extern RwInt32 +RpHAnimAnimationStreamGetSize(RpHAnimAnimation *animation); + +extern RwBool +RpHAnimAnimationMakeDelta(RpHAnimAnimation *animation, + RwInt32 numNodes, + RwReal time); + +/* Plugin support */ + +extern RwBool +RpHAnimPluginAttach(void); + +/* Overloadable keyframe functions */ + +#define RpHAnimFrameToMatrixMacro(hierarchy, matrix, iFrame) \ +MACRO_START \ +{ \ + const RpHAnimKeyFrameToMatrixCallBack keyFrameToMatrixCB = \ + (hierarchy)->keyFrameToMatrixCB; \ + \ + if (RpHAnimStdKeyFrameToMatrix == keyFrameToMatrixCB) \ + { \ + RpHAnimStdKeyFrameToMatrixMacro((matrix), (iFrame)); \ + } \ + else \ + { \ + keyFrameToMatrixCB((matrix), (iFrame)); \ + } \ +} \ +MACRO_STOP + +#define RpHAnimFrameInterpolateMacro(hierarchy, out, in1, in2, time) \ +MACRO_START \ +{ \ + (hierarchy)->keyFrameInterpolateCB((out), (in1), (in2), (time)); \ +} \ +MACRO_STOP + +#define RpHAnimFrameBlendMacro(hierarchy, out, in1, in2, fAlpha) \ +MACRO_START \ +{ \ + (hierarchy)->keyFrameBlendCB((out), (in1), (in2), (fAlpha)); \ +} \ +MACRO_STOP + +#define RpHAnimFrameAddTogetherMacro(hierarchy, out, in1, in2) \ +MACRO_START \ +{ \ + (hierarchy)->keyFrameAddCB((out), (in1), (in2)); \ +} \ +MACRO_STOP + +#ifdef RWDEBUG +void +RpHAnimFrameInterpolate(RpHAnimHierarchy *hierarchy, + void *out, void *in1, + void *in2, RwReal time); + +void +RpHAnimFrameBlend(RpHAnimHierarchy *hierarchy, + void *out, + void *in1, + void *in2, + RwReal alpha); + +void +RpHAnimFrameToMatrix(RpHAnimHierarchy *hierarchy, + RwMatrix *matrix, void *iFrame); + +void +RpHAnimFrameAddTogether(RpHAnimHierarchy *hierarchy, + void *out, void *in1, void *in2); + +#else /* RWDEBUG */ + +#define RpHAnimFrameToMatrix(hierarchy, matrix, iFrame) \ + RpHAnimFrameToMatrixMacro(hierarchy, matrix, iFrame) + +#define RpHAnimFrameInterpolate(hierarchy, out, in1, in2, time) \ + RpHAnimFrameInterpolateMacro(hierarchy, out, in1, in2, time) + +#define RpHAnimFrameBlend(hierarchy, out, in1, in2, alpha) \ + RpHAnimFrameBlendMacro(hierarchy, out, in1, in2, alpha) + +#define RpHAnimFrameAddTogether(hierarchy, out, in1, in2) \ + RpHAnimFrameAddTogetherMacro(hierarchy, out, in1, in2) + +#endif /* RWDEBUG */ + +/* Standard keyframe functions */ + +extern void +RpHAnimStdKeyFrameToMatrix(RwMatrix *matrix, + void * voidIFrame); + +extern void +RpHAnimStdKeyFrameBlend(void *voidOut, + void *voidIn1, + void *voidIn2, + RwReal alpha); + +extern void +RpHAnimStdKeyFrameInterpolate(void *voidOut, + void *voidIn1, + void *voidIn2, + RwReal time); + +extern void +RpHAnimStdKeyFrameAdd(void *voidOut, + void *voidIn1, + void *voidIn2); + +extern void +RpHAnimStdKeyFrameMulRecip(void *voidFrame, + void *voidStart); + +extern RpHAnimAnimation * +RpHAnimStdKeyFrameStreamRead(RwStream *stream, + RpHAnimAnimation *animation); + +extern RwBool +RpHAnimStdKeyFrameStreamWrite(RpHAnimAnimation *animation, + RwStream *stream); + +extern RwInt32 +RpHAnimStdKeyFrameStreamGetSize(RpHAnimAnimation *animation); + +/* Hierarchy blending/combination functions */ + +extern RwBool +RpHAnimHierarchyBlend(RpHAnimHierarchy *outHierarchy, + RpHAnimHierarchy *inHierarchy1, + RpHAnimHierarchy *inHierarchy2, + RwReal alpha); +extern RwBool +RpHAnimHierarchyAddTogether(RpHAnimHierarchy *outHierarchy, + RpHAnimHierarchy *inHierarchy1, + RpHAnimHierarchy *inHierarchy2); + +extern RwBool +RpHAnimHierarchyBlendSubHierarchy(RpHAnimHierarchy *outHierarchy, + RpHAnimHierarchy *inHierarchy1, + RpHAnimHierarchy *inHierarchy2, + RwReal alpha); +extern RwBool +RpHAnimHierarchyAddSubHierarchy(RpHAnimHierarchy *outHierarchy, + RpHAnimHierarchy *mainHierarchy, + RpHAnimHierarchy *subHierarchy); + +extern RwBool +RpHAnimHierarchyCopy(RpHAnimHierarchy *outHierarchy, + RpHAnimHierarchy *inHierarchy); + +/* Access to RwFrame ID's */ + +extern RwBool +RpHAnimFrameSetID(RwFrame *frame, + RwInt32 id); + +extern RwInt32 +RpHAnimFrameGetID(RwFrame *frame); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#endif /* RPHANIM_H */ |