d3dx9anim.h

Go to the documentation of this file.

/*
 *
 * Copyright (C) Microsoft Corporation. All Rights Reserved.
 *
 * File: d3dx9anim.h
 * Content: D3DX mesh types and functions
 */

#ifndef __D3DX9ANIM_H__
#define __D3DX9ANIM_H__

/* {698CFB3F-9289-4d95-9A57-33A94B5A65F9} */
DEFINE_GUID(IID_ID3DXAnimationSet,
0x698cfb3f, 0x9289, 0x4d95, 0x9a, 0x57, 0x33, 0xa9, 0x4b, 0x5a, 0x65, 0xf9);

/* {FA4E8E3A-9786-407d-8B4C-5995893764AF} */
DEFINE_GUID(IID_ID3DXKeyframedAnimationSet,
0xfa4e8e3a, 0x9786, 0x407d, 0x8b, 0x4c, 0x59, 0x95, 0x89, 0x37, 0x64, 0xaf);

/* {6CC2480D-3808-4739-9F88-DE49FACD8D4C} */
DEFINE_GUID(IID_ID3DXCompressedAnimationSet,
0x6cc2480d, 0x3808, 0x4739, 0x9f, 0x88, 0xde, 0x49, 0xfa, 0xcd, 0x8d, 0x4c);

/* {AC8948EC-F86D-43e2-96DE-31FC35F96D9E} */
DEFINE_GUID(IID_ID3DXAnimationController,
0xac8948ec, 0xf86d, 0x43e2, 0x96, 0xde, 0x31, 0xfc, 0x35, 0xf9, 0x6d, 0x9e);

typedef enum _D3DXMESHDATATYPE
{
 D3DXMESHTYPE_MESH = 0x001, /* Normal ID3DXMesh data */
 D3DXMESHTYPE_PMESH = 0x002, /* Progressive Mesh - ID3DXPMesh */
 D3DXMESHTYPE_PATCHMESH = 0x003, /* Patch Mesh - ID3DXPatchMesh */

 D3DXMESHTYPE_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} D3DXMESHDATATYPE;

typedef struct _D3DXMESHDATA
{
 D3DXMESHDATATYPE Type;

 /* current mesh data interface */
 union
 {
 LPD3DXMESH pMesh;
 LPD3DXPMESH pPMesh;
 LPD3DXPATCHMESH pPatchMesh;
 };
} D3DXMESHDATA, *LPD3DXMESHDATA;

typedef struct _D3DXMESHCONTAINER
{
 LPSTR Name;

 D3DXMESHDATA MeshData;

 LPD3DXMATERIAL pMaterials;
 LPD3DXEFFECTINSTANCE pEffects;
 DWORD NumMaterials;
 DWORD *pAdjacency;

 LPD3DXSKININFO pSkinInfo;

 struct _D3DXMESHCONTAINER *pNextMeshContainer;
} D3DXMESHCONTAINER, *LPD3DXMESHCONTAINER;

typedef struct _D3DXFRAME
{
 LPSTR Name;
 D3DXMATRIX TransformationMatrix;

 LPD3DXMESHCONTAINER pMeshContainer;

 struct _D3DXFRAME *pFrameSibling;
 struct _D3DXFRAME *pFrameFirstChild;
} D3DXFRAME, *LPD3DXFRAME;

typedef interface ID3DXAllocateHierarchy ID3DXAllocateHierarchy;
typedef interface ID3DXAllocateHierarchy *LPD3DXALLOCATEHIERARCHY;

#undef INTERFACE
#define INTERFACE ID3DXAllocateHierarchy

DECLARE_INTERFACE(ID3DXAllocateHierarchy)
{
 STDMETHOD(CreateFrame)(THIS_ LPCSTR Name,
 LPD3DXFRAME *ppNewFrame) PURE;

 STDMETHOD(CreateMeshContainer)(THIS_
 LPCSTR Name,
 CONST D3DXMESHDATA *pMeshData,
 CONST D3DXMATERIAL *pMaterials,
 CONST D3DXEFFECTINSTANCE *pEffectInstances,
 DWORD NumMaterials,
 CONST DWORD *pAdjacency,
 LPD3DXSKININFO pSkinInfo,
 LPD3DXMESHCONTAINER *ppNewMeshContainer) PURE;

 STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME pFrameToFree) PURE;

 STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER pMeshContainerToFree) PURE;
};

