a3x/re3
1
0
Fork 0
mirror of https://git.rip/DMCA_FUCKER/re3.git synced 2024-11-01 05:35:55 +00:00
Code Issues Projects Releases Wiki Activity
re3/sdk/rwsdk/include/d3d8/rphanim.h

874 lines
32 KiB
C
Raw Normal View History

more work on CPhysical
2019-05-18 10:39:39 +00:00
/******************************************
* *
* 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 */
Reference in a new issue Copy permalink