UseDXX.h

Go to the documentation of this file.

//
//
#ifndef _INC_UseDXX_H
#define _INC_UseDXX_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "UseDX.h"
 
#ifdef USE_DXX
#include <d3dx9.h>              // Extra DX9 stuff for meshes, loading textures, effects , etc.
 
#else
 
#define THIS_
#ifndef THIS
#define THIS
#define PURE
#endif
 
//interface ID3DXAllocateHierarchy;
//interface ID3DXBuffer;        // LPD3DXBUFFER
//interface ID3DXLoadUserData;
interface ID3DXSaveUserData;
interface ID3DXAnimationController;
//interface ID3DXFileData;
interface ID3DXFileSaveData;
interface ID3DXFile;
interface ID3DXEffect;
interface ID3DXBaseMesh;
interface ID3DXMesh;    // LPD3DXMESH
interface ID3DXSkinInfo;        // NOT USED ?
//interface ID3DXPMesh;
//interface ID3DXPatchMesh;
 
#define MAX_FVF_DECL_SIZE       (64+1)          //  MAXD3DDECLLENGTH + 1 // +1 for END
typedef DWORD D3DXATTRIBUTERANGE;       // ???
 
enum _D3DXEFFECTDEFAULTTYPE
{
        D3DXEDT_STRING = 0x1,       // pValue points to a null terminated ASCII string
        D3DXEDT_FLOATS = 0x2,       // pValue points to an array of floats - number of floats is NumBytes / sizeof(float)
        D3DXEDT_DWORD = 0x3,       // pValue points to a DWORD
 
        D3DXEDT_FORCEDWORD = 0x7fffffff
};
 
struct _D3DXMATERIAL
{
        _D3DMATERIAL9  MatD3D;
        char* pTextureFilename;
};
 
struct _D3DXEFFECTDEFAULT
{
        LPSTR                 pParamName;
        enum _D3DXEFFECTDEFAULTTYPE Type;           // type of the data pointed to by pValue
        DWORD                 NumBytes;       // size in bytes of the data pointed to by pValue
        LPVOID                pValue;         // data for the default of the effect
}; //  D3DXEFFECTDEFAULT, *LPD3DXEFFECTDEFAULT
 
struct _D3DXEFFECTINSTANCE
{
        char* pEffectFilename;
        DWORD               NumDefaults;
        _D3DXEFFECTDEFAULT* pDefaults;
};
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
};
struct _D3DXMESHDATA
{
        _D3DXMESHDATATYPE Type;
 
        // current mesh data interface
        union
        {
                ID3DXMesh* pMesh;
                // ID3DXPMesh*             pPMesh;
                // ID3DXPatchMesh*         pPatchMesh;
        };
};
struct _D3DXMESHCONTAINER
{
        char* Name;
        _D3DXMESHDATA            MeshData;
        _D3DXMATERIAL* pMaterials;
        _D3DXEFFECTINSTANCE* pEffects;
        DWORD                   NumMaterials;
        DWORD* pAdjacency;
        ID3DXSkinInfo* pSkinInfo;       // NOT USED
        struct _D3DXMESHCONTAINER* pNextMeshContainer;
};
 
struct _D3DXFRAME
{
        char* Name;
        XMFLOAT4X4              TransformationMatrix;
 
        _D3DXMESHCONTAINER* pMeshContainer;
 
        struct _D3DXFRAME* pFrameSibling;
        struct _D3DXFRAME* pFrameFirstChild;
};
 
#define D3DX_DEFAULT            ((UINT) -1)
 