typedef interface ID3DXLoadUserData ID3DXLoadUserData;
typedef interface ID3DXLoadUserData *LPD3DXLOADUSERDATA;

#undef INTERFACE
#define INTERFACE ID3DXLoadUserData

DECLARE_INTERFACE(ID3DXLoadUserData)
{
 STDMETHOD(LoadTopLevelData)(LPD3DXFILEDATA pXofChildData) PURE;

 STDMETHOD(LoadFrameChildData)(LPD3DXFRAME pFrame,
 LPD3DXFILEDATA pXofChildData) PURE;

 STDMETHOD(LoadMeshChildData)(LPD3DXMESHCONTAINER pMeshContainer,
 LPD3DXFILEDATA pXofChildData) PURE;
};

typedef interface ID3DXSaveUserData ID3DXSaveUserData;
typedef interface ID3DXSaveUserData *LPD3DXSAVEUSERDATA;

#undef INTERFACE
#define INTERFACE ID3DXSaveUserData

DECLARE_INTERFACE(ID3DXSaveUserData)
{
 STDMETHOD(AddFrameChildData)(CONST D3DXFRAME *pFrame,
 LPD3DXFILESAVEOBJECT pXofSave,
 LPD3DXFILESAVEDATA pXofFrameData) PURE;

 STDMETHOD(AddMeshChildData)(CONST D3DXMESHCONTAINER *pMeshContainer,
 LPD3DXFILESAVEOBJECT pXofSave,
 LPD3DXFILESAVEDATA pXofMeshData) PURE;

 /* NOTE: this is called once per Save. All top level objects should be added using the
 * provided interface. One call adds objects before the frame hierarchy, the other after */
 STDMETHOD(AddTopLevelDataObjectsPre)(LPD3DXFILESAVEOBJECT pXofSave) PURE;
 STDMETHOD(AddTopLevelDataObjectsPost)(LPD3DXFILESAVEOBJECT pXofSave) PURE;

 /* callbacks for the user to register and then save templates to the XFile */
 STDMETHOD(RegisterTemplates)(LPD3DXFILE pXFileApi) PURE;
 STDMETHOD(SaveTemplates)(LPD3DXFILESAVEOBJECT pXofSave) PURE;
};

typedef enum _D3DXCALLBACK_SEARCH_FLAGS
{
 D3DXCALLBACK_SEARCH_EXCLUDING_INITIAL_POSITION = 0x01, /* exclude callbacks at the initial position from the search */
 D3DXCALLBACK_SEARCH_BEHIND_INITIAL_POSITION = 0x02, /* reverse the callback search direction */

 D3DXCALLBACK_SEARCH_FORCE_DWORD = 0x7fffffff
} D3DXCALLBACK_SEARCH_FLAGS;

typedef interface ID3DXAnimationSet ID3DXAnimationSet;
typedef interface ID3DXAnimationSet *LPD3DXANIMATIONSET;

#undef INTERFACE
#define INTERFACE ID3DXAnimationSet

DECLARE_INTERFACE_(ID3DXAnimationSet, IUnknown)
{
 /* IUnknown */
 STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
 STDMETHOD_(ULONG, AddRef)(THIS) PURE;
 STDMETHOD_(ULONG, Release)(THIS) PURE;

 /* Name */
 STDMETHOD_(LPCSTR, GetName)(THIS) PURE;

 /* Period */
 STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE;
 STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE Position) PURE; /* Maps position into animation period */

 /* Animation names */
 STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE;
 STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT Index, LPCSTR *ppName) PURE;
 STDMETHOD(GetAnimationIndexByName)(THIS_ LPCSTR pName, UINT *pIndex) PURE;

 /* SRT */
 STDMETHOD(GetSRT)(THIS_
 DOUBLE PeriodicPosition, /* Position mapped to period (use GetPeriodicPosition) */
 UINT Animation, /* Animation index */
 D3DXVECTOR3 *pScale, /* Returns the scale */
 D3DXQUATERNION *pRotation, /* Returns the rotation as a quaternion */
 D3DXVECTOR3 *pTranslation) PURE; /* Returns the translation */

 /* Callbacks */
 STDMETHOD(GetCallback)(THIS_
 DOUBLE Position, /* Position from which to find callbacks */
 DWORD Flags, /* Callback search flags */
 DOUBLE *pCallbackPosition, /* Returns the position of the callback */
 LPVOID *ppCallbackData) PURE; /* Returns the callback data pointer */
};

