开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
d3dfile.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：26k
源码类别：

游戏

开发平台：

Visual C++

d3dfile.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: D3DFile.cpp
  3. //
  4. // Desc: Support code for loading DirectX .X files.
  5. //
  6. // Copyright (c) Microsoft Corporation. All rights reserved.
  7. //-----------------------------------------------------------------------------
  8. #include "dxstdafx.h"
  9. #include <dxfile.h>
  10. #include <rmxfguid.h>
  11. #include <rmxftmpl.h>
  12. #include "D3DFile.h"
  17. //-----------------------------------------------------------------------------
  18. // Name:
  19. // Desc:
  20. //-----------------------------------------------------------------------------
  21. CD3DMesh::CD3DMesh( LPCTSTR strName )
  22. {
  23.     _tcsncpy( m_strName, strName, sizeof(m_strName) / sizeof(TCHAR) );
  24.     m_strName[sizeof(m_strName) / sizeof(TCHAR) - 1] = _T('');
  25.     m_pSysMemMesh        = NULL;
  26.     m_pLocalMesh         = NULL;
  27.     m_dwNumMaterials     = 0L;
  28.     m_pMaterials         = NULL;
  29.     m_pTextures          = NULL;
  30.     m_bUseMaterials      = TRUE;
  31. }
  36. //-----------------------------------------------------------------------------
  37. // Name:
  38. // Desc:
  39. //-----------------------------------------------------------------------------
  40. CD3DMesh::~CD3DMesh()
  41. {
  42.     Destroy();
  43. }
  48. //-----------------------------------------------------------------------------
  49. // Name:
  50. // Desc:
  51. //-----------------------------------------------------------------------------
  52. HRESULT CD3DMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice, LPCTSTR strFilename )
  53. {
  54.     TCHAR        strPath[MAX_PATH];
  55.     LPD3DXBUFFER pAdjacencyBuffer = NULL;
  56.     LPD3DXBUFFER pMtrlBuffer = NULL;
  57.     HRESULT      hr;
  59.     // Find the path for the file, and convert it to ANSI (for the D3DX API)
  60.     DXUtil_FindMediaFileCb( strPath, sizeof(strPath), strFilename );
  62.     // Load the mesh
  63.     if( FAILED( hr = D3DXLoadMeshFromX( strPath, D3DXMESH_SYSTEMMEM, pd3dDevice, 
  64.                                         &pAdjacencyBuffer, &pMtrlBuffer, NULL,
  65.                                         &m_dwNumMaterials, &m_pSysMemMesh ) ) )
  66.     {
  67.         return hr;
  68.     }
  70.     // Optimize the mesh for performance
  71.     if( FAILED( hr = m_pSysMemMesh->OptimizeInplace(
  72.                         D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
  73.                         (DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) )
  74.     {
  75.         SAFE_RELEASE( pAdjacencyBuffer );
  76.         SAFE_RELEASE( pMtrlBuffer );
  77.         return hr;
  78.     }
  80.     // Get material info for the mesh
  81.     // Get the array of materials out of the buffer
  82.     if( pMtrlBuffer && m_dwNumMaterials > 0 )
  83.     {
  84.         // Allocate memory for the materials and textures
  85.         D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
  86.         m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials];
  87.         if( m_pMaterials == NULL )
  88.         {
  89.             hr = E_OUTOFMEMORY;
  90.             goto LEnd;
  91.         }
  92.         m_pTextures  = new LPDIRECT3DTEXTURE9[m_dwNumMaterials];
  93.         if( m_pTextures == NULL )
  94.         {
  95.             hr = E_OUTOFMEMORY;
  96.             goto LEnd;
  97.         }
  99.         // Copy each material and create its texture
  100.         for( DWORD i=0; i<m_dwNumMaterials; i++ )
  101.         {
  102.             // Copy the material
  103.             m_pMaterials[i]         = d3dxMtrls[i].MatD3D;
  104.             m_pTextures[i]          = NULL;
  106.             // Create a texture
  107.             if( d3dxMtrls[i].pTextureFilename )
  108.             {
  109.                 TCHAR strTexture[MAX_PATH];
  110.                 TCHAR strTextureTemp[MAX_PATH];
  111.                 DXUtil_ConvertAnsiStringToGenericCb( strTextureTemp, d3dxMtrls[i].pTextureFilename, sizeof(strTextureTemp) );
  112.                 DXUtil_FindMediaFileCb( strTexture, sizeof(strTexture), strTextureTemp );
  114.                 if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexture, 
  115.                                                        &m_pTextures[i] ) ) )
  116.                     m_pTextures[i] = NULL;
  117.             }
  118.         }
  119.     }
  120.     hr = S_OK;
  122. LEnd:
  123.     SAFE_RELEASE( pAdjacencyBuffer );
  124.     SAFE_RELEASE( pMtrlBuffer );
  126.     return hr;
  127. }
  132. //-----------------------------------------------------------------------------
  133. // Name:
  134. // Desc:
  135. //-----------------------------------------------------------------------------
  136. HRESULT CD3DMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice,
  137.                           LPDIRECTXFILEDATA pFileData )
  138. {
  139.     LPD3DXBUFFER pMtrlBuffer = NULL;
  140.     LPD3DXBUFFER pAdjacencyBuffer = NULL;
  141.     HRESULT      hr;
  143.     // Load the mesh from the DXFILEDATA object
  144.     if( FAILED( hr = D3DXLoadMeshFromXof( pFileData, D3DXMESH_SYSTEMMEM, pd3dDevice,
  145.                                           &pAdjacencyBuffer, &pMtrlBuffer, NULL,
  146.                                           &m_dwNumMaterials, &m_pSysMemMesh ) ) )
  147.     {
  148.         return hr;
  149.     }
  151.     // Optimize the mesh for performance
  152.     if( FAILED( hr = m_pSysMemMesh->OptimizeInplace(
  153.                         D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
  154.                         (DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) )
  155.     {
  156.         SAFE_RELEASE( pAdjacencyBuffer );
  157.         SAFE_RELEASE( pMtrlBuffer );
  158.         return hr;
  159.     }
  161.     // Get material info for the mesh
  162.     // Get the array of materials out of the buffer
  163.     if( pMtrlBuffer && m_dwNumMaterials > 0 )
  164.     {
  165.         // Allocate memory for the materials and textures
  166.         D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
  167.         m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials];
  168.         if( m_pMaterials == NULL )
  169.         {
  170.             hr = E_OUTOFMEMORY;
  171.             goto LEnd;
  172.         }
  173.         m_pTextures  = new LPDIRECT3DTEXTURE9[m_dwNumMaterials];
  174.         if( m_pTextures == NULL )
  175.         {
  176.             hr = E_OUTOFMEMORY;
  177.             goto LEnd;
  178.         }
  180.         // Copy each material and create its texture
  181.         for( DWORD i=0; i<m_dwNumMaterials; i++ )
  182.         {
  183.             // Copy the material
  184.             m_pMaterials[i]         = d3dxMtrls[i].MatD3D;
  185.             m_pTextures[i]          = NULL;
  187.             // Create a texture
  188.             if( d3dxMtrls[i].pTextureFilename )
  189.             {
  190.                 TCHAR strTexture[MAX_PATH];
  191.                 TCHAR strTextureTemp[MAX_PATH];
  192.                 DXUtil_ConvertAnsiStringToGenericCb( strTextureTemp, d3dxMtrls[i].pTextureFilename, sizeof(strTextureTemp) );
  193.                 DXUtil_FindMediaFileCb( strTexture, sizeof(strTexture), strTextureTemp );
  195.                 if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexture, 
  196.                                                        &m_pTextures[i] ) ) )
  197.                     m_pTextures[i] = NULL;
  198.             }
  199.         }
  200.     }
  201.     hr = S_OK;
  203. LEnd:
  204.     SAFE_RELEASE( pAdjacencyBuffer );
  205.     SAFE_RELEASE( pMtrlBuffer );
  207.     return hr;
  208. }
  213. //-----------------------------------------------------------------------------
  214. // Name:
  215. // Desc:
  216. //-----------------------------------------------------------------------------
  217. HRESULT CD3DMesh::SetFVF( LPDIRECT3DDEVICE9 pd3dDevice, DWORD dwFVF )
  218. {
  219.     LPD3DXMESH pTempSysMemMesh = NULL;
  220.     LPD3DXMESH pTempLocalMesh  = NULL;
  222.     if( m_pSysMemMesh )
  223.     {
  224.         if( FAILED( m_pSysMemMesh->CloneMeshFVF( D3DXMESH_SYSTEMMEM, dwFVF,
  225.                                                  pd3dDevice, &pTempSysMemMesh ) ) )
  226.             return E_FAIL;
  227.     }
  228.     if( m_pLocalMesh )
  229.     {
  230.         if( FAILED( m_pLocalMesh->CloneMeshFVF( 0L, dwFVF, pd3dDevice,
  231.                                                 &pTempLocalMesh ) ) )
  232.         {
  233.             SAFE_RELEASE( pTempSysMemMesh );
  234.             return E_FAIL;
  235.         }
  236.     }
  238.     SAFE_RELEASE( m_pSysMemMesh );
  239.     SAFE_RELEASE( m_pLocalMesh );
  241.     if( pTempSysMemMesh ) m_pSysMemMesh = pTempSysMemMesh;
  242.     if( pTempLocalMesh )  m_pLocalMesh  = pTempLocalMesh;
  244.     // Compute normals in case the meshes have them
  245.     if( m_pSysMemMesh )
  246.         D3DXComputeNormals( m_pSysMemMesh, NULL );
  247.     if( m_pLocalMesh )
  248.         D3DXComputeNormals( m_pLocalMesh, NULL );
  250.     return S_OK;
  251. }
  256. //-----------------------------------------------------------------------------
  257. // Name: CD3DMesh::SetVertexDecl
  258. // Desc: Convert the mesh to the format specified by the given vertex
  259. //       declarations.
  260. //-----------------------------------------------------------------------------
  261. HRESULT CD3DMesh::SetVertexDecl( LPDIRECT3DDEVICE9 pd3dDevice, D3DVERTEXELEMENT9 *pDecl )
  262. {
  263.     LPD3DXMESH pTempSysMemMesh = NULL;
  264.     LPD3DXMESH pTempLocalMesh  = NULL;
  266.     if( m_pSysMemMesh )
  267.     {
  268.         if( FAILED( m_pSysMemMesh->CloneMesh( D3DXMESH_SYSTEMMEM, pDecl,
  269.                                               pd3dDevice, &pTempSysMemMesh ) ) )
  270.             return E_FAIL;
  271.     }
  273.     if( m_pLocalMesh )
  274.     {
  275.         if( FAILED( m_pLocalMesh->CloneMesh( 0L, pDecl, pd3dDevice,
  276.                                              &pTempLocalMesh ) ) )
  277.         {
  278.             SAFE_RELEASE( pTempSysMemMesh );
  279.             return E_FAIL;
  280.         }
  281.     }
  283.     SAFE_RELEASE( m_pSysMemMesh );
  284.     SAFE_RELEASE( m_pLocalMesh );
  286.     if( pTempSysMemMesh )
  287.     {
  288.         m_pSysMemMesh = pTempSysMemMesh;
  289.         // Compute normals in case the meshes have them
  290.         D3DXComputeNormals( m_pSysMemMesh, NULL );
  291.     }
  293.     if( pTempLocalMesh )
  294.     {
  295.         m_pLocalMesh = pTempLocalMesh;
  296.         // Compute normals in case the meshes have them
  297.         D3DXComputeNormals( m_pLocalMesh, NULL );
  298.     }
  300.     return S_OK;
  301. }
  306. //-----------------------------------------------------------------------------
  307. // Name:
  308. // Desc:
  309. //-----------------------------------------------------------------------------
  310. HRESULT CD3DMesh::RestoreDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice )
  311. {
  312.     if( NULL == m_pSysMemMesh )
  313.         return E_FAIL;
  315.     // Make a local memory version of the mesh. Note: because we are passing in
  316.     // no flags, the default behavior is to clone into local memory.
  317.     if( FAILED( m_pSysMemMesh->CloneMeshFVF( D3DXMESH_MANAGED, m_pSysMemMesh->GetFVF(),
  318.                                              pd3dDevice, &m_pLocalMesh ) ) )
  319.         return E_FAIL;
  321.     return S_OK;
  323. }
  328. //-----------------------------------------------------------------------------
  329. // Name:
  330. // Desc:
  331. //-----------------------------------------------------------------------------
  332. HRESULT CD3DMesh::InvalidateDeviceObjects()
  333. {
  334.     SAFE_RELEASE( m_pLocalMesh );
  336.     return S_OK;
  337. }
  342. //-----------------------------------------------------------------------------
  343. // Name:
  344. // Desc:
  345. //-----------------------------------------------------------------------------
  346. HRESULT CD3DMesh::Destroy()
  347. {
  348.     InvalidateDeviceObjects();
  349.     for( UINT i=0; i<m_dwNumMaterials; i++ )
  350.         SAFE_RELEASE( m_pTextures[i] );
  351.     SAFE_DELETE_ARRAY( m_pTextures );
  352.     SAFE_DELETE_ARRAY( m_pMaterials );
  354.     SAFE_RELEASE( m_pSysMemMesh );
  356.     m_dwNumMaterials = 0L;
  358.     return S_OK;
  359. }
  364. //-----------------------------------------------------------------------------
  365. // Name:
  366. // Desc:
  367. //-----------------------------------------------------------------------------
  368. HRESULT CD3DMesh::Render( LPDIRECT3DDEVICE9 pd3dDevice, bool bDrawOpaqueSubsets,
  369.                           bool bDrawAlphaSubsets )
  370. {
  371.     if( NULL == m_pLocalMesh )
  372.         return E_FAIL;
  374.     // Frist, draw the subsets without alpha
  375.     if( bDrawOpaqueSubsets )
  376.     {
  377.         for( DWORD i=0; i<m_dwNumMaterials; i++ )
  378.         {
  379.             if( m_bUseMaterials )
  380.             {
  381.                 if( m_pMaterials[i].Diffuse.a < 1.0f )
  382.                     continue;
  383.                 pd3dDevice->SetMaterial( &m_pMaterials[i] );
  384.                 pd3dDevice->SetTexture( 0, m_pTextures[i] );
  385.             }
  386.             m_pLocalMesh->DrawSubset( i );
  387.         }
  388.     }
  390.     // Then, draw the subsets with alpha
  391.     if( bDrawAlphaSubsets && m_bUseMaterials )
  392.     {
  393.         for( DWORD i=0; i<m_dwNumMaterials; i++ )
  394.         {
  395.             if( m_pMaterials[i].Diffuse.a == 1.0f )
  396.                 continue;
  398.             // Set the material and texture
  399.             pd3dDevice->SetMaterial( &m_pMaterials[i] );
  400.             pd3dDevice->SetTexture( 0, m_pTextures[i] );
  401.             m_pLocalMesh->DrawSubset( i );
  402.         }
  403.     }
  405.     return S_OK;
  406. }
  411. //-----------------------------------------------------------------------------
  412. // Name:
  413. // Desc:
  414. //-----------------------------------------------------------------------------
  415. CD3DFrame::CD3DFrame( LPCTSTR strName )
  416. {
  417.     _tcsncpy( m_strName, strName, sizeof(m_strName) / sizeof(TCHAR) );
  418.     m_strName[sizeof(m_strName) / sizeof(TCHAR) - 1] = _T('');
  419.     D3DXMatrixIdentity( &m_mat );
  420.     m_pMesh  = NULL;
  422.     m_pChild = NULL;
  423.     m_pNext  = NULL;
  424. }
  429. //-----------------------------------------------------------------------------
  430. // Name:
  431. // Desc:
  432. //-----------------------------------------------------------------------------
  433. CD3DFrame::~CD3DFrame()
  434. {
  435.     SAFE_DELETE( m_pChild );
  436.     SAFE_DELETE( m_pNext );
  437. }
  442. //-----------------------------------------------------------------------------
  443. // Name:
  444. // Desc:
  445. //-----------------------------------------------------------------------------
  446. bool CD3DFrame::EnumMeshes( bool (*EnumMeshCB)(CD3DMesh*,void*),
  447.                             void* pContext )
  448. {
  449.     if( m_pMesh )
  450.         EnumMeshCB( m_pMesh, pContext );
  451.     if( m_pChild )
  452.         m_pChild->EnumMeshes( EnumMeshCB, pContext );
  453.     if( m_pNext )
  454.         m_pNext->EnumMeshes( EnumMeshCB, pContext );
  456.     return TRUE;
  457. }
  462. //-----------------------------------------------------------------------------
  463. // Name:
  464. // Desc:
  465. //-----------------------------------------------------------------------------
  466. CD3DMesh* CD3DFrame::FindMesh( LPCTSTR strMeshName )
  467. {
  468.     CD3DMesh* pMesh;
  470.     if( m_pMesh )
  471.         if( !lstrcmpi( m_pMesh->m_strName, strMeshName ) )
  472.             return m_pMesh;
  474.     if( m_pChild )
  475.         if( NULL != ( pMesh = m_pChild->FindMesh( strMeshName ) ) )
  476.             return pMesh;
  478.     if( m_pNext )
  479.         if( NULL != ( pMesh = m_pNext->FindMesh( strMeshName ) ) )
  480.             return pMesh;
  482.     return NULL;
  483. }
  488. //-----------------------------------------------------------------------------
  489. // Name:
  490. // Desc:
  491. //-----------------------------------------------------------------------------
  492. CD3DFrame* CD3DFrame::FindFrame( LPCTSTR strFrameName )
  493. {
  494.     CD3DFrame* pFrame;
  496.     if( !lstrcmpi( m_strName, strFrameName ) )
  497.         return this;
  499.     if( m_pChild )
  500.         if( NULL != ( pFrame = m_pChild->FindFrame( strFrameName ) ) )
  501.             return pFrame;
  503.     if( m_pNext )
  504.         if( NULL != ( pFrame = m_pNext->FindFrame( strFrameName ) ) )
  505.             return pFrame;
  507.     return NULL;
  508. }
  513. //-----------------------------------------------------------------------------
  514. // Name:
  515. // Desc:
  516. //-----------------------------------------------------------------------------
  517. HRESULT CD3DFrame::Destroy()
  518. {
  519.     if( m_pMesh )  m_pMesh->Destroy();
  520.     if( m_pChild ) m_pChild->Destroy();
  521.     if( m_pNext )  m_pNext->Destroy();
  523.     SAFE_DELETE( m_pMesh );
  524.     SAFE_DELETE( m_pNext );
  525.     SAFE_DELETE( m_pChild );
  527.     return S_OK;
  528. }
  533. //-----------------------------------------------------------------------------
  534. // Name:
  535. // Desc:
  536. //-----------------------------------------------------------------------------
  537. HRESULT CD3DFrame::RestoreDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice )
  538. {
  539.     if( m_pMesh )  m_pMesh->RestoreDeviceObjects( pd3dDevice );
  540.     if( m_pChild ) m_pChild->RestoreDeviceObjects( pd3dDevice );
  541.     if( m_pNext )  m_pNext->RestoreDeviceObjects( pd3dDevice );
  542.     return S_OK;
  543. }
  548. //-----------------------------------------------------------------------------
  549. // Name:
  550. // Desc:
  551. //-----------------------------------------------------------------------------
  552. HRESULT CD3DFrame::InvalidateDeviceObjects()
  553. {
  554.     if( m_pMesh )  m_pMesh->InvalidateDeviceObjects();
  555.     if( m_pChild ) m_pChild->InvalidateDeviceObjects();
  556.     if( m_pNext )  m_pNext->InvalidateDeviceObjects();
  557.     return S_OK;
  558. }
  563. //-----------------------------------------------------------------------------
  564. // Name:
  565. // Desc:
  566. //-----------------------------------------------------------------------------
  567. HRESULT CD3DFrame::Render( LPDIRECT3DDEVICE9 pd3dDevice, bool bDrawOpaqueSubsets,
  568.                            bool bDrawAlphaSubsets, D3DXMATRIX* pmatWorldMatrix )
  569. {
  570.     // For pure devices, specify the world transform. If the world transform is not
  571.     // specified on pure devices, this function will fail.
  573.     D3DXMATRIXA16 matSavedWorld, matWorld;
  575.     if ( NULL == pmatWorldMatrix )
  576.         pd3dDevice->GetTransform( D3DTS_WORLD, &matSavedWorld );
  577.     else
  578.         matSavedWorld = *pmatWorldMatrix;
  580.     D3DXMatrixMultiply( &matWorld, &m_mat, &matSavedWorld );
  581.     pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
  583.     if( m_pMesh )
  584.         m_pMesh->Render( pd3dDevice, bDrawOpaqueSubsets, bDrawAlphaSubsets );
  586.     if( m_pChild )
  587.         m_pChild->Render( pd3dDevice, bDrawOpaqueSubsets, bDrawAlphaSubsets, &matWorld );
  589.     pd3dDevice->SetTransform( D3DTS_WORLD, &matSavedWorld );
  591.     if( m_pNext )
  592.         m_pNext->Render( pd3dDevice, bDrawOpaqueSubsets, bDrawAlphaSubsets, &matSavedWorld );
  594.     return S_OK;
  595. }
  600. //-----------------------------------------------------------------------------
  601. // Name:
  602. // Desc:
  603. //-----------------------------------------------------------------------------
  604. HRESULT CD3DFile::LoadFrame( LPDIRECT3DDEVICE9 pd3dDevice,
  605.                              LPDIRECTXFILEDATA pFileData,
  606.                              CD3DFrame* pParentFrame )
  607. {
  608.     LPDIRECTXFILEDATA   pChildData = NULL;
  609.     LPDIRECTXFILEOBJECT pChildObj = NULL;
  610.     const GUID* pGUID;
  611.     DWORD       cbSize;
  612.     CD3DFrame*  pCurrentFrame;
  613.     HRESULT     hr;
  615.     // Get the type of the object
  616.     if( FAILED( hr = pFileData->GetType( &pGUID ) ) )
  617.         return hr;
  619.     if( *pGUID == TID_D3DRMMesh )
  620.     {
  621.         hr = LoadMesh( pd3dDevice, pFileData, pParentFrame );
  622.         if( FAILED(hr) )
  623.             return hr;
  624.     }
  625.     if( *pGUID == TID_D3DRMFrameTransformMatrix )
  626.     {
  627.         D3DXMATRIX* pmatMatrix;
  628.         hr = pFileData->GetData( NULL, &cbSize, (void**)&pmatMatrix );
  629.         if( FAILED(hr) )
  630.             return hr;
  632.         // Update the parent's matrix with the new one
  633.         pParentFrame->SetMatrix( pmatMatrix );
  634.     }
  635.     if( *pGUID == TID_D3DRMFrame )
  636.     {
  637.         // Get the frame name
  638.         CHAR  strAnsiName[512] = "";
  639.         TCHAR strName[512];
  640.         DWORD dwNameLength = 512;
  641.         if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
  642.             return hr;
  643.         DXUtil_ConvertAnsiStringToGenericCb( strName, strAnsiName, sizeof(strName) );
  645.         // Create the frame
  646.         pCurrentFrame = new CD3DFrame( strName );
  647.         if( pCurrentFrame == NULL )
  648.             return E_OUTOFMEMORY;
  650.         pCurrentFrame->m_pNext = pParentFrame->m_pChild;
  651.         pParentFrame->m_pChild = pCurrentFrame;
  653.         // Enumerate child objects
  654.         while( SUCCEEDED( pFileData->GetNextObject( &pChildObj ) ) )
  655.         {
  656.             // Query the child for its FileData
  657.             hr = pChildObj->QueryInterface( IID_IDirectXFileData,
  658.                                             (void**)&pChildData );
  659.             if( SUCCEEDED(hr) )
  660.             {
  661.                 hr = LoadFrame( pd3dDevice, pChildData, pCurrentFrame );
  662.                 pChildData->Release();
  663.             }
  665.             pChildObj->Release();
  667.             if( FAILED(hr) )
  668.                 return hr;
  669.         }
  670.     }
  672.     return S_OK;
  673. }
  678. //-----------------------------------------------------------------------------
  679. // Name:
  680. // Desc:
  681. //-----------------------------------------------------------------------------
  682. HRESULT CD3DFile::LoadMesh( LPDIRECT3DDEVICE9 pd3dDevice,
  683.                             LPDIRECTXFILEDATA pFileData,
  684.                             CD3DFrame* pParentFrame )
  685. {
  686.     // Currently only allowing one mesh per frame
  687.     if( pParentFrame->m_pMesh )
  688.         return E_FAIL;
  690.     // Get the mesh name
  691.     CHAR  strAnsiName[512] = {0};
  692.     TCHAR strName[512];
  693.     DWORD dwNameLength = 512;
  694.     HRESULT hr;
  695.     if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
  696.         return hr;
  697.     DXUtil_ConvertAnsiStringToGenericCb( strName, strAnsiName, sizeof(strName) );
  699.     // Create the mesh
  700.     pParentFrame->m_pMesh = new CD3DMesh( strName );
  701.     if( pParentFrame->m_pMesh == NULL )
  702.         return E_OUTOFMEMORY;
  703.     pParentFrame->m_pMesh->Create( pd3dDevice, pFileData );
  705.     return S_OK;
  706. }
  711. //-----------------------------------------------------------------------------
  712. // Name:
  713. // Desc:
  714. //-----------------------------------------------------------------------------
  715. HRESULT CD3DFile::CreateFromResource( LPDIRECT3DDEVICE9 pd3dDevice, LPCTSTR strResource, LPCTSTR strType )
  716. {
  717.     LPDIRECTXFILE           pDXFile   = NULL;
  718.     LPDIRECTXFILEENUMOBJECT pEnumObj  = NULL;
  719.     LPDIRECTXFILEDATA       pFileData = NULL;
  720.     HRESULT hr;
  722.     // Create a x file object
  723.     if( FAILED( hr = DirectXFileCreate( &pDXFile ) ) )
  724.         return E_FAIL;
  726.     // Register templates for d3drm and patch extensions.
  727.     if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
  728.                                                  D3DRM_XTEMPLATE_BYTES ) ) )
  729.     {
  730.         pDXFile->Release();
  731.         return E_FAIL;
  732.     }
  733.     
  734.     CHAR strTypeAnsi[MAX_PATH];
  735.     DXUtil_ConvertGenericStringToAnsiCb( strTypeAnsi, strType, sizeof(strTypeAnsi) );
  737.     DXFILELOADRESOURCE dxlr;
  738.     dxlr.hModule = NULL;
  739.     dxlr.lpName = strResource;
  740.     dxlr.lpType = (TCHAR*) strTypeAnsi;
  742.     // Create enum object
  743.     hr = pDXFile->CreateEnumObject( (void*)&dxlr, DXFILELOAD_FROMRESOURCE, 
  744.                                     &pEnumObj );
  745.     if( FAILED(hr) )
  746.     {
  747.         pDXFile->Release();
  748.         return hr;
  749.     }
  751.     // Enumerate top level objects (which are always frames)
  752.     while( SUCCEEDED( pEnumObj->GetNextDataObject( &pFileData ) ) )
  753.     {
  754.         hr = LoadFrame( pd3dDevice, pFileData, this );
  755.         pFileData->Release();
  756.         if( FAILED(hr) )
  757.         {
  758.             pEnumObj->Release();
  759.             pDXFile->Release();
  760.             return E_FAIL;
  761.         }
  762.     }
  764.     SAFE_RELEASE( pFileData );
  765.     SAFE_RELEASE( pEnumObj );
  766.     SAFE_RELEASE( pDXFile );
  768.     return S_OK;
  769. }
  774. //-----------------------------------------------------------------------------
  775. // Name:
  776. // Desc:
  777. //-----------------------------------------------------------------------------
  778. HRESULT CD3DFile::Create( LPDIRECT3DDEVICE9 pd3dDevice, LPCTSTR strFilename )
  779. {
  780.     LPDIRECTXFILE           pDXFile   = NULL;
  781.     LPDIRECTXFILEENUMOBJECT pEnumObj  = NULL;
  782.     LPDIRECTXFILEDATA       pFileData = NULL;
  783.     HRESULT hr;
  785.     // Create a x file object
  786.     if( FAILED( hr = DirectXFileCreate( &pDXFile ) ) )
  787.         return E_FAIL;
  789.     // Register templates for d3drm and patch extensions.
  790.     if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
  791.                                                  D3DRM_XTEMPLATE_BYTES ) ) )
  792.     {
  793.         pDXFile->Release();
  794.         return E_FAIL;
  795.     }
  797.     // Find the path to the file, and convert it to ANSI (for the D3DXOF API)
  798.     TCHAR strPath[MAX_PATH];
  799.     CHAR  strPathANSI[MAX_PATH];
  800.     DXUtil_FindMediaFileCb( strPath, sizeof(strPath), strFilename );
  801.     DXUtil_ConvertGenericStringToAnsiCb( strPathANSI, strPath, sizeof(strPathANSI) );
  802.     
  803.     // Create enum object
  804.     hr = pDXFile->CreateEnumObject( (void*)strPathANSI, DXFILELOAD_FROMFILE, 
  805.                                     &pEnumObj );
  806.     if( FAILED(hr) )
  807.     {
  808.         pDXFile->Release();
  809.         return hr;
  810.     }
  812.     // Enumerate top level objects (which are always frames)
  813.     while( SUCCEEDED( pEnumObj->GetNextDataObject( &pFileData ) ) )
  814.     {
  815.         hr = LoadFrame( pd3dDevice, pFileData, this );
  816.         pFileData->Release();
  817.         if( FAILED(hr) )
  818.         {
  819.             pEnumObj->Release();
  820.             pDXFile->Release();
  821.             return E_FAIL;
  822.         }
  823.     }
  825.     SAFE_RELEASE( pFileData );
  826.     SAFE_RELEASE( pEnumObj );
  827.     SAFE_RELEASE( pDXFile );
  829.     return S_OK;
  830. }
  835. //-----------------------------------------------------------------------------
  836. // Name:
  837. // Desc:
  838. //-----------------------------------------------------------------------------
  839. HRESULT CD3DFile::Render( LPDIRECT3DDEVICE9 pd3dDevice, D3DXMATRIX* pmatWorldMatrix )
  840. {
  842.     // For pure devices, specify the world transform. If the world transform is not
  843.     // specified on pure devices, this function will fail.
  845.     // Set up the world transformation
  846.     D3DXMATRIX matSavedWorld, matWorld;
  848.     if ( NULL == pmatWorldMatrix )
  849.         pd3dDevice->GetTransform( D3DTS_WORLD, &matSavedWorld );
  850.     else
  851.         matSavedWorld = *pmatWorldMatrix;
  853.     D3DXMatrixMultiply( &matWorld, &matSavedWorld, &m_mat );
  854.     pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
  856.     // Render opaque subsets in the meshes
  857.     if( m_pChild )
  858.         m_pChild->Render( pd3dDevice, TRUE, FALSE, &matWorld );
  860.     // Enable alpha blending
  861.     pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
  862.     pd3dDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
  863.     pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
  865.     // Render alpha subsets in the meshes
  866.     if( m_pChild )
  867.         m_pChild->Render( pd3dDevice, FALSE, TRUE, &matWorld );
  869.     // Restore state
  870.     pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
  871.     pd3dDevice->SetTransform( D3DTS_WORLD, &matSavedWorld );
  873.     return S_OK;
  874. }