enum _D3DXMESHOPT
{
        // ID3DXMesh::Optimize options - upper byte only, lower 3 bytes used from _D3DXMESH option flags
        D3DXMESHOPT_COMPACT = 0x01000000,
        D3DXMESHOPT_ATTRSORT = 0x02000000,
        D3DXMESHOPT_VERTEXCACHE = 0x04000000,
        D3DXMESHOPT_STRIPREORDER = 0x08000000,
        D3DXMESHOPT_IGNOREVERTS = 0x10000000,  // optimize faces only, don't touch vertices
        D3DXMESHOPT_DONOTSPLIT = 0x20000000,  // do not split vertices shared between attribute groups when attribute sorting
        D3DXMESHOPT_DEVICEINDEPENDENT = 0x00400000,  // Only affects VCache.  uses a static known good cache size for all cards
        // D3DXMESHOPT_SHAREVB has been removed, please use D3DXMESH_VB_SHARE instead
};
 
DECLARE_INTERFACE_(ID3DXBuffer, IUnknown)
{
        // IUnknown
        STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
        STDMETHOD_(ULONG, AddRef)(THIS) PURE;
        STDMETHOD_(ULONG, Release)(THIS) PURE;
 
        // ID3DXBuffer
        STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;
        STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;
};
 
// Mesh options - lower 3 bytes only, upper byte used by _D3DXMESHOPT option flags
enum _D3DXMESH
{
        D3DXMESH_32BIT                  = 0x001, // If set, then use 32 bit indices, if not set use 16 bit indices.
        D3DXMESH_DONOTCLIP              = 0x002, // Use D3DUSAGE_DONOTCLIP for VB & IB.
        D3DXMESH_POINTS                 = 0x004, // Use D3DUSAGE_POINTS for VB & IB.
        D3DXMESH_RTPATCHES              = 0x008, // Use D3DUSAGE_RTPATCHES for VB & IB.
        D3DXMESH_NPATCHES               = 0x4000,// Use D3DUSAGE_NPATCHES for VB & IB.
        D3DXMESH_VB_SYSTEMMEM           = 0x010, // Use D3DPOOL_SYSTEMMEM for VB. Overrides D3DXMESH_MANAGEDVERTEXBUFFER
        D3DXMESH_VB_MANAGED             = 0x020, // Use D3DPOOL_MANAGED for VB.
        D3DXMESH_VB_WRITEONLY           = 0x040, // Use D3DUSAGE_WRITEONLY for VB.
        D3DXMESH_VB_DYNAMIC             = 0x080, // Use D3DUSAGE_DYNAMIC for VB.
        D3DXMESH_VB_SOFTWAREPROCESSING = 0x8000, // Use D3DUSAGE_SOFTWAREPROCESSING for VB.
        D3DXMESH_IB_SYSTEMMEM           = 0x100, // Use D3DPOOL_SYSTEMMEM for IB. Overrides D3DXMESH_MANAGEDINDEXBUFFER
        D3DXMESH_IB_MANAGED             = 0x200, // Use D3DPOOL_MANAGED for IB.
        D3DXMESH_IB_WRITEONLY           = 0x400, // Use D3DUSAGE_WRITEONLY for IB.
        D3DXMESH_IB_DYNAMIC             = 0x800, // Use D3DUSAGE_DYNAMIC for IB.
        D3DXMESH_IB_SOFTWAREPROCESSING= 0x10000, // Use D3DUSAGE_SOFTWAREPROCESSING for IB.
 
        D3DXMESH_VB_SHARE               = 0x1000, // Valid for Clone* calls only, forces cloned mesh/pmesh to share vertex buffer
 
        D3DXMESH_USEHWONLY              = 0x2000, // Valid for ID3DXSkinInfo::ConvertToBlendedMesh
 
        // Helper options
        D3DXMESH_SYSTEMMEM              = 0x110, // D3DXMESH_VB_SYSTEMMEM | D3DXMESH_IB_SYSTEMMEM
        D3DXMESH_MANAGED                = 0x220, // D3DXMESH_VB_MANAGED | D3DXMESH_IB_MANAGED
        D3DXMESH_WRITEONLY              = 0x440, // D3DXMESH_VB_WRITEONLY | D3DXMESH_IB_WRITEONLY
        D3DXMESH_DYNAMIC                = 0x880, // D3DXMESH_VB_DYNAMIC | D3DXMESH_IB_DYNAMIC
        D3DXMESH_SOFTWAREPROCESSING   = 0x18000, // D3DXMESH_VB_SOFTWAREPROCESSING | D3DXMESH_IB_SOFTWAREPROCESSING
};
 