typedef enum _D3DXPLAYBACK_TYPE
{
 D3DXPLAY_LOOP = 0,
 D3DXPLAY_ONCE = 1,
 D3DXPLAY_PINGPONG = 2,

 D3DXPLAY_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} D3DXPLAYBACK_TYPE;

typedef struct _D3DXKEY_VECTOR3
{
 FLOAT Time;
 D3DXVECTOR3 Value;
} D3DXKEY_VECTOR3, *LPD3DXKEY_VECTOR3;

typedef struct _D3DXKEY_QUATERNION
{
 FLOAT Time;
 D3DXQUATERNION Value;
} D3DXKEY_QUATERNION, *LPD3DXKEY_QUATERNION;

typedef struct _D3DXKEY_CALLBACK
{
 FLOAT Time;
 LPVOID pCallbackData;
} D3DXKEY_CALLBACK, *LPD3DXKEY_CALLBACK;

typedef enum _D3DXCOMPRESSION_FLAGS
{
 D3DXCOMPRESS_DEFAULT = 0x00,

 D3DXCOMPRESS_FORCE_DWORD = 0x7fffffff
} D3DXCOMPRESSION_FLAGS;

typedef interface ID3DXKeyframedAnimationSet ID3DXKeyframedAnimationSet;
typedef interface ID3DXKeyframedAnimationSet *LPD3DXKEYFRAMEDANIMATIONSET;

#undef INTERFACE
#define INTERFACE ID3DXKeyframedAnimationSet

