You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
655 lines
24 KiB
C
655 lines
24 KiB
C
#ifndef RTANIM_H
|
|
#define RTANIM_H
|
|
|
|
#include "rtanim.rpe" /* automatically generated header file */
|
|
|
|
#define rtANIMSTREAMCURRENTVERSION 0x100
|
|
|
|
/* Doxygen plugin groups. */
|
|
|
|
/**
|
|
* \defgroup rtanim RtAnim
|
|
* \ingroup animtools
|
|
*
|
|
* Animation Toolkit for RenderWare Graphics.
|
|
*/
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* Typedef for struct \ref RtAnimAnimation.
|
|
*/
|
|
typedef struct RtAnimAnimation RtAnimAnimation;
|
|
|
|
/*
|
|
* The following CallBacks are needed for each interpolation scheme.
|
|
* See RtAnimInterpolatorInfo.
|
|
*/
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameApplyCallBack
|
|
* defines a callback function for converting
|
|
* an interpolated animation keyframe into the required result.
|
|
*
|
|
* \param result Void pointer to store the output of the conversion.
|
|
* \param voidIFrame Void pointer to the keyframe and should be cast
|
|
* to the interpolated keyframe type this callback
|
|
* is for.
|
|
*/
|
|
typedef void (*RtAnimKeyFrameApplyCallBack) (void *result, void *voidIFrame);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameBlendCallBack
|
|
* defines a callback function for blending between two
|
|
* interpolated keyframes by the given blend factor. This is used for
|
|
* blending the states of two different \ref RtAnimInterpolator objects.
|
|
* The \ref RtAnimKeyFrameInterpolateCallBack is used for interpolating
|
|
* actual animation keyframes into an interpolated frame.
|
|
*
|
|
* \param voidOut Void pointer to store the output of the blend.
|
|
* \param voidIn1 Void pointer containing the first input
|
|
* interpolated keyframe.
|
|
* \param voidIn2 Void pointer containing the second input
|
|
* interpolated keyframe.
|
|
* \param alpha \ref RwReal containing the blend factor.
|
|
*/
|
|
typedef void (*RtAnimKeyFrameBlendCallBack) (void *voidOut, void *voidIn1,
|
|
void *voidIn2, RwReal alpha);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameInterpolateCallBack
|
|
* defines a callback function for interpolating between two
|
|
* animation keyframes according to the given time. The output is
|
|
* an interpolated frame object residing in an \ref RtAnimInterpolator
|
|
* and will usually have the same structure as the keyframe apart from
|
|
* the header data (\ref RtAnimInterpFrameHeader).
|
|
*
|
|
* \param voidOut Void pointer for the output of the interpolation.
|
|
* \param voidIn1 Void pointer containing the first input keyframe.
|
|
* \param voidIn2 Void pointer containing the second input keyframe.
|
|
* \param time \ref RwReal containing the time at which to interpolate.
|
|
* \param customData Void pointer to the custom data associated with this
|
|
* animation
|
|
*/
|
|
typedef void (*RtAnimKeyFrameInterpolateCallBack) (void *voidOut, void *voidIn1,
|
|
void *voidIn2, RwReal time,
|
|
void *customData);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameAddCallBack
|
|
* defines a callback function for adding two interpolated
|
|
* keyframes together. This is used when adding the states of two
|
|
* \ref RtAnimInterpolator objects, such as when adding a delta animation
|
|
* to a base animation.
|
|
*
|
|
* \param voidOut Void pointer for the output interpolated frame.
|
|
* \param voidIn1 Void pointer containing the first input
|
|
* interpoalted keyframe.
|
|
* \param voidIn2 Void pointer containing the second input
|
|
* interpolated keyframe.
|
|
*/
|
|
typedef void (*RtAnimKeyFrameAddCallBack) (void *voidOut, void *voidIn1,
|
|
void *voidIn2);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameMulRecipCallBack
|
|
* defines a callback function for multiplying a keyframe
|
|
* by the inverse of another keyframe. This is used for creating delta
|
|
* animations.
|
|
*
|
|
* \param voidFrame Void pointer for the keyframe to be modified.
|
|
* \param voidStart Void pointer for the start keyframe to take the reciprocal of.
|
|
*/
|
|
typedef void (*RtAnimKeyFrameMulRecipCallBack)
|
|
(void *voidFrame, void *voidStart);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameStreamReadCallBack
|
|
* defines a callback function for reading in keyframes
|
|
* from an \ref RwStream for the given animation.
|
|
*
|
|
* \param stream Pointer to the \ref RwStream to read the keyframes from.
|
|
* \param animation Pointer to the \ref RtAnimAnimation to read the keyframes into.
|
|
*
|
|
* \return Pointer to the \ref RtAnimAnimation.
|
|
*/
|
|
typedef RtAnimAnimation * (*RtAnimKeyFrameStreamReadCallBack)
|
|
(RwStream *stream, RtAnimAnimation *animation);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameStreamWriteCallBack
|
|
* defines a callback function for writing keyframes from the
|
|
* given animation to an \ref RwStream.
|
|
*
|
|
* \param animation Pointer to the \ref RtAnimAnimation to write out from.
|
|
* \param stream Pointer to the \ref RwStream to write the keyframes to.
|
|
*
|
|
* \return \ref RwBool, TRUE if successful.
|
|
*/
|
|
typedef RwBool (*RtAnimKeyFrameStreamWriteCallBack)
|
|
(const RtAnimAnimation *animation, RwStream *stream);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameStreamGetSizeCallBack
|
|
* defines a callback function for calculating the binary stream
|
|
* size of keyframe data within an animation.
|
|
*
|
|
* \param animation Pointer to the \ref RtAnimAnimation to calculate sizes from.
|
|
*
|
|
* \return \ref RwInt32 containing the size, in bytes, of the keyframe data.
|
|
*/
|
|
typedef RwInt32 (*RtAnimKeyFrameStreamGetSizeCallBack)
|
|
(const RtAnimAnimation *animation);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimInterpolatorInfo
|
|
* Typedef for struct \ref RtAnimInterpolatorInfo
|
|
*/
|
|
typedef struct RtAnimInterpolatorInfo RtAnimInterpolatorInfo;
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \struct RtAnimInterpolatorInfo
|
|
* This structure is used to hold information for a keyframe interpolation scheme.
|
|
*
|
|
* \see RtAnimRegisterInterpolationScheme
|
|
* \see RtAnimGetInterpolatorInfo
|
|
*/
|
|
struct RtAnimInterpolatorInfo
|
|
{
|
|
RwInt32 typeID;
|
|
/**< The ID of the interpolation scheme. */
|
|
RwInt32 interpKeyFrameSize;
|
|
/**< Size, in bytes, of the interpolated keyframe structure. */
|
|
RwInt32 animKeyFrameSize;
|
|
/**< Size, in bytes, of the animation keyframe structure. */
|
|
RtAnimKeyFrameApplyCallBack keyFrameApplyCB;
|
|
/**< Pointer to a function that converts a keyframe to the needed
|
|
* format. This function is never called from the \ref rtanim
|
|
* toolkit (as the toolit doesn't know the data layout of the
|
|
* results) but is stored to ease the creation of overloaded
|
|
* interpolators. */
|
|
RtAnimKeyFrameBlendCallBack keyFrameBlendCB;
|
|
/**< Pointer to a function that blends between two
|
|
* interpolated keyframes, for the purpose of blending
|
|
* between the states of two \ref RtAnimInterpolator objects. */
|
|
RtAnimKeyFrameInterpolateCallBack keyFrameInterpolateCB;
|
|
/**< Pointer to a function that interpolates between two keyframes
|
|
* for a given time in between. */
|
|
RtAnimKeyFrameAddCallBack keyFrameAddCB;
|
|
/**< Pointer to a function that adds two interpolated keyframes
|
|
* for the purpose of adding the states of two
|
|
* \ref RtAnimInterpolator objects. */
|
|
RtAnimKeyFrameMulRecipCallBack keyFrameMulRecipCB;
|
|
/**< Pointer to a function that multiplies a keyframe by the
|
|
* reciprocal of another. */
|
|
RtAnimKeyFrameStreamReadCallBack keyFrameStreamReadCB;
|
|
/**< Pointer to a function that reads the keyframes from a stream
|
|
* for a given animation. */
|
|
RtAnimKeyFrameStreamWriteCallBack keyFrameStreamWriteCB;
|
|
/**< Pointer to a function that writes the keyframes to a stream for
|
|
* a given animation. */
|
|
RtAnimKeyFrameStreamGetSizeCallBack keyFrameStreamGetSizeCB;
|
|
/**< Pointer to a function that returns the binary stream size of
|
|
* the keyframes for a given animation. */
|
|
RwInt32 customDataSize;
|
|
/**< Amount of custom data required per animation. */
|
|
};
|
|
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \struct RtAnimAnimation
|
|
* A keyframed 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. That is, the next keyframe
|
|
* at some point in the sequence should correspond to the node whose
|
|
* previous two keyframes are next to expire as an interpolation
|
|
* pair.
|
|
*
|
|
* Put another way, the correct ordering can be achieved by sorting
|
|
* an unordered keyframe array using the following primary and secondary
|
|
* sort keys:
|
|
*
|
|
* - time of previous keyframe for node
|
|
* - node index
|
|
*
|
|
* An example is shown in the following diagram, where each vertical bar
|
|
* indicates a keyframe point in time. The position of the keyframe
|
|
* within the animation sequence is shown by an index to the left of
|
|
* each bar.
|
|
*
|
|
* \verbatim
|
|
|
|
t=0 t=duration
|
|
node 0 kf0..| kf3.......| kf8....| kf10....|
|
|
node 1 kf1..| kf4...| kf6........| kf11....|
|
|
node 2 kf2..| kf5.....| kf7..| kf9.........|
|
|
|
|
\endverbatim
|
|
*
|
|
* Each node MUST have an initial keyframe at time = 0.0, and a terminal
|
|
* keyframe at time = duration of the animation.
|
|
*
|
|
* Pointers link all of the keyframes for a particular node backwards
|
|
* through time in a list.
|
|
*
|
|
* \see RtAnimAnimationCreate
|
|
*/
|
|
struct RtAnimAnimation
|
|
{
|
|
RtAnimInterpolatorInfo *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 */
|
|
void *customData;
|
|
/**< Pointer to custom data for this animation */
|
|
};
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimKeyFrameHeader
|
|
* Typedef for struct RtAnimKeyFrameHeader
|
|
*/
|
|
typedef struct RtAnimKeyFrameHeader RtAnimKeyFrameHeader;
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \struct RtAnimKeyFrameHeader
|
|
* holds header information for a keyframe. All keyframe structures used with
|
|
* the overloadable interpolation system should start with this data.
|
|
*
|
|
* \see RtAnimRegisterInterpolationScheme
|
|
*/
|
|
struct RtAnimKeyFrameHeader
|
|
{
|
|
void *prevFrame;
|
|
/**< Previous keyframe for particular hierarchy node */
|
|
RwReal time;
|
|
/**< Time at keyframe */
|
|
};
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimInterpFrameHeader
|
|
* Typedef for struct RtAnimInterpFrameHeader
|
|
*/
|
|
typedef struct RtAnimInterpFrameHeader RtAnimInterpFrameHeader;
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \struct RtAnimInterpFrameHeader
|
|
* is the header for an interpolated animation frame, intermediate
|
|
* between a keyframe pair. This structure is intentionally the same size as an
|
|
* \ref RtAnimKeyFrameHeader, so that an interpolated frame and key frame data
|
|
* block can be otherwise identical. It relies on the
|
|
* fact that the prevFrame and time fields of a keyframe header are not
|
|
* relevant to an interpolated frame. These fields should therefore not be
|
|
* be modified by a custom keyframe interpolator.
|
|
*
|
|
* \see RtAnimRegisterInterpolationScheme
|
|
*/
|
|
struct RtAnimInterpFrameHeader
|
|
{
|
|
RtAnimKeyFrameHeader *keyFrame1;
|
|
/**< Pointer to the first of the current pair of keyframes in
|
|
the associated \ref RtAnimAnimation */
|
|
RtAnimKeyFrameHeader *keyFrame2;
|
|
/**< Pointer to the second of the current pair of keyframes in
|
|
the associated \ref RtAnimAnimation */
|
|
};
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimInterpolator
|
|
* Typedef for struct \ref RtAnimInterpolator
|
|
*/
|
|
typedef struct RtAnimInterpolator RtAnimInterpolator;
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \ref RtAnimCallBack
|
|
* defines a callback function for use with the
|
|
* \ref RtAnimInterpolatorSetAnimCallBack and
|
|
* \ref RtAnimInterpolatorSetAnimLoopCallBack functions.
|
|
*
|
|
* \param animInstance
|
|
* A pointer to the \ref RtAnimInterpolator structure.
|
|
*
|
|
* \param data Void pointer for user-defined data.
|
|
* You can use this to pass your own data
|
|
* structure(s) to the callback function.
|
|
*
|
|
* \see RtAnimInterpolatorSetAnimCallBack
|
|
* \see RtAnimInterpolatorSetAnimLoopCallBack
|
|
*
|
|
*/
|
|
|
|
typedef RtAnimInterpolator * (*RtAnimCallBack)
|
|
(RtAnimInterpolator *animInstance,
|
|
void *data);
|
|
|
|
/**
|
|
* \ingroup rtanim
|
|
* \struct RtAnimInterpolator
|
|
* holds the current state for a particular instance of an animation,
|
|
* corresponding to a specific point in time.
|
|
*
|
|
* The current interpolated keyframes are stored in an array after the
|
|
* end of this structure. For advanced use, these may be accessed
|
|
* using the macro rtANIMGETINTERPFRAME(interpolator, nodeIndex)
|
|
* which takes a pointer to the interpolator and the node index
|
|
* for the interpolated keyframe required.
|
|
*
|
|
* \see \ref RtAnimInterpolatorCreate
|
|
* \see \ref RtAnimInterpolatorDestroy
|
|
* \see \ref RtAnimInterpolatorSetCurrentAnim
|
|
* \see \ref RtAnimInterpolatorGetCurrentAnim
|
|
* \see \ref RtAnimInterpolatorSetKeyFrameCallBacks
|
|
* \see \ref RtAnimInterpolatorSetAnimLoopCallBack
|
|
* \see \ref RtAnimInterpolatorSetAnimCallBack
|
|
* \see \ref RtAnimInterpolatorCopy
|
|
* \see \ref RtAnimInterpolatorSubAnimTime
|
|
* \see \ref RtAnimInterpolatorAddAnimTime
|
|
* \see \ref RtAnimInterpolatorSetCurrentTime
|
|
* \see \ref RtAnimCallBack
|
|
*/
|
|
struct RtAnimInterpolator
|
|
{
|
|
RtAnimAnimation *pCurrentAnim;
|
|
/**< Current \ref RtAnimAnimation applied */
|
|
RwReal currentTime;
|
|
/**< Current animation time */
|
|
void *pNextFrame;
|
|
/**< Next animation keyframe to be played */
|
|
RtAnimCallBack pAnimCallBack;
|
|
/**< Animation callback function pointer */
|
|
void *pAnimCallBackData;
|
|
/**< Animation callback function user data */
|
|
RwReal animCallBackTime;
|
|
/**< Trigger time for callback function */
|
|
RtAnimCallBack pAnimLoopCallBack;
|
|
/**< Animation loop callback function pointer */
|
|
void *pAnimLoopCallBackData;
|
|
/**< Animation loop callback function data */
|
|
RwInt32 maxInterpKeyFrameSize;
|
|
/**< Maximum size of interpolated keyframes
|
|
* usable on this animation (set at creation
|
|
* time) */
|
|
RwInt32 currentInterpKeyFrameSize;
|
|
/**< Size of interpolated keyframes in the current
|
|
* animation scheme */
|
|
RwInt32 currentAnimKeyFrameSize;
|
|
/**< Size of animation keyframes in the current
|
|
* animation scheme */
|
|
RwInt32 numNodes;
|
|
/**< Number of nodes driven by the animation */
|
|
RwBool isSubInterpolator;
|
|
/**< Internal use */
|
|
RwInt32 offsetInParent;
|
|
/**< Internal use */
|
|
RtAnimInterpolator *parentAnimation;
|
|
/**< Internal use */
|
|
|
|
RtAnimKeyFrameApplyCallBack keyFrameApplyCB;
|
|
/**< Internal use */
|
|
RtAnimKeyFrameBlendCallBack keyFrameBlendCB;
|
|
/**< Internal use */
|
|
RtAnimKeyFrameInterpolateCallBack keyFrameInterpolateCB;
|
|
/**< Internal use */
|
|
RtAnimKeyFrameAddCallBack keyFrameAddCB;
|
|
/**< Internal use */
|
|
};
|
|
|
|
/* Access to array of interpolated frames occupying a block of memory
|
|
* after the end of the RtAnimInterpolator structure.
|
|
*/
|
|
#define rtANIMGETINTERPFRAME( anim, nodeIndex ) \
|
|
( (void *)( ( (RwUInt8 *)&(anim[1]) + \
|
|
((nodeIndex) * \
|
|
anim->currentInterpKeyFrameSize) ) ) )
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
{
|
|
#endif /* __cplusplus */
|
|
|
|
|
|
/* Engine functions */
|
|
extern void
|
|
RtAnimAnimationFreeListCreateParams( RwInt32 blockSize, RwInt32 numBlocksToPrealloc );
|
|
|
|
extern RwBool
|
|
RtAnimInitialize(void);
|
|
|
|
extern RwBool
|
|
RtAnimRegisterInterpolationScheme(RtAnimInterpolatorInfo *interpolatorInfo);
|
|
|
|
extern RtAnimInterpolatorInfo *
|
|
RtAnimGetInterpolatorInfo(RwInt32 typeID);
|
|
|
|
/* RtAnimAnimation */
|
|
extern RtAnimAnimation *
|
|
RtAnimAnimationCreate(RwInt32 typeID,
|
|
RwInt32 numFrames,
|
|
RwInt32 flags,
|
|
RwReal duration);
|
|
|
|
extern RwBool
|
|
RtAnimAnimationDestroy(RtAnimAnimation *animation);
|
|
|
|
extern RtAnimAnimation *
|
|
RtAnimAnimationRead(const RwChar * filename);
|
|
|
|
extern RwBool
|
|
RtAnimAnimationWrite(const RtAnimAnimation *animation,
|
|
const RwChar * filename);
|
|
|
|
extern RtAnimAnimation *
|
|
RtAnimAnimationStreamRead(RwStream *stream);
|
|
|
|
extern RwBool
|
|
RtAnimAnimationStreamWrite(const RtAnimAnimation *animation,
|
|
RwStream *stream);
|
|
|
|
extern RwInt32
|
|
RtAnimAnimationStreamGetSize(const RtAnimAnimation *animation);
|
|
|
|
extern RwUInt32
|
|
RtAnimAnimationGetNumNodes(const RtAnimAnimation *animation);
|
|
|
|
#ifdef RWDEBUG
|
|
|
|
extern RwInt32
|
|
RtAnimAnimationGetTypeID(RtAnimAnimation *animation);
|
|
|
|
#else /* RWDEBUG */
|
|
|
|
#define RtAnimAnimationGetTypeID(animation) \
|
|
(animation->interpInfo->typeID)
|
|
|
|
#endif /* RWDEBUG */
|
|
|
|
/* RtAnimInterpolator */
|
|
extern RtAnimInterpolator *
|
|
RtAnimInterpolatorCreate(RwInt32 numNodes,
|
|
RwInt32 maxInterpKeyFrameSize);
|
|
|
|
extern void
|
|
RtAnimInterpolatorDestroy(RtAnimInterpolator *anim);
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorSetCurrentAnim(RtAnimInterpolator *animI,
|
|
RtAnimAnimation *anim);
|
|
|
|
|
|
#ifdef RWDEBUG
|
|
|
|
extern RtAnimAnimation *
|
|
RtAnimInterpolatorGetCurrentAnim(RtAnimInterpolator *animI);
|
|
|
|
#else /* RWDEBUG */
|
|
|
|
#define RtAnimInterpolatorGetCurrentAnim(animI) \
|
|
((animI)->pCurrentAnim)
|
|
|
|
#endif /* RWDEBUG */
|
|
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorSetKeyFrameCallBacks(RtAnimInterpolator *anim,
|
|
RwInt32 keyFrameTypeID);
|
|
|
|
|
|
extern void
|
|
RtAnimInterpolatorSetAnimLoopCallBack(RtAnimInterpolator *anim,
|
|
RtAnimCallBack callBack,
|
|
void *data );
|
|
|
|
extern void
|
|
RtAnimInterpolatorSetAnimCallBack(RtAnimInterpolator *anim,
|
|
RtAnimCallBack callBack,
|
|
RwReal time,
|
|
void *data );
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorCopy(RtAnimInterpolator *outAnim,
|
|
RtAnimInterpolator *inAnim);
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorSubAnimTime(RtAnimInterpolator *anim,
|
|
RwReal time);
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorAddAnimTime(RtAnimInterpolator *anim,
|
|
RwReal time);
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorSetCurrentTime(RtAnimInterpolator *anim,
|
|
RwReal time);
|
|
|
|
extern RwBool
|
|
RtAnimAnimationMakeDelta(RtAnimAnimation *animation,
|
|
RwInt32 numNodes,
|
|
RwReal time);
|
|
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorBlend(RtAnimInterpolator *outAnim,
|
|
RtAnimInterpolator *inAnim1,
|
|
RtAnimInterpolator *inAnim2,
|
|
RwReal alpha);
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorAddTogether(RtAnimInterpolator *outAnim,
|
|
RtAnimInterpolator *inAnim1,
|
|
RtAnimInterpolator *inAnim2);
|
|
|
|
#define RtAnimKeyFrameApplyMacro(anim, out, in) \
|
|
MACRO_START \
|
|
{ \
|
|
(anim)->keyFrameApplyCB((out), (in)); \
|
|
} \
|
|
MACRO_STOP
|
|
|
|
|
|
#define RtAnimKeyFrameInterpolateMacro(anim, out, in1, in2, time) \
|
|
MACRO_START \
|
|
{ \
|
|
(anim)->keyFrameInterpolateCB((out), (in1), (in2), (time), (anim->pCurrentAnim->customData)); \
|
|
} \
|
|
MACRO_STOP
|
|
|
|
#define RtAnimKeyFrameBlendMacro(anim, out, in1, in2, fAlpha) \
|
|
MACRO_START \
|
|
{ \
|
|
(anim)->keyFrameBlendCB((out), (in1), (in2), (fAlpha)); \
|
|
} \
|
|
MACRO_STOP
|
|
|
|
#define RtAnimKeyFrameAddTogetherMacro(anim, out, in1, in2) \
|
|
MACRO_START \
|
|
{ \
|
|
(anim)->keyFrameAddCB((out), (in1), (in2)); \
|
|
} \
|
|
MACRO_STOP
|
|
|
|
|
|
|
|
#ifdef RWDEBUG
|
|
extern void
|
|
RtAnimKeyFrameApply(RtAnimInterpolator *animation,
|
|
void *result, void *iFrame);
|
|
|
|
extern void
|
|
RtAnimKeyFrameInterpolate(RtAnimInterpolator *animation,
|
|
void *out, void *in1,
|
|
void *in2, RwReal time);
|
|
|
|
extern void
|
|
RtAnimKeyFrameBlend(RtAnimInterpolator *animation,
|
|
void *out,
|
|
void *in1,
|
|
void *in2,
|
|
RwReal alpha);
|
|
|
|
extern void
|
|
RtAnimKeyFrameAddTogether(RtAnimInterpolator *animation,
|
|
void *out, void *in1, void *in2);
|
|
|
|
#else /* RWDEBUG */
|
|
#define RtAnimKeyFrameApply(animation, out, in) \
|
|
RtAnimKeyFrameApplyMacro(animation, out, in)
|
|
|
|
#define RtAnimKeyFrameInterpolate(animation, out, in1, in2, time) \
|
|
RtAnimKeyFrameInterpolateMacro(animation, out, in1, in2, time)
|
|
|
|
#define RtAnimKeyFrameBlend(animation, out, in1, in2, alpha) \
|
|
RtAnimKeyFrameBlendMacro(animation, out, in1, in2, alpha)
|
|
|
|
#define RtAnimKeyFrameAddTogether(animation, out, in1, in2) \
|
|
RtAnimKeyFrameAddTogetherMacro(animation, out, in1, in2)
|
|
|
|
#endif /* RWDEBUG */
|
|
|
|
extern RtAnimInterpolator *
|
|
RtAnimInterpolatorCreateSubInterpolator(
|
|
RtAnimInterpolator *parentAnim,
|
|
RwInt32 startNode,
|
|
RwInt32 numNodes,
|
|
RwInt32 maxInterpKeyFrameSize);
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorBlendSubInterpolator(RtAnimInterpolator *outAnim,
|
|
RtAnimInterpolator *inAnim1,
|
|
RtAnimInterpolator *inAnim2,
|
|
RwReal alpha);
|
|
|
|
extern RwBool
|
|
RtAnimInterpolatorAddSubInterpolator(RtAnimInterpolator *outAnim,
|
|
RtAnimInterpolator *mainAnim,
|
|
RtAnimInterpolator *subAnim);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* RTANIM_H */
|