DECLARE_INTERFACE_(ID3DXBaseMesh, IUnknown)
{
        // IUnknown
        STDMETHOD(QueryInterface)(THIS_ const IID& iid, void* *ppv) PURE;
        STDMETHOD_(ULONG, AddRef)(THIS) PURE;
        STDMETHOD_(ULONG, Release)(THIS) PURE;
 
        // ID3DXBaseMesh
        STDMETHOD(DrawSubset)(THIS_ DWORD AttribId) PURE;
        STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE;
        STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE;
        STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
        STDMETHOD(GetDeclaration)(THIS_ _D3DVERTEXELEMENT9 Declaration[]) PURE; // MAX_FVF_DECL_SIZE
        STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE;
        STDMETHOD_(DWORD, GetOptions)(THIS) PURE;
        STDMETHOD(GetDevice)(THIS_ IDirect3DDevice9** ppDevice) PURE;
        STDMETHOD(CloneMeshFVF)(THIS_ DWORD Options,
                DWORD FVF, IDirect3DDevice9* pD3DDevice, ID3DXMesh** ppCloneMesh) PURE;
        STDMETHOD(CloneMesh)(THIS_ DWORD Options,
                const _D3DVERTEXELEMENT9 *pDeclaration, IDirect3DDevice9* pD3DDevice, ID3DXMesh** ppCloneMesh) PURE;
        STDMETHOD(GetVertexBuffer)(THIS_ IDirect3DVertexBuffer9** ppVB) PURE;
        STDMETHOD(GetIndexBuffer)(THIS_ IDirect3DIndexBuffer9** ppIB) PURE;
        STDMETHOD(LockVertexBuffer)(THIS_ DWORD Flags, void* *ppData) PURE;
        STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
        STDMETHOD(LockIndexBuffer)(THIS_ DWORD Flags, void* *ppData) PURE;
        STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
        STDMETHOD(GetAttributeTable)(
                THIS_ D3DXATTRIBUTERANGE *pAttribTable, DWORD* pAttribTableSize) PURE;
 
        STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD* pPRep, DWORD* pAdjacency) PURE;
        STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD* pAdjacency, DWORD* pPRep) PURE;
        STDMETHOD(GenerateAdjacency)(THIS_ float Epsilon, DWORD* pAdjacency) PURE;
 
        STDMETHOD(UpdateSemantics)(THIS_ _D3DVERTEXELEMENT9 Declaration[]) PURE;        // MAX_FVF_DECL_SIZE
};
 