DECLARE_INTERFACE_(ID3DXKeyframedAnimationSet, ID3DXAnimationSet)
{
 /* ID3DXAnimationSet */
 STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
 STDMETHOD_(ULONG, AddRef)(THIS) PURE;
 STDMETHOD_(ULONG, Release)(THIS) PURE;

 /* Name */
 STDMETHOD_(LPCSTR, GetName)(THIS) PURE;

 /* Period */
 STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE;
 STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE Position) PURE; /* Maps position into animation period */

 /* Animation names */
 STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE;
 STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT Index, LPCSTR *ppName) PURE;
 STDMETHOD(GetAnimationIndexByName)(THIS_ LPCSTR pName, UINT *pIndex) PURE;

 /* SRT */
 STDMETHOD(GetSRT)(THIS_
 DOUBLE PeriodicPosition, /* Position mapped to period (use GetPeriodicPosition) */
 UINT Animation, /* Animation index */
 D3DXVECTOR3 *pScale, /* Returns the scale */
 D3DXQUATERNION *pRotation, /* Returns the rotation as a quaternion */
 D3DXVECTOR3 *pTranslation) PURE; /* Returns the translation */

 /* Callbacks */
 STDMETHOD(GetCallback)(THIS_
 DOUBLE Position, /* Position from which to find callbacks */
 DWORD Flags, /* Callback search flags */
 DOUBLE *pCallbackPosition, /* Returns the position of the callback */
 LPVOID *ppCallbackData) PURE; /* Returns the callback data pointer */

 /* Playback */
 STDMETHOD_(D3DXPLAYBACK_TYPE, GetPlaybackType)(THIS) PURE;
 STDMETHOD_(DOUBLE, GetSourceTicksPerSecond)(THIS) PURE;

 /* Scale keys */
 STDMETHOD_(UINT, GetNumScaleKeys)(THIS_ UINT Animation) PURE;
 STDMETHOD(GetScaleKeys)(THIS_ UINT Animation, LPD3DXKEY_VECTOR3 pScaleKeys) PURE;
 STDMETHOD(GetScaleKey)(THIS_ UINT Animation, UINT Key, LPD3DXKEY_VECTOR3 pScaleKey) PURE;
 STDMETHOD(SetScaleKey)(THIS_ UINT Animation, UINT Key, LPD3DXKEY_VECTOR3 pScaleKey) PURE;

 /* Rotation keys */
 STDMETHOD_(UINT, GetNumRotationKeys)(THIS_ UINT Animation) PURE;
 STDMETHOD(GetRotationKeys)(THIS_ UINT Animation, LPD3DXKEY_QUATERNION pRotationKeys) PURE;
 STDMETHOD(GetRotationKey)(THIS_ UINT Animation, UINT Key, LPD3DXKEY_QUATERNION pRotationKey) PURE;
 STDMETHOD(SetRotationKey)(THIS_ UINT Animation, UINT Key, LPD3DXKEY_QUATERNION pRotationKey) PURE;

 /* Translation keys */
 STDMETHOD_(UINT, GetNumTranslationKeys)(THIS_ UINT Animation) PURE;
 STDMETHOD(GetTranslationKeys)(THIS_ UINT Animation, LPD3DXKEY_VECTOR3 pTranslationKeys) PURE;
 STDMETHOD(GetTranslationKey)(THIS_ UINT Animation, UINT Key, LPD3DXKEY_VECTOR3 pTranslationKey) PURE;
 STDMETHOD(SetTranslationKey)(THIS_ UINT Animation, UINT Key, LPD3DXKEY_VECTOR3 pTranslationKey) PURE;

 /* Callback keys */
 STDMETHOD_(UINT, GetNumCallbackKeys)(THIS) PURE;
 STDMETHOD(GetCallbackKeys)(THIS_ LPD3DXKEY_CALLBACK pCallbackKeys) PURE;
 STDMETHOD(GetCallbackKey)(THIS_ UINT Key, LPD3DXKEY_CALLBACK pCallbackKey) PURE;
 STDMETHOD(SetCallbackKey)(THIS_ UINT Key, LPD3DXKEY_CALLBACK pCallbackKey) PURE;

 /* Key removal methods. These are slow, and should not be used once the animation starts playing */
 STDMETHOD(UnregisterScaleKey)(THIS_ UINT Animation, UINT Key) PURE;
 STDMETHOD(UnregisterRotationKey)(THIS_ UINT Animation, UINT Key) PURE;
 STDMETHOD(UnregisterTranslationKey)(THIS_ UINT Animation, UINT Key) PURE;

 /* One-time animaton SRT keyframe registration */
 STDMETHOD(RegisterAnimationSRTKeys)(THIS_
 LPCSTR pName, /* Animation name */
 UINT NumScaleKeys, /* Number of scale keys */
 UINT NumRotationKeys, /* Number of rotation keys */
 UINT NumTranslationKeys, /* Number of translation keys */
 CONST D3DXKEY_VECTOR3 *pScaleKeys, /* Array of scale keys */
 CONST D3DXKEY_QUATERNION *pRotationKeys, /* Array of rotation keys */
 CONST D3DXKEY_VECTOR3 *pTranslationKeys, /* Array of translation keys */
 DWORD *pAnimationIndex) PURE; /* Returns the animation index */

 /* Compression */
 STDMETHOD(Compress)(THIS_
 DWORD Flags, /* Compression flags (use D3DXCOMPRESS_STRONG for better results) */
 FLOAT Lossiness, /* Compression loss ratio in the [0, 1] range */
 LPD3DXFRAME pHierarchy, /* Frame hierarchy (optional) */
 LPD3DXBUFFER *ppCompressedData) PURE; /* Returns the compressed animation set */

 STDMETHOD(UnregisterAnimation)(THIS_ UINT Index) PURE;
};


/*
 * ID3DXCompressedAnimationSet:
 * ----------------------------
 * This interface implements a compressed keyframed animation set.
 */
typedef interface ID3DXCompressedAnimationSet ID3DXCompressedAnimationSet;
typedef interface ID3DXCompressedAnimationSet *LPD3DXCOMPRESSEDANIMATIONSET;

#undef INTERFACE
#define INTERFACE ID3DXCompressedAnimationSet

