Demos/DX11ClothDemo/DXUT/Optional/SDKmesh.h

   1 //--------------------------------------------------------------------------------------\r
   2 // File: SDKMesh.h\r
   3 //\r
   4 // Disclaimer:  \r
   5 //   The SDK Mesh format (.sdkmesh) is not a recommended file format for shipping titles.  \r
   6 //   It was designed to meet the specific needs of the SDK samples.  Any real-world \r
   7 //   applications should avoid this file format in favor of a destination format that \r
   8 //   meets the specific needs of the application.\r
   9 //\r
  10 // Copyright (c) Microsoft Corporation. All rights reserved.\r
  11 //--------------------------------------------------------------------------------------\r
  12 #pragma once\r
  13 #ifndef _SDKMESH_\r
  14 #define _SDKMESH_\r
  15 \r
  16 //--------------------------------------------------------------------------------------\r
  17 // Hard Defines for the various structures\r
  18 //--------------------------------------------------------------------------------------\r
  19 #define SDKMESH_FILE_VERSION 101\r
  20 #define MAX_VERTEX_ELEMENTS 32\r
  21 #define MAX_VERTEX_STREAMS 16\r
  22 #define MAX_FRAME_NAME 100\r
  23 #define MAX_MESH_NAME 100\r
  24 #define MAX_SUBSET_NAME 100\r
  25 #define MAX_MATERIAL_NAME 100\r
  26 #define MAX_TEXTURE_NAME MAX_PATH\r
  27 #define MAX_MATERIAL_PATH MAX_PATH\r
  28 #define INVALID_FRAME ((UINT)-1)\r
  29 #define INVALID_MESH ((UINT)-1)\r
  30 #define INVALID_MATERIAL ((UINT)-1)\r
  31 #define INVALID_SUBSET ((UINT)-1)\r
  32 #define INVALID_ANIMATION_DATA ((UINT)-1)\r
  33 #define INVALID_SAMPLER_SLOT ((UINT)-1)\r
  34 #define ERROR_RESOURCE_VALUE 1\r
  35 \r
  36 template<typename TYPE> BOOL IsErrorResource( TYPE data )\r
  37 {\r
  38     if( ( TYPE )ERROR_RESOURCE_VALUE == data )\r
  39         return TRUE;\r
  40     return FALSE;\r
  41 }\r
  42 //--------------------------------------------------------------------------------------\r
  43 // Enumerated Types.  These will have mirrors in both D3D9 and D3D11\r
  44 //--------------------------------------------------------------------------------------\r
  45 enum SDKMESH_PRIMITIVE_TYPE\r
  46 {\r
  47     PT_TRIANGLE_LIST = 0,\r
  48     PT_TRIANGLE_STRIP,\r
  49     PT_LINE_LIST,\r
  50     PT_LINE_STRIP,\r
  51     PT_POINT_LIST,\r
  52     PT_TRIANGLE_LIST_ADJ,\r
  53     PT_TRIANGLE_STRIP_ADJ,\r
  54     PT_LINE_LIST_ADJ,\r
  55     PT_LINE_STRIP_ADJ,\r
  56     PT_QUAD_PATCH_LIST,\r
  57     PT_TRIANGLE_PATCH_LIST,\r
  58 };\r
  59 \r
  60 enum SDKMESH_INDEX_TYPE\r
  61 {\r
  62     IT_16BIT = 0,\r
  63     IT_32BIT,\r
  64 };\r
  65 \r
  66 enum FRAME_TRANSFORM_TYPE\r
  67 {\r
  68     FTT_RELATIVE = 0,\r
  69     FTT_ABSOLUTE,               //This is not currently used but is here to support absolute transformations in the future\r
  70 };\r
  71 \r
  72 //--------------------------------------------------------------------------------------\r
  73 // Structures.  Unions with pointers are forced to 64bit.\r
  74 //--------------------------------------------------------------------------------------\r
  75 struct SDKMESH_HEADER\r
  76 {\r
  77     //Basic Info and sizes\r
  78     UINT Version;\r
  79     BYTE IsBigEndian;\r
  80     UINT64 HeaderSize;\r
  81     UINT64 NonBufferDataSize;\r
  82     UINT64 BufferDataSize;\r
  83 \r
  84     //Stats\r
  85     UINT NumVertexBuffers;\r
  86     UINT NumIndexBuffers;\r
  87     UINT NumMeshes;\r
  88     UINT NumTotalSubsets;\r
  89     UINT NumFrames;\r
  90     UINT NumMaterials;\r
  91 \r
  92     //Offsets to Data\r
  93     UINT64 VertexStreamHeadersOffset;\r
  94     UINT64 IndexStreamHeadersOffset;\r
  95     UINT64 MeshDataOffset;\r
  96     UINT64 SubsetDataOffset;\r
  97     UINT64 FrameDataOffset;\r
  98     UINT64 MaterialDataOffset;\r
  99 };\r
 100 \r
 101 struct SDKMESH_VERTEX_BUFFER_HEADER\r
 102 {\r
 103     UINT64 NumVertices;\r
 104     UINT64 SizeBytes;\r
 105     UINT64 StrideBytes;\r
 106     D3DVERTEXELEMENT9 Decl[MAX_VERTEX_ELEMENTS];\r
 107     union\r
 108     {\r
 109         UINT64 DataOffset;                              //(This also forces the union to 64bits)\r
 110         IDirect3DVertexBuffer9* pVB9;\r
 111         ID3D11Buffer* pVB11;\r
 112     };\r
 113 };\r
 114 \r
 115 struct SDKMESH_INDEX_BUFFER_HEADER\r
 116 {\r
 117     UINT64 NumIndices;\r
 118     UINT64 SizeBytes;\r
 119     UINT IndexType;\r
 120     union\r
 121     {\r
 122         UINT64 DataOffset;                              //(This also forces the union to 64bits)\r
 123         IDirect3DIndexBuffer9* pIB9;\r
 124         ID3D11Buffer* pIB11;\r
 125     };\r
 126 };\r
 127 \r
 128 struct SDKMESH_MESH\r
 129 {\r
 130     char Name[MAX_MESH_NAME];\r
 131     BYTE NumVertexBuffers;\r
 132     UINT VertexBuffers[MAX_VERTEX_STREAMS];\r
 133     UINT IndexBuffer;\r
 134     UINT NumSubsets;\r
 135     UINT NumFrameInfluences; //aka bones\r
 136 \r
 137     D3DXVECTOR3 BoundingBoxCenter;\r
 138     D3DXVECTOR3 BoundingBoxExtents;\r
 139 \r
 140     union\r
 141     {\r
 142         UINT64 SubsetOffset;    //Offset to list of subsets (This also forces the union to 64bits)\r
 143         UINT* pSubsets;     //Pointer to list of subsets\r
 144     };\r
 145     union\r
 146     {\r
 147         UINT64 FrameInfluenceOffset;  //Offset to list of frame influences (This also forces the union to 64bits)\r
 148         UINT* pFrameInfluences;      //Pointer to list of frame influences\r
 149     };\r
 150 };\r
 151 \r
 152 struct SDKMESH_SUBSET\r
 153 {\r
 154     char Name[MAX_SUBSET_NAME];\r
 155     UINT MaterialID;\r
 156     UINT PrimitiveType;\r
 157     UINT64 IndexStart;\r
 158     UINT64 IndexCount;\r
 159     UINT64 VertexStart;\r
 160     UINT64 VertexCount;\r
 161 };\r
 162 \r
 163 struct SDKMESH_FRAME\r
 164 {\r
 165     char Name[MAX_FRAME_NAME];\r
 166     UINT Mesh;\r
 167     UINT ParentFrame;\r
 168     UINT ChildFrame;\r
 169     UINT SiblingFrame;\r
 170     D3DXMATRIX Matrix;\r
 171     UINT AnimationDataIndex;            //Used to index which set of keyframes transforms this frame\r
 172 };\r
 173 \r
 174 struct SDKMESH_MATERIAL\r
 175 {\r
 176     char    Name[MAX_MATERIAL_NAME];\r
 177 \r
 178     // Use MaterialInstancePath\r
 179     char    MaterialInstancePath[MAX_MATERIAL_PATH];\r
 180 \r
 181     // Or fall back to d3d8-type materials\r
 182     char    DiffuseTexture[MAX_TEXTURE_NAME];\r
 183     char    NormalTexture[MAX_TEXTURE_NAME];\r
 184     char    SpecularTexture[MAX_TEXTURE_NAME];\r
 185 \r
 186     D3DXVECTOR4 Diffuse;\r
 187     D3DXVECTOR4 Ambient;\r
 188     D3DXVECTOR4 Specular;\r
 189     D3DXVECTOR4 Emissive;\r
 190     FLOAT Power;\r
 191 \r
 192     union\r
 193     {\r
 194         UINT64 Force64_1;                       //Force the union to 64bits\r
 195         IDirect3DTexture9* pDiffuseTexture9;\r
 196         ID3D11Texture2D* pDiffuseTexture11;\r
 197     };\r
 198     union\r
 199     {\r
 200         UINT64 Force64_2;                       //Force the union to 64bits\r
 201         IDirect3DTexture9* pNormalTexture9;\r
 202         ID3D11Texture2D* pNormalTexture11;\r
 203     };\r
 204     union\r
 205     {\r
 206         UINT64 Force64_3;                       //Force the union to 64bits\r
 207         IDirect3DTexture9* pSpecularTexture9;\r
 208         ID3D11Texture2D* pSpecularTexture11;\r
 209     };\r
 210 \r
 211     union\r
 212     {\r
 213         UINT64 Force64_4;                       //Force the union to 64bits\r
 214         ID3D11ShaderResourceView* pDiffuseRV11;\r
 215     };\r
 216     union\r
 217     {\r
 218         UINT64 Force64_5;                   //Force the union to 64bits\r
 219         ID3D11ShaderResourceView* pNormalRV11;\r
 220     };\r
 221     union\r
 222     {\r
 223         UINT64 Force64_6;                       //Force the union to 64bits\r
 224         ID3D11ShaderResourceView* pSpecularRV11;\r
 225     };\r
 226 \r
 227 };\r
 228 \r
 229 struct SDKANIMATION_FILE_HEADER\r
 230 {\r
 231     UINT Version;\r
 232     BYTE IsBigEndian;\r
 233     UINT FrameTransformType;\r
 234     UINT NumFrames;\r
 235     UINT NumAnimationKeys;\r
 236     UINT AnimationFPS;\r
 237     UINT64 AnimationDataSize;\r
 238     UINT64 AnimationDataOffset;\r
 239 };\r
 240 \r
 241 struct SDKANIMATION_DATA\r
 242 {\r
 243     D3DXVECTOR3 Translation;\r
 244     D3DXVECTOR4 Orientation;\r
 245     D3DXVECTOR3 Scaling;\r
 246 };\r
 247 \r
 248 struct SDKANIMATION_FRAME_DATA\r
 249 {\r
 250     char FrameName[MAX_FRAME_NAME];\r
 251     union\r
 252     {\r
 253         UINT64 DataOffset;\r
 254         SDKANIMATION_DATA* pAnimationData;\r
 255     };\r
 256 };\r
 257 \r
 258 #ifndef _CONVERTER_APP_\r
 259 \r
 260 //--------------------------------------------------------------------------------------\r
 261 // AsyncLoading callbacks\r
 262 //--------------------------------------------------------------------------------------\r
 263 typedef void ( CALLBACK*LPCREATETEXTUREFROMFILE9 )( IDirect3DDevice9* pDev, char* szFileName,\r
 264                                                     IDirect3DTexture9** ppTexture, void* pContext );\r
 265 typedef void ( CALLBACK*LPCREATEVERTEXBUFFER9 )( IDirect3DDevice9* pDev, IDirect3DVertexBuffer9** ppBuffer,\r
 266                                                  UINT iSizeBytes, DWORD Usage, DWORD FVF, D3DPOOL Pool, void* pData,\r
 267                                                  void* pContext );\r
 268 typedef void ( CALLBACK*LPCREATEINDEXBUFFER9 )( IDirect3DDevice9* pDev, IDirect3DIndexBuffer9** ppBuffer,\r
 269                                                 UINT iSizeBytes, DWORD Usage, D3DFORMAT ibFormat, D3DPOOL Pool,\r
 270                                                 void* pData, void* pContext );\r
 271 struct SDKMESH_CALLBACKS9\r
 272 {\r
 273     LPCREATETEXTUREFROMFILE9 pCreateTextureFromFile;\r
 274     LPCREATEVERTEXBUFFER9 pCreateVertexBuffer;\r
 275     LPCREATEINDEXBUFFER9 pCreateIndexBuffer;\r
 276     void* pContext;\r
 277 };\r
 278 \r
 279 \r
 280 typedef void ( CALLBACK*LPCREATETEXTUREFROMFILE11 )( ID3D11Device* pDev, char* szFileName,\r
 281                                                      ID3D11ShaderResourceView** ppRV, void* pContext );\r
 282 typedef void ( CALLBACK*LPCREATEVERTEXBUFFER11 )( ID3D11Device* pDev, ID3D11Buffer** ppBuffer,\r
 283                                                   D3D11_BUFFER_DESC BufferDesc, void* pData, void* pContext );\r
 284 typedef void ( CALLBACK*LPCREATEINDEXBUFFER11 )( ID3D11Device* pDev, ID3D11Buffer** ppBuffer,\r
 285                                                  D3D11_BUFFER_DESC BufferDesc, void* pData, void* pContext );\r
 286 struct SDKMESH_CALLBACKS11\r
 287 {\r
 288     LPCREATETEXTUREFROMFILE11 pCreateTextureFromFile;\r
 289     LPCREATEVERTEXBUFFER11 pCreateVertexBuffer;\r
 290     LPCREATEINDEXBUFFER11 pCreateIndexBuffer;\r
 291     void* pContext;\r
 292 };\r
 293 \r
 294 //--------------------------------------------------------------------------------------\r
 295 // CDXUTSDKMesh class.  This class reads the sdkmesh file format for use by the samples\r
 296 //--------------------------------------------------------------------------------------\r
 297 class CDXUTSDKMesh\r
 298 {\r
 299 private:\r
 300     UINT m_NumOutstandingResources;\r
 301     bool m_bLoading;\r
 302     //BYTE*                         m_pBufferData;\r
 303     HANDLE m_hFile;\r
 304     HANDLE m_hFileMappingObject;\r
 305     CGrowableArray <BYTE*> m_MappedPointers;\r
 306     IDirect3DDevice9* m_pDev9;\r
 307     ID3D11Device* m_pDev11;\r
 308     ID3D11DeviceContext* m_pDevContext11;\r
 309 \r
 310 protected:\r
 311     //These are the pointers to the two chunks of data loaded in from the mesh file\r
 312     BYTE* m_pStaticMeshData;\r
 313     BYTE* m_pHeapData;\r
 314     BYTE* m_pAnimationData;\r
 315     BYTE** m_ppVertices;\r
 316     BYTE** m_ppIndices;\r
 317 \r
 318     //Keep track of the path\r
 319     WCHAR                           m_strPathW[MAX_PATH];\r
 320     char                            m_strPath[MAX_PATH];\r
 321 \r
 322     //General mesh info\r
 323     SDKMESH_HEADER* m_pMeshHeader;\r
 324     SDKMESH_VERTEX_BUFFER_HEADER* m_pVertexBufferArray;\r
 325     SDKMESH_INDEX_BUFFER_HEADER* m_pIndexBufferArray;\r
 326     SDKMESH_MESH* m_pMeshArray;\r
 327     SDKMESH_SUBSET* m_pSubsetArray;\r
 328     SDKMESH_FRAME* m_pFrameArray;\r
 329     SDKMESH_MATERIAL* m_pMaterialArray;\r
 330 \r
 331     // Adjacency information (not part of the m_pStaticMeshData, so it must be created and destroyed separately )\r
 332     SDKMESH_INDEX_BUFFER_HEADER* m_pAdjacencyIndexBufferArray;\r
 333 \r
 334     //Animation (TODO: Add ability to load/track multiple animation sets)\r
 335     SDKANIMATION_FILE_HEADER* m_pAnimationHeader;\r
 336     SDKANIMATION_FRAME_DATA* m_pAnimationFrameData;\r
 337     D3DXMATRIX* m_pBindPoseFrameMatrices;\r
 338     D3DXMATRIX* m_pTransformedFrameMatrices;\r
 339     D3DXMATRIX* m_pWorldPoseFrameMatrices;\r
 340 \r
 341 protected:\r
 342     void                            LoadMaterials( ID3D11Device* pd3dDevice, SDKMESH_MATERIAL* pMaterials,\r
 343                                                    UINT NumMaterials, SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );\r
 344 \r
 345     void                            LoadMaterials( IDirect3DDevice9* pd3dDevice, SDKMESH_MATERIAL* pMaterials,\r
 346                                                    UINT NumMaterials, SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );\r
 347 \r
 348     HRESULT                         CreateVertexBuffer( ID3D11Device* pd3dDevice,\r
 349                                                         SDKMESH_VERTEX_BUFFER_HEADER* pHeader, void* pVertices,\r
 350                                                         SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );\r
 351     HRESULT                         CreateVertexBuffer( IDirect3DDevice9* pd3dDevice,\r
 352                                                         SDKMESH_VERTEX_BUFFER_HEADER* pHeader, void* pVertices,\r
 353                                                         SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );\r
 354 \r
 355     HRESULT                         CreateIndexBuffer( ID3D11Device* pd3dDevice, SDKMESH_INDEX_BUFFER_HEADER* pHeader,\r
 356                                                        void* pIndices, SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );\r
 357     HRESULT                         CreateIndexBuffer( IDirect3DDevice9* pd3dDevice,\r
 358                                                        SDKMESH_INDEX_BUFFER_HEADER* pHeader, void* pIndices,\r
 359                                                        SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );\r
 360 \r
 361     virtual HRESULT                 CreateFromFile( ID3D11Device* pDev11,\r
 362                                                     IDirect3DDevice9* pDev9,\r
 363                                                     LPCTSTR szFileName,\r
 364                                                     bool bCreateAdjacencyIndices,\r
 365                                                     SDKMESH_CALLBACKS11* pLoaderCallbacks11 = NULL,\r
 366                                                     SDKMESH_CALLBACKS9* pLoaderCallbacks9 = NULL );\r
 367 \r
 368     virtual HRESULT                 CreateFromMemory( ID3D11Device* pDev11,\r
 369                                                       IDirect3DDevice9* pDev9,\r
 370                                                       BYTE* pData,\r
 371                                                       UINT DataBytes,\r
 372                                                       bool bCreateAdjacencyIndices,\r
 373                                                       bool bCopyStatic,\r
 374                                                       SDKMESH_CALLBACKS11* pLoaderCallbacks11 = NULL,\r
 375                                                       SDKMESH_CALLBACKS9* pLoaderCallbacks9 = NULL );\r
 376 \r
 377     //frame manipulation\r
 378     void                            TransformBindPoseFrame( UINT iFrame, D3DXMATRIX* pParentWorld );\r
 379     void                            TransformFrame( UINT iFrame, D3DXMATRIX* pParentWorld, double fTime );\r
 380     void                            TransformFrameAbsolute( UINT iFrame, double fTime );\r
 381 \r
 382     //Direct3D 11 rendering helpers\r
 383     void                            RenderMesh( UINT iMesh,\r
 384                                                 bool bAdjacent,\r
 385                                                 ID3D11DeviceContext* pd3dDeviceContext,\r
 386                                                 UINT iDiffuseSlot,\r
 387                                                 UINT iNormalSlot,\r
 388                                                 UINT iSpecularSlot );\r
 389     void                            RenderFrame( UINT iFrame,\r
 390                                                  bool bAdjacent,\r
 391                                                  ID3D11DeviceContext* pd3dDeviceContext,\r
 392                                                  UINT iDiffuseSlot,\r
 393                                                  UINT iNormalSlot,\r
 394                                                  UINT iSpecularSlot );\r
 395 \r
 396 \r
 397     //Direct3D 9 rendering helpers\r
 398     void                            RenderMesh( UINT iMesh,\r
 399                                                 LPDIRECT3DDEVICE9 pd3dDevice,\r
 400                                                 LPD3DXEFFECT pEffect,\r
 401                                                 D3DXHANDLE hTechnique,\r
 402                                                 D3DXHANDLE htxDiffuse,\r
 403                                                 D3DXHANDLE htxNormal,\r
 404                                                 D3DXHANDLE htxSpecular );\r
 405     void                            RenderFrame( UINT iFrame,\r
 406                                                  LPDIRECT3DDEVICE9 pd3dDevice,\r
 407                                                  LPD3DXEFFECT pEffect,\r
 408                                                  D3DXHANDLE hTechnique,\r
 409                                                  D3DXHANDLE htxDiffuse,\r
 410                                                  D3DXHANDLE htxNormal,\r
 411                                                  D3DXHANDLE htxSpecular );\r
 412 \r
 413 public:\r
 414                                     CDXUTSDKMesh();\r
 415     virtual                         ~CDXUTSDKMesh();\r
 416 \r
 417     virtual HRESULT                 Create( ID3D11Device* pDev11, LPCTSTR szFileName, bool bCreateAdjacencyIndices=\r
 418                                             false, SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );\r
 419     virtual HRESULT                 Create( IDirect3DDevice9* pDev9, LPCTSTR szFileName, bool bCreateAdjacencyIndices=\r
 420                                             false, SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );\r
 421     virtual HRESULT                 Create( ID3D11Device* pDev11, BYTE* pData, UINT DataBytes,\r
 422                                             bool bCreateAdjacencyIndices=false, bool bCopyStatic=false,\r
 423                                             SDKMESH_CALLBACKS11* pLoaderCallbacks=NULL );\r
 424     virtual HRESULT                 Create( IDirect3DDevice9* pDev9, BYTE* pData, UINT DataBytes,\r
 425                                             bool bCreateAdjacencyIndices=false, bool bCopyStatic=false,\r
 426                                             SDKMESH_CALLBACKS9* pLoaderCallbacks=NULL );\r
 427     virtual HRESULT                 LoadAnimation( WCHAR* szFileName );\r
 428     virtual void                    Destroy();\r
 429 \r
 430     //Frame manipulation\r
 431     void                            TransformBindPose( D3DXMATRIX* pWorld );\r
 432     void                            TransformMesh( D3DXMATRIX* pWorld, double fTime );\r
 433 \r
 434 \r
 435     //Direct3D 11 Rendering\r
 436     virtual void                    Render( ID3D11DeviceContext* pd3dDeviceContext,\r
 437                                             UINT iDiffuseSlot = INVALID_SAMPLER_SLOT,\r
 438                                             UINT iNormalSlot = INVALID_SAMPLER_SLOT,\r
 439                                             UINT iSpecularSlot = INVALID_SAMPLER_SLOT );\r
 440     virtual void                    RenderAdjacent( ID3D11DeviceContext* pd3dDeviceContext,\r
 441                                                     UINT iDiffuseSlot = INVALID_SAMPLER_SLOT,\r
 442                                                     UINT iNormalSlot = INVALID_SAMPLER_SLOT,\r
 443                                                     UINT iSpecularSlot = INVALID_SAMPLER_SLOT );\r
 444 \r
 445     //Direct3D 9 Rendering\r
 446     virtual void                    Render( LPDIRECT3DDEVICE9 pd3dDevice,\r
 447                                             LPD3DXEFFECT pEffect,\r
 448                                             D3DXHANDLE hTechnique,\r
 449                                             D3DXHANDLE htxDiffuse = 0,\r
 450                                             D3DXHANDLE htxNormal = 0,\r
 451                                             D3DXHANDLE htxSpecular = 0 );\r
 452 \r
 453     //Helpers (D3D11 specific)\r
 454     static D3D11_PRIMITIVE_TOPOLOGY GetPrimitiveType11( SDKMESH_PRIMITIVE_TYPE PrimType );\r
 455     DXGI_FORMAT                     GetIBFormat11( UINT iMesh );\r
 456     ID3D11Buffer* GetVB11( UINT iMesh, UINT iVB );\r
 457     ID3D11Buffer* GetIB11( UINT iMesh );\r
 458     SDKMESH_INDEX_TYPE GetIndexType( UINT iMesh ); \r
 459 \r
 460     ID3D11Buffer* GetAdjIB11( UINT iMesh );\r
 461 \r
 462     //Helpers (D3D9 specific)\r
 463     static D3DPRIMITIVETYPE         GetPrimitiveType9( SDKMESH_PRIMITIVE_TYPE PrimType );\r
 464     D3DFORMAT                       GetIBFormat9( UINT iMesh );\r
 465     IDirect3DVertexBuffer9* GetVB9( UINT iMesh, UINT iVB );\r
 466     IDirect3DIndexBuffer9* GetIB9( UINT iMesh );\r
 467 \r
 468     //Helpers (general)\r
 469     char* GetMeshPathA();\r
 470     WCHAR* GetMeshPathW();\r
 471     UINT                            GetNumMeshes();\r
 472     UINT                            GetNumMaterials();\r
 473     UINT                            GetNumVBs();\r
 474     UINT                            GetNumIBs();\r
 475 \r
 476     ID3D11Buffer* GetVB11At( UINT iVB );\r
 477     ID3D11Buffer* GetIB11At( UINT iIB );\r
 478 \r
 479     IDirect3DVertexBuffer9* GetVB9At( UINT iVB );\r
 480     IDirect3DIndexBuffer9* GetIB9At( UINT iIB );\r
 481 \r
 482     BYTE* GetRawVerticesAt( UINT iVB );\r
 483     BYTE* GetRawIndicesAt( UINT iIB );\r
 484     SDKMESH_MATERIAL* GetMaterial( UINT iMaterial );\r
 485     SDKMESH_MESH* GetMesh( UINT iMesh );\r
 486     UINT                            GetNumSubsets( UINT iMesh );\r
 487     SDKMESH_SUBSET* GetSubset( UINT iMesh, UINT iSubset );\r
 488     UINT                            GetVertexStride( UINT iMesh, UINT iVB );\r
 489     UINT                            GetNumFrames();\r
 490     SDKMESH_FRAME*                  GetFrame( UINT iFrame );\r
 491     SDKMESH_FRAME*                  FindFrame( char* pszName );\r
 492     UINT64                          GetNumVertices( UINT iMesh, UINT iVB );\r
 493     UINT64                          GetNumIndices( UINT iMesh );\r
 494     D3DXVECTOR3                     GetMeshBBoxCenter( UINT iMesh );\r
 495     D3DXVECTOR3                     GetMeshBBoxExtents( UINT iMesh );\r
 496     UINT                            GetOutstandingResources();\r
 497     UINT                            GetOutstandingBufferResources();\r
 498     bool                            CheckLoadDone();\r
 499     bool                            IsLoaded();\r
 500     bool                            IsLoading();\r
 501     void                            SetLoading( bool bLoading );\r
 502     BOOL                            HadLoadingError();\r
 503 \r
 504     //Animation\r
 505     UINT                            GetNumInfluences( UINT iMesh );\r
 506     const D3DXMATRIX*               GetMeshInfluenceMatrix( UINT iMesh, UINT iInfluence );\r
 507     UINT                            GetAnimationKeyFromTime( double fTime );\r
 508     const D3DXMATRIX*               GetWorldMatrix( UINT iFrameIndex );\r
 509     const D3DXMATRIX*               GetInfluenceMatrix( UINT iFrameIndex );\r
 510     bool                            GetAnimationProperties( UINT* pNumKeys, FLOAT* pFrameTime );\r
 511 };\r
 512 \r
 513 //-----------------------------------------------------------------------------\r
 514 // Name: class CDXUTXFileMesh\r
 515 // Desc: Class for loading and rendering file-based meshes\r
 516 //-----------------------------------------------------------------------------\r
 517 class CDXUTXFileMesh\r
 518 {\r
 519 public:\r
 520     WCHAR       m_strName[512];\r
 521     LPD3DXMESH m_pMesh;   // Managed mesh\r
 522 \r
 523     // Cache of data in m_pMesh for easy access\r
 524     IDirect3DVertexBuffer9* m_pVB;\r
 525     IDirect3DIndexBuffer9* m_pIB;\r
 526     IDirect3DVertexDeclaration9* m_pDecl;\r
 527     DWORD m_dwNumVertices;\r
 528     DWORD m_dwNumFaces;\r
 529     DWORD m_dwBytesPerVertex;\r
 530 \r
 531     DWORD m_dwNumMaterials; // Materials for the mesh\r
 532     D3DMATERIAL9* m_pMaterials;\r
 533     CHAR        (*m_strMaterials )[MAX_PATH];\r
 534     IDirect3DBaseTexture9** m_pTextures;\r
 535     bool m_bUseMaterials;\r
 536 \r
 537 public:\r
 538     // Rendering\r
 539     HRESULT     Render( LPDIRECT3DDEVICE9 pd3dDevice,\r
 540                         bool bDrawOpaqueSubsets = true,\r
 541                         bool bDrawAlphaSubsets = true );\r
 542     HRESULT     Render( ID3DXEffect* pEffect,\r
 543                         D3DXHANDLE hTexture = NULL,\r
 544                         D3DXHANDLE hDiffuse = NULL,\r
 545                         D3DXHANDLE hAmbient = NULL,\r
 546                         D3DXHANDLE hSpecular = NULL,\r
 547                         D3DXHANDLE hEmissive = NULL,\r
 548                         D3DXHANDLE hPower = NULL,\r
 549                         bool bDrawOpaqueSubsets = true,\r
 550                         bool bDrawAlphaSubsets = true );\r
 551 \r
 552     // Mesh access\r
 553     LPD3DXMESH  GetMesh()\r
 554     {\r
 555         return m_pMesh;\r
 556     }\r
 557 \r
 558     // Rendering options\r
 559     void        UseMeshMaterials( bool bFlag )\r
 560     {\r
 561         m_bUseMaterials = bFlag;\r
 562     }\r
 563     HRESULT     SetFVF( LPDIRECT3DDEVICE9 pd3dDevice, DWORD dwFVF );\r
 564     HRESULT     SetVertexDecl( LPDIRECT3DDEVICE9 pd3dDevice, const D3DVERTEXELEMENT9* pDecl,\r
 565                                bool bAutoComputeNormals = true, bool bAutoComputeTangents = true,\r
 566                                bool bSplitVertexForOptimalTangents = false );\r
 567 \r
 568     // Initializing\r
 569     HRESULT     RestoreDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice );\r
 570     HRESULT     InvalidateDeviceObjects();\r
 571 \r
 572     // Creation/destruction\r
 573     HRESULT     Create( LPDIRECT3DDEVICE9 pd3dDevice, LPCWSTR strFilename );\r
 574     HRESULT     Create( LPDIRECT3DDEVICE9 pd3dDevice, LPD3DXFILEDATA pFileData );\r
 575     HRESULT     Create( LPDIRECT3DDEVICE9 pd3dDevice, ID3DXMesh* pInMesh, D3DXMATERIAL* pd3dxMaterials,\r
 576                         DWORD dwMaterials );\r
 577     HRESULT     CreateMaterials( LPCWSTR strPath, IDirect3DDevice9* pd3dDevice, D3DXMATERIAL* d3dxMtrls,\r
 578                                  DWORD dwNumMaterials );\r
 579     HRESULT     Destroy();\r
 580 \r
 581                 CDXUTXFileMesh( LPCWSTR strName = L"CDXUTXMeshFile_Mesh" );\r
 582     virtual     ~CDXUTXFileMesh();\r
 583 };\r
 584 \r
 585 \r
 586 #endif\r
 587 \r
 588 #endif\r
 589 \r