DECLARE_INTERFACE_(ID3DXMesh,ID3DXBaseMesh)
{
        // LockAttributeBuffer
        // UnlockAttributeBuffer
 
        // IUnknown
        STDMETHOD(QueryInterface)(THIS_ const IID& iid, void* *ppv) PURE;
        STDMETHOD_(ULONG, AddRef)(THIS) PURE;
        STDMETHOD_(ULONG, Release)(THIS) PURE;
 
        // ID3DXBaseMesh
        STDMETHOD(DrawSubset)(THIS_ DWORD AttribId) PURE;
        STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE;
        STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE;
        STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
        STDMETHOD(GetDeclaration)(THIS_ _D3DVERTEXELEMENT9 Declaration[]) PURE; // MAX_FVF_DECL_SIZE
        STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE;
        STDMETHOD_(DWORD, GetOptions)(THIS) PURE;
        STDMETHOD(GetDevice)(THIS_ IDirect3DDevice9** ppDevice) PURE;
        STDMETHOD(CloneMeshFVF)(THIS_ DWORD Options,
                DWORD FVF, IDirect3DDevice9* pD3DDevice, ID3DXMesh** ppCloneMesh) PURE;
        STDMETHOD(CloneMesh)(THIS_ DWORD Options,
                const _D3DVERTEXELEMENT9 *pDeclaration, IDirect3DDevice9* pD3DDevice, ID3DXMesh** ppCloneMesh) PURE;
        STDMETHOD(GetVertexBuffer)(THIS_ IDirect3DVertexBuffer9** ppVB) PURE;
        STDMETHOD(GetIndexBuffer)(THIS_ IDirect3DIndexBuffer9** ppIB) PURE;
        STDMETHOD(LockVertexBuffer)(THIS_ DWORD Flags, void* *ppData) PURE;
        STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
        STDMETHOD(LockIndexBuffer)(THIS_ DWORD Flags, void* *ppData) PURE;
        STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
        STDMETHOD(GetAttributeTable)(
                THIS_ D3DXATTRIBUTERANGE *pAttribTable, DWORD* pAttribTableSize) PURE;
 
        STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ const DWORD* pPRep, DWORD* pAdjacency) PURE;
        STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ const DWORD* pAdjacency, DWORD* pPRep) PURE;
        STDMETHOD(GenerateAdjacency)(THIS_ float Epsilon, DWORD* pAdjacency) PURE;
 
        STDMETHOD(UpdateSemantics)(THIS_ _D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
 
        // ID3DXMesh
        STDMETHOD(LockAttributeBuffer)(THIS_ DWORD Flags, DWORD** ppData) PURE;
        STDMETHOD(UnlockAttributeBuffer)(THIS) PURE;
        STDMETHOD(Optimize)(THIS_ DWORD Flags, const DWORD* pAdjacencyIn, DWORD* pAdjacencyOut,
                DWORD* pFaceRemap, ID3DXBuffer**ppVertexRemap,
                ID3DXMesh** ppOptMesh) PURE;
        STDMETHOD(OptimizeInplace)(THIS_ DWORD Flags, const DWORD* pAdjacencyIn, DWORD* pAdjacencyOut,
                DWORD* pFaceRemap, ID3DXBuffer** ppVertexRemap) PURE;
        STDMETHOD(SetAttributeTable)(THIS_ const D3DXATTRIBUTERANGE *pAttribTable, DWORD cAttribTableSize) PURE;
};
 
DECLARE_INTERFACE(ID3DXAllocateHierarchy)
{
        // ID3DXAllocateHierarchy
 
        //------------------------------------------------------------------------
        // CreateFrame:
        // ------------
        // Requests allocation of a frame object.
        //
        // Parameters:
        //  Name
        //              Name of the frame to be created
        //      ppNewFrame
        //              Returns the created frame object
        //
        //------------------------------------------------------------------------
        STDMETHOD(CreateFrame)(THIS_ LPCSTR Name, _D3DXFRAME* *ppNewFrame) PURE;
 
        //------------------------------------------------------------------------
        // CreateMeshContainer:
        // --------------------
        // Requests allocation of a mesh container object.
        //
        // Parameters:
        //  Name
        //              Name of the mesh
        //      pMesh
        //              Pointer to the mesh object if basic polygon data found
        //      pPMesh
        //              Pointer to the progressive mesh object if progressive mesh data found
        //      pPatchMesh
        //              Pointer to the patch mesh object if patch data found
        //      pMaterials
        //              Array of materials used in the mesh
        //      pEffectInstances
        //              Array of effect instances used in the mesh
        //      NumMaterials
        //              Num elements in the pMaterials array
        //      pAdjacency
        //              Adjacency array for the mesh
        //      pSkinInfo
        //              Pointer to the skininfo object if the mesh is skinned
        //      pBoneNames
        //              Array of names, one for each bone in the skinned mesh.
        //              The numberof bones can be found from the pSkinMesh object
        //      pBoneOffsetMatrices
        //              Array of matrices, one for each bone in the skinned mesh.
        //
        //------------------------------------------------------------------------
        STDMETHOD(CreateMeshContainer)(THIS_
                LPCSTR Name,
                const _D3DXMESHDATA *pMeshData,
                const _D3DXMATERIAL *pMaterials,
                const _D3DXEFFECTINSTANCE *pEffectInstances,
                DWORD NumMaterials,
                const DWORD *pAdjacency,
                ID3DXSkinInfo* /* pSkinInfo*/,
                _D3DXMESHCONTAINER* *ppNewMeshContainer) PURE;
 
        //------------------------------------------------------------------------
        // DestroyFrame:
        // -------------
        // Requests de-allocation of a frame object.
        //
        // Parameters:
        //  pFrameToFree
        //              Pointer to the frame to be de-allocated
        //
        //------------------------------------------------------------------------
        STDMETHOD(DestroyFrame)(THIS_ _D3DXFRAME* pFrameToFree) PURE;
 
        //------------------------------------------------------------------------
        // DestroyMeshContainer:
        // ---------------------
        // Requests de-allocation of a mesh container object.
        //
        // Parameters:
        //  pMeshContainerToFree
        //              Pointer to the mesh container object to be de-allocated
        //
        //------------------------------------------------------------------------
        STDMETHOD(DestroyMeshContainer)(THIS_ _D3DXMESHCONTAINER* pMeshContainerToFree) PURE;
};
 