DECLARE_INTERFACE_(ID3DXCompressedAnimationSet, ID3DXAnimationSet)
{
 /* ID3DXAnimationSet */
 STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
 STDMETHOD_(ULONG, AddRef)(THIS) PURE;
 STDMETHOD_(ULONG, Release)(THIS) PURE;

 /* Name */
 STDMETHOD_(LPCSTR, GetName)(THIS) PURE;

 /* Period */
 STDMETHOD_(DOUBLE, GetPeriod)(THIS) PURE;
 STDMETHOD_(DOUBLE, GetPeriodicPosition)(THIS_ DOUBLE Position) PURE; /* Maps position into animation period */

 /* Animation names */
 STDMETHOD_(UINT, GetNumAnimations)(THIS) PURE;
 STDMETHOD(GetAnimationNameByIndex)(THIS_ UINT Index, LPCSTR *ppName) PURE;
 STDMETHOD(GetAnimationIndexByName)(THIS_ LPCSTR pName, UINT *pIndex) PURE;

 /* SRT */
 STDMETHOD(GetSRT)(THIS_
 DOUBLE PeriodicPosition, /* Position mapped to period (use GetPeriodicPosition) */
 UINT Animation, /* Animation index */
 D3DXVECTOR3 *pScale, /* Returns the scale */
 D3DXQUATERNION *pRotation, /* Returns the rotation as a quaternion */
 D3DXVECTOR3 *pTranslation) PURE; /* Returns the translation */

 /* Callbacks */
 STDMETHOD(GetCallback)(THIS_
 DOUBLE Position, /* Position from which to find callbacks */
 DWORD Flags, /* Callback search flags */
 DOUBLE *pCallbackPosition, /* Returns the position of the callback */
 LPVOID *ppCallbackData) PURE; /* Returns the callback data pointer */

 /* Playback */
 STDMETHOD_(D3DXPLAYBACK_TYPE, GetPlaybackType)(THIS) PURE;
 STDMETHOD_(DOUBLE, GetSourceTicksPerSecond)(THIS) PURE;

 /* Scale keys */
 STDMETHOD(GetCompressedData)(THIS_ LPD3DXBUFFER *ppCompressedData) PURE;

 /* Callback keys */
 STDMETHOD_(UINT, GetNumCallbackKeys)(THIS) PURE;
 STDMETHOD(GetCallbackKeys)(THIS_ LPD3DXKEY_CALLBACK pCallbackKeys) PURE;
};

typedef enum _D3DXPRIORITY_TYPE
{
 D3DXPRIORITY_LOW = 0, /* This track should be blended with all low priority tracks before mixed with the high priority result */
 D3DXPRIORITY_HIGH = 1, /* This track should be blended with all high priority tracks before mixed with the low priority result */

 D3DXPRIORITY_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} D3DXPRIORITY_TYPE;

typedef struct _D3DXTRACK_DESC
{
 D3DXPRIORITY_TYPE Priority;
 FLOAT Weight;
 FLOAT Speed;
 DOUBLE Position;
 BOOL Enable;
} D3DXTRACK_DESC, *LPD3DXTRACK_DESC;

typedef enum _D3DXEVENT_TYPE
{
 D3DXEVENT_TRACKSPEED = 0,
 D3DXEVENT_TRACKWEIGHT = 1,
 D3DXEVENT_TRACKPOSITION = 2,
 D3DXEVENT_TRACKENABLE = 3,
 D3DXEVENT_PRIORITYBLEND = 4,

 D3DXEVENT_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} D3DXEVENT_TYPE;

typedef enum _D3DXTRANSITION_TYPE
{
 D3DXTRANSITION_LINEAR = 0x000, /* Linear transition from one value to the next */
 D3DXTRANSITION_EASEINEASEOUT = 0x001, /* Ease-In Ease-Out spline transition from one value to the next */

 D3DXTRANSITION_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} D3DXTRANSITION_TYPE;

typedef struct _D3DXEVENT_DESC
{
 D3DXEVENT_TYPE Type;
 UINT Track;
 DOUBLE StartTime;
 DOUBLE Duration;
 D3DXTRANSITION_TYPE Transition;
 union
 {
 FLOAT Weight;
 FLOAT Speed;
 DOUBLE Position;
 BOOL Enable;
 };
} D3DXEVENT_DESC, *LPD3DXEVENT_DESC;

typedef DWORD D3DXEVENTHANDLE;
typedef D3DXEVENTHANDLE *LPD3DXEVENTHANDLE;

typedef interface ID3DXAnimationCallbackHandler ID3DXAnimationCallbackHandler;
typedef interface ID3DXAnimationCallbackHandler *LPD3DXANIMATIONCALLBACKHANDLER;

#undef INTERFACE
#define INTERFACE ID3DXAnimationCallbackHandler

DECLARE_INTERFACE(ID3DXAnimationCallbackHandler)
{
 STDMETHOD(HandleCallback)(THIS_ UINT Track, LPVOID pCallbackData) PURE;
};

typedef interface ID3DXAnimationController ID3DXAnimationController;
typedef interface ID3DXAnimationController *LPD3DXANIMATIONCONTROLLER;

#undef INTERFACE
#define INTERFACE ID3DXAnimationController

