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 */