interface ID3DXFileEnumObject;
 
DECLARE_INTERFACE_(ID3DXFileData, IUnknown)
{
        STDMETHOD(QueryInterface)(THIS_ REFIID, LPVOID*) PURE;
        STDMETHOD_(ULONG, AddRef)(THIS) PURE;
        STDMETHOD_(ULONG, Release)(THIS) PURE;
 
        STDMETHOD(GetEnum)(THIS_ ID3DXFileEnumObject**) PURE;
        STDMETHOD(GetName)(THIS_ LPSTR, SIZE_T*) PURE;
        STDMETHOD(GetId)(THIS_ LPGUID) PURE;
        STDMETHOD(Lock)(THIS_ SIZE_T*, LPCVOID*) PURE;
        STDMETHOD(Unlock)(THIS) PURE;
        STDMETHOD(GetType)(THIS_ GUID*) PURE;
        STDMETHOD_(BOOL, IsReference)(THIS) PURE;
        STDMETHOD(GetChildren)(THIS_ SIZE_T*) PURE;
        STDMETHOD(GetChild)(THIS_ SIZE_T, ID3DXFileData**) PURE;
};
 
DECLARE_INTERFACE_(ID3DXFileEnumObject, IUnknown)
{
        STDMETHOD(QueryInterface)(THIS_ REFIID, LPVOID*) PURE;
        STDMETHOD_(ULONG, AddRef)(THIS) PURE;
        STDMETHOD_(ULONG, Release)(THIS) PURE;
 
        STDMETHOD(GetFile)(THIS_ ID3DXFile**) PURE;
        STDMETHOD(GetChildren)(THIS_ SIZE_T*) PURE;
        STDMETHOD(GetChild)(THIS_ SIZE_T, ID3DXFileData**) PURE;
        STDMETHOD(GetDataObjectById)(THIS_ REFGUID, ID3DXFileData**) PURE;
        STDMETHOD(GetDataObjectByName)(THIS_ LPCSTR, ID3DXFileData**) PURE;
};
 
DECLARE_INTERFACE(ID3DXLoadUserData)
{
        STDMETHOD(LoadTopLevelData)(ID3DXFileData* pXofChildData) PURE;
 
        STDMETHOD(LoadFrameChildData)(_D3DXFRAME* pFrame,
                ID3DXFileData* pXofChildData) PURE;
 
        STDMETHOD(LoadMeshChildData)(_D3DXMESHCONTAINER* pMeshContainer,
                ID3DXFileData* pXofChildData) PURE;
};
 
#endif  // USE_DXX
#endif // _INC_UseDXX_H