DECLARE_INTERFACE_(ID3DXAnimationController, IUnknown)
{
 /* IUnknown */
 STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
 STDMETHOD_(ULONG, AddRef)(THIS) PURE;
 STDMETHOD_(ULONG, Release)(THIS) PURE;

 /* Max sizes */
 STDMETHOD_(UINT, GetMaxNumAnimationOutputs)(THIS) PURE;
 STDMETHOD_(UINT, GetMaxNumAnimationSets)(THIS) PURE;
 STDMETHOD_(UINT, GetMaxNumTracks)(THIS) PURE;
 STDMETHOD_(UINT, GetMaxNumEvents)(THIS) PURE;

 /* Animation output registration */
 STDMETHOD(RegisterAnimationOutput)(THIS_
 LPCSTR pName,
 D3DXMATRIX *pMatrix,
 D3DXVECTOR3 *pScale,
 D3DXQUATERNION *pRotation,
 D3DXVECTOR3 *pTranslation) PURE;

 /* Animation set registration */
 STDMETHOD(RegisterAnimationSet)(THIS_ LPD3DXANIMATIONSET pAnimSet) PURE;
 STDMETHOD(UnregisterAnimationSet)(THIS_ LPD3DXANIMATIONSET pAnimSet) PURE;

 STDMETHOD_(UINT, GetNumAnimationSets)(THIS) PURE;
 STDMETHOD(GetAnimationSet)(THIS_ UINT Index, LPD3DXANIMATIONSET *ppAnimationSet) PURE;
 STDMETHOD(GetAnimationSetByName)(THIS_ LPCSTR szName, LPD3DXANIMATIONSET *ppAnimationSet) PURE;

 /* Global time */
 STDMETHOD(AdvanceTime)(THIS_ DOUBLE TimeDelta, LPD3DXANIMATIONCALLBACKHANDLER pCallbackHandler) PURE;
 STDMETHOD(ResetTime)(THIS) PURE;
 STDMETHOD_(DOUBLE, GetTime)(THIS) PURE;

 /* Tracks */
 STDMETHOD(SetTrackAnimationSet)(THIS_ UINT Track, LPD3DXANIMATIONSET pAnimSet) PURE;
 STDMETHOD(GetTrackAnimationSet)(THIS_ UINT Track, LPD3DXANIMATIONSET *ppAnimSet) PURE;

 STDMETHOD(SetTrackPriority)(THIS_ UINT Track, D3DXPRIORITY_TYPE Priority) PURE;

 STDMETHOD(SetTrackSpeed)(THIS_ UINT Track, FLOAT Speed) PURE;
 STDMETHOD(SetTrackWeight)(THIS_ UINT Track, FLOAT Weight) PURE;
 STDMETHOD(SetTrackPosition)(THIS_ UINT Track, DOUBLE Position) PURE;
 STDMETHOD(SetTrackEnable)(THIS_ UINT Track, BOOL Enable) PURE;

 STDMETHOD(SetTrackDesc)(THIS_ UINT Track, LPD3DXTRACK_DESC pDesc) PURE;
 STDMETHOD(GetTrackDesc)(THIS_ UINT Track, LPD3DXTRACK_DESC pDesc) PURE;

 /* Priority blending */
 STDMETHOD(SetPriorityBlend)(THIS_ FLOAT BlendWeight) PURE;
 STDMETHOD_(FLOAT, GetPriorityBlend)(THIS) PURE;

 /* Event keying */
 STDMETHOD_(D3DXEVENTHANDLE, KeyTrackSpeed)(THIS_ UINT Track, FLOAT NewSpeed, DOUBLE StartTime, DOUBLE Duration, D3DXTRANSITION_TYPE Transition) PURE;
 STDMETHOD_(D3DXEVENTHANDLE, KeyTrackWeight)(THIS_ UINT Track, FLOAT NewWeight, DOUBLE StartTime, DOUBLE Duration, D3DXTRANSITION_TYPE Transition) PURE;
 STDMETHOD_(D3DXEVENTHANDLE, KeyTrackPosition)(THIS_ UINT Track, DOUBLE NewPosition, DOUBLE StartTime) PURE;
 STDMETHOD_(D3DXEVENTHANDLE, KeyTrackEnable)(THIS_ UINT Track, BOOL NewEnable, DOUBLE StartTime) PURE;

 STDMETHOD_(D3DXEVENTHANDLE, KeyPriorityBlend)(THIS_ FLOAT NewBlendWeight, DOUBLE StartTime, DOUBLE Duration, D3DXTRANSITION_TYPE Transition) PURE;

 /* Event unkeying */
 STDMETHOD(UnkeyEvent)(THIS_ D3DXEVENTHANDLE hEvent) PURE;

 STDMETHOD(UnkeyAllTrackEvents)(THIS_ UINT Track) PURE;
 STDMETHOD(UnkeyAllPriorityBlends)(THIS) PURE;

 /* Event enumeration */
 STDMETHOD_(D3DXEVENTHANDLE, GetCurrentTrackEvent)(THIS_ UINT Track, D3DXEVENT_TYPE EventType) PURE;
 STDMETHOD_(D3DXEVENTHANDLE, GetCurrentPriorityBlend)(THIS) PURE;

 STDMETHOD_(D3DXEVENTHANDLE, GetUpcomingTrackEvent)(THIS_ UINT Track, D3DXEVENTHANDLE hEvent) PURE;
 STDMETHOD_(D3DXEVENTHANDLE, GetUpcomingPriorityBlend)(THIS_ D3DXEVENTHANDLE hEvent) PURE;

 STDMETHOD(ValidateEvent)(THIS_ D3DXEVENTHANDLE hEvent) PURE;

 STDMETHOD(GetEventDesc)(THIS_ D3DXEVENTHANDLE hEvent, LPD3DXEVENT_DESC pDesc) PURE;

 /* Cloning */
 STDMETHOD(CloneAnimationController)(THIS_
 UINT MaxNumAnimationOutputs,
 UINT MaxNumAnimationSets,
 UINT MaxNumTracks,
 UINT MaxNumEvents,
 LPD3DXANIMATIONCONTROLLER *ppAnimController) PURE;
};

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

