diff options
Diffstat (limited to '')
| -rw-r--r-- | sdk/rwsdk/include/d3d8/rphanim.h | 873 |
1 files changed, 0 insertions, 873 deletions
diff --git a/sdk/rwsdk/include/d3d8/rphanim.h b/sdk/rwsdk/include/d3d8/rphanim.h deleted file mode 100644 index a9b0438a..00000000 --- a/sdk/rwsdk/include/d3d8/rphanim.h +++ /dev/null @@ -1,873 +0,0 @@ -/****************************************** - * * - * 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 */ |