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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
d3dfile.cpp
资源名称：estereo2.zip　[点击查看]
上传用户：fengshi120
上传日期：2014-07-17
资源大小：6155k
文件大小：26k
源码类别：

3D图形编程

开发平台：

C/C++

d3dfile.cpp：源码内容
  1. //-----------------------------------------------------------------------------
  2. // File: D3DFile.cpp
  3. //
  4. // Desc: Support code for loading DirectX .X files.
  5. //-----------------------------------------------------------------------------
  6. #define STRICT
  7. #include "stdafx.h"
  8. #include <tchar.h>
  9. #include <stdio.h>
  10. #include <d3d9.h>
  11. #include <d3dx9.h>
  12. #include <dxfile.h>
  13. #include <rmxfguid.h>
  14. #include <rmxftmpl.h>
  15. #include "D3DFile.h"
  16. #include "DXUtil.h"
  21. //-----------------------------------------------------------------------------
  22. // Name:
  23. // Desc:
  24. //-----------------------------------------------------------------------------
  25. CD3DMesh::CD3DMesh( TCHAR* strName )
  26. {
  27.     _tcsncpy( m_strName, strName, sizeof(m_strName) / sizeof(TCHAR) );
  28.     m_strName[sizeof(m_strName) / sizeof(TCHAR) - 1] = _T('');
  29.     m_pSysMemMesh        = NULL;
  30.     m_pLocalMesh         = NULL;
  31.     m_dwNumMaterials     = 0L;
  32.     m_pMaterials         = NULL;
  33.     m_pTextures          = NULL;
  34.     m_bUseMaterials      = FALSE;
  35. }
  40. //-----------------------------------------------------------------------------
  41. // Name:
  42. // Desc:
  43. //-----------------------------------------------------------------------------
  44. CD3DMesh::~CD3DMesh()
  45. {
  46.     Destroy();
  47. }
  51. //-----------------------------------------------------------------------------
  52. // Name:
  53. // Desc:
  54. //-----------------------------------------------------------------------------
  55. HRESULT CD3DMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice, TCHAR* strFilename,float fAlpha)
  56. {
  57.     TCHAR        strPath[MAX_PATH];
  58.     LPD3DXBUFFER pAdjacencyBuffer = NULL;
  59.     LPD3DXBUFFER pMtrlBuffer = NULL;
  60.     HRESULT      hr;
  62.     // Find the path for the file, and convert it to ANSI (for the D3DX API)
  63.     DXUtil_FindMediaFileCb( strPath, sizeof(strPath), strFilename );
  65.     // Load the mesh
  66.     if( FAILED( hr = D3DXLoadMeshFromX( strPath, D3DXMESH_SYSTEMMEM, pd3dDevice, 
  67.                                         &pAdjacencyBuffer, &pMtrlBuffer, NULL,
  68.                                         &m_dwNumMaterials, &m_pSysMemMesh ) ) )
  69.     {
  70.         return hr;
  71.     }
  73. if(m_pSysMemMesh == NULL)
  74. {
  75. return E_OUTOFMEMORY;
  76. }
  77.     // Optimize the mesh for performance
  78.     if( FAILED( hr = m_pSysMemMesh->OptimizeInplace(
  79.                         D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
  80.                         (DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) )
  81.     {
  82.         SAFE_RELEASE( pAdjacencyBuffer );
  83.         SAFE_RELEASE( pMtrlBuffer );
  84.         return hr;
  85.     }
  87.     // Get material info for the mesh
  88.     // Get the array of materials out of the buffer
  89.     if( pMtrlBuffer && m_dwNumMaterials > 0 )
  90.     {
  91.         // Allocate memory for the materials and textures
  92.         D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
  93.         m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials];
  94.         if( m_pMaterials == NULL )
  95.         {
  96.             hr = E_OUTOFMEMORY;
  97.             goto LEnd;
  98.         }
  99.         m_pTextures  = new LPDIRECT3DTEXTURE9[m_dwNumMaterials];
  100.         if( m_pTextures == NULL )
  101.         {
  102.             hr = E_OUTOFMEMORY;
  103.             goto LEnd;
  104.         }
  106.         // Copy each material and create its texture
  107.         for( DWORD i=0; i<m_dwNumMaterials; i++ )
  108.         {
  109.             // Copy the material
  110. d3dxMtrls[i].MatD3D.Diffuse.a = fAlpha;
  111. d3dxMtrls[i].MatD3D.Specular.a = fAlpha;
  112. d3dxMtrls[i].MatD3D.Emissive.a = fAlpha;
  113.             m_pMaterials[i]         = d3dxMtrls[i].MatD3D;
  114.             m_pTextures[i]          = NULL;
  116.             // Create a texture
  117.             if( d3dxMtrls[i].pTextureFilename )
  118.             {
  119.                 TCHAR strTexture[MAX_PATH];
  120.                 TCHAR strTextureTemp[MAX_PATH];
  121.                 DXUtil_ConvertAnsiStringToGenericCb( strTextureTemp, d3dxMtrls[i].pTextureFilename, sizeof(strTextureTemp) );
  122.                 DXUtil_FindMediaFileCb( strTexture, sizeof(strTexture), strTextureTemp );
  124.                 if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexture, 
  125.                                                        &m_pTextures[i] ) ) )
  126.                     m_pTextures[i] = NULL;
  127.             }
  128.         }
  129.     }
  130.     hr = S_OK;
  132. LEnd:
  133.     SAFE_RELEASE( pAdjacencyBuffer );
  134.     SAFE_RELEASE( pMtrlBuffer );
  136.     return hr;
  137. }
  139. /*
  142. //-----------------------------------------------------------------------------
  143. // Name:
  144. // Desc:
  145. //-----------------------------------------------------------------------------
  146. //HRESULT CD3DMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice,
  147. //                          LPDIRECTXFILEDATA pFileData )
  148. HRESULT CD3DMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice,
  149.                           LPD3DXFILEDATA pFileData )
  150. {
  151.     LPD3DXBUFFER pMtrlBuffer = NULL;
  152.     LPD3DXBUFFER pAdjacencyBuffer = NULL;
  153.     HRESULT      hr;
  155.     // Load the mesh from the DXFILEDATA object
  156.     if( FAILED( hr = D3DXLoadMeshFromXof( pFileData, D3DXMESH_SYSTEMMEM, pd3dDevice,
  157.                                           &pAdjacencyBuffer, &pMtrlBuffer, NULL,
  158.                                           &m_dwNumMaterials, &m_pSysMemMesh ) ) )
  159.     {
  160.         return hr;
  161.     }
  163.     // Optimize the mesh for performance
  164.     if( FAILED( hr = m_pSysMemMesh->OptimizeInplace(
  165.                         D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE,
  166.                         (DWORD*)pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) )
  167.     {
  168.         SAFE_RELEASE( pAdjacencyBuffer );
  169.         SAFE_RELEASE( pMtrlBuffer );
  170.         return hr;
  171.     }
  173.     // Get material info for the mesh
  174.     // Get the array of materials out of the buffer
  175.     if( pMtrlBuffer && m_dwNumMaterials > 0 )
  176.     {
  177.         // Allocate memory for the materials and textures
  178.         D3DXMATERIAL* d3dxMtrls = (D3DXMATERIAL*)pMtrlBuffer->GetBufferPointer();
  179.         m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials];
  180.         if( m_pMaterials == NULL )
  181.         {
  182.             hr = E_OUTOFMEMORY;
  183.             goto LEnd;
  184.         }
  185.         m_pTextures  = new LPDIRECT3DTEXTURE9[m_dwNumMaterials];
  186.         if( m_pTextures == NULL )
  187.         {
  188.             hr = E_OUTOFMEMORY;
  189.             goto LEnd;
  190.         }
  192.         // Copy each material and create its texture
  193.         for( DWORD i=0; i<m_dwNumMaterials; i++ )
  194.         {
  195.             // Copy the material
  196.             m_pMaterials[i]         = d3dxMtrls[i].MatD3D;
  197.             m_pTextures[i]          = NULL;
  199.             // Create a texture
  200.             if( d3dxMtrls[i].pTextureFilename )
  201.             {
  202.                 TCHAR strTexture[MAX_PATH];
  203.                 TCHAR strTextureTemp[MAX_PATH];
  204.                 DXUtil_ConvertAnsiStringToGenericCb( strTextureTemp, d3dxMtrls[i].pTextureFilename, sizeof(strTextureTemp) );
  205.                 DXUtil_FindMediaFileCb( strTexture, sizeof(strTexture), strTextureTemp );
  207.                 if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexture, 
  208.                                                        &m_pTextures[i] ) ) )
  209.                     m_pTextures[i] = NULL;
  210.             }
  211.         }
  212.     }
  213.     hr = S_OK;
  215. LEnd:
  216.     SAFE_RELEASE( pAdjacencyBuffer );
  217.     SAFE_RELEASE( pMtrlBuffer );
  219.     return hr;
  220. }
  223. */
  225. //-----------------------------------------------------------------------------
  226. // Name:
  227. // Desc:
  228. //-----------------------------------------------------------------------------
  229. HRESULT CD3DMesh::SetFVF( LPDIRECT3DDEVICE9 pd3dDevice, DWORD dwFVF )
  230. {
  231.     LPD3DXMESH pTempSysMemMesh = NULL;
  232.     LPD3DXMESH pTempLocalMesh  = NULL;
  234.     if( m_pSysMemMesh )
  235.     {
  236.         if( FAILED( m_pSysMemMesh->CloneMeshFVF( D3DXMESH_32BIT | D3DXMESH_SYSTEMMEM, dwFVF,
  237.                                                  pd3dDevice, &pTempSysMemMesh ) ) )
  238.             return E_FAIL;
  239.     }
  240.     if( m_pLocalMesh )
  241.     {
  242.         if( FAILED( m_pLocalMesh->CloneMeshFVF( D3DXMESH_32BIT, dwFVF, pd3dDevice,
  243.                                                 &pTempLocalMesh ) ) )
  244.         {
  245.             SAFE_RELEASE( pTempSysMemMesh );
  246.             return E_FAIL;
  247.         }
  248.     }
  250.     SAFE_RELEASE( m_pSysMemMesh );
  251.     SAFE_RELEASE( m_pLocalMesh );
  253.     if( pTempSysMemMesh ) m_pSysMemMesh = pTempSysMemMesh;
  254.     if( pTempLocalMesh )  m_pLocalMesh  = pTempLocalMesh;
  256.     // Compute normals in case the meshes have them
  257.     if( m_pSysMemMesh )
  258.         D3DXComputeNormals( m_pSysMemMesh, NULL );
  259.     if( m_pLocalMesh )
  260.         D3DXComputeNormals( m_pLocalMesh, NULL );
  262.     return S_OK;
  263. }
  268. //-----------------------------------------------------------------------------
  269. // Name:
  270. // Desc:
  271. //-----------------------------------------------------------------------------
  272. HRESULT CD3DMesh::RestoreDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice )
  273. {
  274.     if( NULL == m_pSysMemMesh )
  275.         return E_FAIL;
  277.     // Make a local memory version of the mesh. Note: because we are passing in
  278.     // no flags, the default behavior is to clone into local memory.
  279.     if( FAILED( m_pSysMemMesh->CloneMeshFVF( D3DXMESH_32BIT, m_pSysMemMesh->GetFVF(),
  280.                                              pd3dDevice, &m_pLocalMesh ) ) )
  281.         return E_FAIL;
  283.     return S_OK;
  285. }
  290. //-----------------------------------------------------------------------------
  291. // Name:
  292. // Desc:
  293. //-----------------------------------------------------------------------------
  294. HRESULT CD3DMesh::InvalidateDeviceObjects()
  295. {
  296.     SAFE_RELEASE( m_pLocalMesh );
  298.     return S_OK;
  299. }
  304. //-----------------------------------------------------------------------------
  305. // Name:
  306. // Desc:
  307. //-----------------------------------------------------------------------------
  308. HRESULT CD3DMesh::Destroy()
  309. {
  310.     InvalidateDeviceObjects();
  311.     if(m_pTextures != NULL)
  312. {
  313. for( UINT i=0; i<m_dwNumMaterials; i++ )
  314.        SAFE_RELEASE( m_pTextures[i] );
  315. }
  316.     SAFE_DELETE_ARRAY( m_pTextures );
  317.     SAFE_DELETE_ARRAY( m_pMaterials );
  319.     SAFE_RELEASE( m_pSysMemMesh );
  321.     m_dwNumMaterials = 0L;
  323.     return S_OK;
  324. }
  329. //-----------------------------------------------------------------------------
  330. // Name:
  331. // Desc:
  332. //-----------------------------------------------------------------------------
  333. HRESULT CD3DMesh::Render( LPDIRECT3DDEVICE9 pd3dDevice, bool bDrawOpaqueSubsets,
  334.                           bool bDrawAlphaSubsets,int iSelectedSubset )
  335. {
  336.     if( NULL == m_pLocalMesh )
  337.         return E_FAIL;
  339. if(iSelectedSubset != -1)
  340. {
  341.     // Frist, draw the subsets without alpha
  342. if( bDrawOpaqueSubsets )
  343. {
  344.             if( m_bUseMaterials )
  345.             {
  346.                 if( m_pMaterials[iSelectedSubset].Diffuse.a == 1.0f )
  347. {
  348. pd3dDevice->SetMaterial( &m_pMaterials[iSelectedSubset] );
  349. pd3dDevice->SetTexture( 0, m_pTextures[iSelectedSubset] );
  350. m_pLocalMesh->DrawSubset( iSelectedSubset );
  351. }
  352. }
  353. else 
  354. m_pLocalMesh->DrawSubset( iSelectedSubset );
  355.         }
  357. // Then, draw the subsets with alpha
  358. if( bDrawAlphaSubsets && m_bUseMaterials )
  359. {
  360. if( m_pMaterials[iSelectedSubset].Diffuse.a < 1.0f )
  361. {
  362. // Set the material and texture
  363. pd3dDevice->SetMaterial( &m_pMaterials[iSelectedSubset] );
  364. pd3dDevice->SetTexture( 0, m_pTextures[iSelectedSubset] );
  365. m_pLocalMesh->DrawSubset( iSelectedSubset );
  366. }
  367. }
  369. return S_OK;
  370. }
  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. }
  408. /*
  411. //-----------------------------------------------------------------------------
  412. // Name:
  413. // Desc:
  414. //-----------------------------------------------------------------------------
  415. CD3DFrame::CD3DFrame( TCHAR* 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. }
  459. */
  461. /*
  462. //-----------------------------------------------------------------------------
  463. // Name:
  464. // Desc:
  465. //-----------------------------------------------------------------------------
  466. CD3DMesh* CD3DFrame::FindMesh( TCHAR* 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. }
  486. */
  487. /*
  488. //-----------------------------------------------------------------------------
  489. // Name:
  490. // Desc:
  491. //-----------------------------------------------------------------------------
  492. CD3DFrame* CD3DFrame::FindFrame( TCHAR* 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. }
  510. */
  512. /*
  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. }
  599. /*
  600. //-----------------------------------------------------------------------------
  601. // Name:
  602. // Desc:
  603. //-----------------------------------------------------------------------------
  604. HRESULT CD3DFile::LoadFrame( LPDIRECT3DDEVICE9 pd3dDevice,
  605.                              LPDIRECTXFILEDATA pFileData,
  606.                              CD3DFrame* pParentFrame )
  607. {
  608.     LPD3DFILEDATA   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. }
  676. */
  679. /*
  680. //-----------------------------------------------------------------------------
  681. // Name:
  682. // Desc:
  683. //-----------------------------------------------------------------------------
  684. HRESULT CD3DFile::LoadMesh( LPDIRECT3DDEVICE9 pd3dDevice,
  685.                             LPD3DXFILEDATA pFileData,
  686.                             CD3DFrame* pParentFrame )
  687. {
  688.     // Currently only allowing one mesh per frame
  689.     if( pParentFrame->m_pMesh )
  690.         return E_FAIL;
  692.     // Get the mesh name
  693.     CHAR  strAnsiName[512] = {0};
  694.     TCHAR strName[512];
  695.     DWORD dwNameLength = 512;
  696.     HRESULT hr;
  697.     if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
  698.         return hr;
  699.     DXUtil_ConvertAnsiStringToGenericCb( strName, strAnsiName, sizeof(strName) );
  701.     // Create the mesh
  702.     pParentFrame->m_pMesh = new CD3DMesh( strName );
  703.     if( pParentFrame->m_pMesh == NULL )
  704.         return E_OUTOFMEMORY;
  705.     pParentFrame->m_pMesh->Create( pd3dDevice, pFileData );
  707.     return S_OK;
  708. }
  710. */
  711. /*
  713. //-----------------------------------------------------------------------------
  714. // Name:
  715. // Desc:
  716. //-----------------------------------------------------------------------------
  717. HRESULT CD3DFile::CreateFromResource( LPDIRECT3DDEVICE9 pd3dDevice, TCHAR* strResource, TCHAR* strType )
  718. {
  719.     LPDIRECTXFILE           pDXFile   = NULL;
  720.     LPDIRECTXFILEENUMOBJECT pEnumObj  = NULL;
  721.     LPDIRECTXFILEDATA       pFileData = NULL;
  722.     HRESULT hr;
  724.     // Create a x file object
  725.     if( FAILED( hr = DirectXFileCreate( &pDXFile ) ) )
  726.         return E_FAIL;
  728.     // Register templates for d3drm and patch extensions.
  729.     if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
  730.                                                  D3DRM_XTEMPLATE_BYTES ) ) )
  731.     {
  732.         pDXFile->Release();
  733.         return E_FAIL;
  734.     }
  735.     
  736.     CHAR strTypeAnsi[MAX_PATH];
  737.     DXUtil_ConvertGenericStringToAnsiCb( strTypeAnsi, strType, sizeof(strTypeAnsi) );
  739.     DXFILELOADRESOURCE dxlr;
  740.     dxlr.hModule = NULL;
  741.     dxlr.lpName = strResource;
  742.     dxlr.lpType = (TCHAR*) strTypeAnsi;
  744.     // Create enum object
  745.     hr = pDXFile->CreateEnumObject( (void*)&dxlr, DXFILELOAD_FROMRESOURCE, 
  746.                                     &pEnumObj );
  747.     if( FAILED(hr) )
  748.     {
  749.         pDXFile->Release();
  750.         return hr;
  751.     }
  753.     // Enumerate top level objects (which are always frames)
  754.     while( SUCCEEDED( pEnumObj->GetNextDataObject( &pFileData ) ) )
  755.     {
  756.         hr = LoadFrame( pd3dDevice, pFileData, this );
  757.         pFileData->Release();
  758.         if( FAILED(hr) )
  759.         {
  760.             pEnumObj->Release();
  761.             pDXFile->Release();
  762.             return E_FAIL;
  763.         }
  764.     }
  766.     SAFE_RELEASE( pFileData );
  767.     SAFE_RELEASE( pEnumObj );
  768.     SAFE_RELEASE( pDXFile );
  770.     return S_OK;
  771. }
  776. //-----------------------------------------------------------------------------
  777. // Name:
  778. // Desc:
  779. //-----------------------------------------------------------------------------
  780. HRESULT CD3DFile::Create( LPDIRECT3DDEVICE9 pd3dDevice, TCHAR* strFilename )
  781. {
  782.     LPDIRECTXFILE           pDXFile   = NULL;
  783.     LPDIRECTXFILEENUMOBJECT pEnumObj  = NULL;
  784.     LPDIRECTXFILEDATA       pFileData = NULL;
  785.     HRESULT hr;
  787.     // Create a x file object
  788.     if( FAILED( hr = DirectXFileCreate( &pDXFile ) ) )
  789.         return E_FAIL;
  791.     // Register templates for d3drm and patch extensions.
  792.     if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
  793.                                                  D3DRM_XTEMPLATE_BYTES ) ) )
  794.     {
  795.         pDXFile->Release();
  796.         return E_FAIL;
  797.     }
  799.     // Find the path to the file, and convert it to ANSI (for the D3DXOF API)
  800.     TCHAR strPath[MAX_PATH];
  801.     CHAR  strPathANSI[MAX_PATH];
  802.     DXUtil_FindMediaFileCb( strPath, sizeof(strPath), strFilename );
  803.     DXUtil_ConvertGenericStringToAnsiCb( strPathANSI, strPath, sizeof(strPathANSI) );
  804.     
  805.     // Create enum object
  806.     hr = pDXFile->CreateEnumObject( (void*)strPathANSI, DXFILELOAD_FROMFILE, 
  807.                                     &pEnumObj );
  808.     if( FAILED(hr) )
  809.     {
  810.         pDXFile->Release();
  811.         return hr;
  812.     }
  814.     // Enumerate top level objects (which are always frames)
  815.     while( SUCCEEDED( pEnumObj->GetNextDataObject( &pFileData ) ) )
  816.     {
  817.         hr = LoadFrame( pd3dDevice, pFileData, this );
  818.         pFileData->Release();
  819.         if( FAILED(hr) )
  820.         {
  821.             pEnumObj->Release();
  822.             pDXFile->Release();
  823.             return E_FAIL;
  824.         }
  825.     }
  827.     SAFE_RELEASE( pFileData );
  828.     SAFE_RELEASE( pEnumObj );
  829.     SAFE_RELEASE( pDXFile );
  831.     return S_OK;
  832. }
  837. //-----------------------------------------------------------------------------
  838. // Name:
  839. // Desc:
  840. //-----------------------------------------------------------------------------
  841. HRESULT CD3DFile::Render( LPDIRECT3DDEVICE9 pd3dDevice, D3DXMATRIX* pmatWorldMatrix )
  842. {
  844.     // For pure devices, specify the world transform. If the world transform is not
  845.     // specified on pure devices, this function will fail.
  847.     // Set up the world transformation
  848.     D3DXMATRIX matSavedWorld, matWorld;
  850.     if ( NULL == pmatWorldMatrix )
  851.         pd3dDevice->GetTransform( D3DTS_WORLD, &matSavedWorld );
  852.     else
  853.         matSavedWorld = *pmatWorldMatrix;
  855.     D3DXMatrixMultiply( &matWorld, &matSavedWorld, &m_mat );
  856.     pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
  858.     // Render opaque subsets in the meshes
  859.     if( m_pChild )
  860.         m_pChild->Render( pd3dDevice, TRUE, FALSE, &matWorld );
  862.     // Enable alpha blending
  863.     pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
  864.     pd3dDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
  865.     pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
  867.     // Render alpha subsets in the meshes
  868.     if( m_pChild )
  869.         m_pChild->Render( pd3dDevice, FALSE, TRUE, &matWorld );
  871.     // Restore state
  872.     pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
  873.     pd3dDevice->SetTransform( D3DTS_WORLD, &matSavedWorld );
  875.     return S_OK;
  876. }
  878. */