HRESULT WINAPI
D3DXLoadMeshHierarchyFromXA
 (
 LPCSTR Filename,
 DWORD MeshOptions,
 LPDIRECT3DDEVICE9 pD3DDevice,
 LPD3DXALLOCATEHIERARCHY pAlloc,
 LPD3DXLOADUSERDATA pUserDataLoader,
 LPD3DXFRAME *ppFrameHierarchy,
 LPD3DXANIMATIONCONTROLLER *ppAnimController
 );

HRESULT WINAPI
D3DXLoadMeshHierarchyFromXW
 (
 LPCWSTR Filename,
 DWORD MeshOptions,
 LPDIRECT3DDEVICE9 pD3DDevice,
 LPD3DXALLOCATEHIERARCHY pAlloc,
 LPD3DXLOADUSERDATA pUserDataLoader,
 LPD3DXFRAME *ppFrameHierarchy,
 LPD3DXANIMATIONCONTROLLER *ppAnimController
 );

#ifdef UNICODE
#define D3DXLoadMeshHierarchyFromX D3DXLoadMeshHierarchyFromXW
#else
#define D3DXLoadMeshHierarchyFromX D3DXLoadMeshHierarchyFromXA
#endif

HRESULT WINAPI
D3DXLoadMeshHierarchyFromXInMemory
 (
 LPCVOID Memory,
 DWORD SizeOfMemory,
 DWORD MeshOptions,
 LPDIRECT3DDEVICE9 pD3DDevice,
 LPD3DXALLOCATEHIERARCHY pAlloc,
 LPD3DXLOADUSERDATA pUserDataLoader,
 LPD3DXFRAME *ppFrameHierarchy,
 LPD3DXANIMATIONCONTROLLER *ppAnimController
 );

HRESULT WINAPI
D3DXSaveMeshHierarchyToFileA
 (
 LPCSTR Filename,
 DWORD XFormat,
 CONST D3DXFRAME *pFrameRoot,
 LPD3DXANIMATIONCONTROLLER pAnimcontroller,
 LPD3DXSAVEUSERDATA pUserDataSaver
 );

HRESULT WINAPI
D3DXSaveMeshHierarchyToFileW
 (
 LPCWSTR Filename,
 DWORD XFormat,
 CONST D3DXFRAME *pFrameRoot,
 LPD3DXANIMATIONCONTROLLER pAnimController,
 LPD3DXSAVEUSERDATA pUserDataSaver
 );

#ifdef UNICODE
#define D3DXSaveMeshHierarchyToFile D3DXSaveMeshHierarchyToFileW
#else
#define D3DXSaveMeshHierarchyToFile D3DXSaveMeshHierarchyToFileA
#endif

HRESULT WINAPI
D3DXFrameDestroy
 (
 LPD3DXFRAME pFrameRoot,
 LPD3DXALLOCATEHIERARCHY pAlloc
 );

HRESULT WINAPI
D3DXFrameAppendChild
 (
 LPD3DXFRAME pFrameParent,
 CONST D3DXFRAME *pFrameChild
 );

LPD3DXFRAME WINAPI
D3DXFrameFind
 (
 CONST D3DXFRAME *pFrameRoot,
 LPCSTR Name
 );

HRESULT WINAPI
D3DXFrameRegisterNamedMatrices
 (
 LPD3DXFRAME pFrameRoot,
 LPD3DXANIMATIONCONTROLLER pAnimController
 );

/*
 * D3DXFrameNumNamedMatrices:
 * --------------------------
 * Counts number of frames in a subtree that have non-null names
 *
 * Parameters:
 * pFrameRoot
 * Pointer to the root node of the subtree
 * Return Value:
 * Count of frames
 *
 */
UINT WINAPI
D3DXFrameNumNamedMatrices
 (
 CONST D3DXFRAME *pFrameRoot
 );

/*
 * D3DXFrameCalculateBoundingSphere:
 * ---------------------------------
 * Computes the bounding sphere of all the meshes in the frame hierarchy.
 *
 * Parameters:
 * pFrameRoot
 * Pointer to the root node
 * pObjectCenter
 * Returns the center of the bounding sphere
 * pObjectRadius
 * Returns the radius of the bounding sphere
 *
 */
HRESULT WINAPI
D3DXFrameCalculateBoundingSphere
 (
 CONST D3DXFRAME *pFrameRoot,
 LPD3DXVECTOR3 pObjectCenter,
 FLOAT *pObjectRadius
 );


/*
 * D3DXCreateKeyframedAnimationSet:
 * --------------------------------
 * This function creates a compressable keyframed animations set interface.
 *
 * Parameters:
 * pName
 * Name of the animation set
 * TicksPerSecond
 * Number of keyframe ticks that elapse per second
 * Playback
 * Playback mode of keyframe looping
 * NumAnimations
 * Number of SRT animations
 * NumCallbackKeys
 * Number of callback keys
 * pCallbackKeys
 * Array of callback keys
 * ppAnimationSet
 * Returns the animation set interface
 *
 */

HRESULT WINAPI
D3DXCreateKeyframedAnimationSet
 (
 LPCSTR pName,
 DOUBLE TicksPerSecond,
 D3DXPLAYBACK_TYPE Playback,
 UINT NumAnimations,
 UINT NumCallbackKeys,
 CONST D3DXKEY_CALLBACK *pCallbackKeys,
 LPD3DXKEYFRAMEDANIMATIONSET *ppAnimationSet
 );


/*
 * D3DXCreateCompressedAnimationSet:
 * --------------------------------
 * This function creates a compressed animations set interface from
 * compressed data.
 *
 * Parameters:
 * pName
 * Name of the animation set
 * TicksPerSecond
 * Number of keyframe ticks that elapse per second
 * Playback
 * Playback mode of keyframe looping
 * pCompressedData
 * Compressed animation SRT data
 * NumCallbackKeys
 * Number of callback keys
 * pCallbackKeys
 * Array of callback keys
 * ppAnimationSet
 * Returns the animation set interface
 *
 */

HRESULT WINAPI
D3DXCreateCompressedAnimationSet
 (
 LPCSTR pName,
 DOUBLE TicksPerSecond,
 D3DXPLAYBACK_TYPE Playback,
 LPD3DXBUFFER pCompressedData,
 UINT NumCallbackKeys,
 CONST D3DXKEY_CALLBACK *pCallbackKeys,
 LPD3DXCOMPRESSEDANIMATIONSET *ppAnimationSet
 );

HRESULT WINAPI
D3DXCreateAnimationController
 (
 UINT MaxNumMatrices,
 UINT MaxNumAnimationSets,
 UINT MaxNumTracks,
 UINT MaxNumEvents,
 LPD3DXANIMATIONCONTROLLER *ppAnimController
 );


#ifdef __cplusplus
}
#endif /*__cplusplus */

#endif /*__D3DX9ANIM_H__ */