diff options
Diffstat (limited to 'samples/DX_APIUsage/DXUT/Optional/SDKmesh.cpp')
| -rw-r--r-- | samples/DX_APIUsage/DXUT/Optional/SDKmesh.cpp | 1600 |
1 files changed, 279 insertions, 1321 deletions
diff --git a/samples/DX_APIUsage/DXUT/Optional/SDKmesh.cpp b/samples/DX_APIUsage/DXUT/Optional/SDKmesh.cpp index 5002d74..207020f 100644 --- a/samples/DX_APIUsage/DXUT/Optional/SDKmesh.cpp +++ b/samples/DX_APIUsage/DXUT/Optional/SDKmesh.cpp @@ -7,12 +7,18 @@ // meets the specific needs of the application. // // Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. +// +// http://go.microsoft.com/fwlink/?LinkId=320437 //-------------------------------------------------------------------------------------- #include "DXUT.h" #include "SDKMesh.h" #include "SDKMisc.h" +using namespace DirectX; + //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ void CDXUTSDKMesh::LoadMaterials( ID3D11Device* pd3dDevice, SDKMESH_MATERIAL* pMaterials, UINT numMaterials, SDKMESH_CALLBACKS11* pLoaderCallbacks ) { @@ -22,12 +28,12 @@ void CDXUTSDKMesh::LoadMaterials( ID3D11Device* pd3dDevice, SDKMESH_MATERIAL* pM { for( UINT m = 0; m < numMaterials; m++ ) { - pMaterials[m].pDiffuseTexture11 = NULL; - pMaterials[m].pNormalTexture11 = NULL; - pMaterials[m].pSpecularTexture11 = NULL; - pMaterials[m].pDiffuseRV11 = NULL; - pMaterials[m].pNormalRV11 = NULL; - pMaterials[m].pSpecularRV11 = NULL; + pMaterials[m].pDiffuseTexture11 = nullptr; + pMaterials[m].pNormalTexture11 = nullptr; + pMaterials[m].pSpecularTexture11 = nullptr; + pMaterials[m].pDiffuseRV11 = nullptr; + pMaterials[m].pNormalRV11 = nullptr; + pMaterials[m].pSpecularRV11 = nullptr; // load textures if( pMaterials[m].DiffuseTexture[0] != 0 ) @@ -54,12 +60,12 @@ void CDXUTSDKMesh::LoadMaterials( ID3D11Device* pd3dDevice, SDKMESH_MATERIAL* pM { for( UINT m = 0; m < numMaterials; m++ ) { - pMaterials[m].pDiffuseTexture11 = NULL; - pMaterials[m].pNormalTexture11 = NULL; - pMaterials[m].pSpecularTexture11 = NULL; - pMaterials[m].pDiffuseRV11 = NULL; - pMaterials[m].pNormalRV11 = NULL; - pMaterials[m].pSpecularRV11 = NULL; + pMaterials[m].pDiffuseTexture11 = nullptr; + pMaterials[m].pNormalTexture11 = nullptr; + pMaterials[m].pSpecularTexture11 = nullptr; + pMaterials[m].pDiffuseRV11 = nullptr; + pMaterials[m].pNormalRV11 = nullptr; + pMaterials[m].pSpecularRV11 = nullptr; // load textures if( pMaterials[m].DiffuseTexture[0] != 0 ) @@ -92,84 +98,7 @@ void CDXUTSDKMesh::LoadMaterials( ID3D11Device* pd3dDevice, SDKMESH_MATERIAL* pM } //-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::LoadMaterials( IDirect3DDevice9* pd3dDevice, SDKMESH_MATERIAL* pMaterials, UINT numMaterials, - SDKMESH_CALLBACKS9* pLoaderCallbacks ) -{ - char strPath[MAX_PATH]; - - if( pLoaderCallbacks && pLoaderCallbacks->pCreateTextureFromFile ) - { - for( UINT m = 0; m < numMaterials; m++ ) - { - pMaterials[m].pDiffuseTexture9 = NULL; - pMaterials[m].pNormalTexture9 = NULL; - pMaterials[m].pSpecularTexture9 = NULL; - - // load textures - if( pMaterials[m].DiffuseTexture[0] != 0 ) - { - pLoaderCallbacks->pCreateTextureFromFile( pd3dDevice, - pMaterials[m].DiffuseTexture, - &pMaterials[m].pDiffuseTexture9, - pLoaderCallbacks->pContext ); - } - if( pMaterials[m].NormalTexture[0] != 0 ) - { - pLoaderCallbacks->pCreateTextureFromFile( pd3dDevice, - pMaterials[m].NormalTexture, &pMaterials[m].pNormalTexture9, - pLoaderCallbacks->pContext ); - } - if( pMaterials[m].SpecularTexture[0] != 0 ) - { - pLoaderCallbacks->pCreateTextureFromFile( pd3dDevice, - pMaterials[m].SpecularTexture, - &pMaterials[m].pSpecularTexture9, - pLoaderCallbacks->pContext ); - } - } - } - else - { - for( UINT m = 0; m < numMaterials; m++ ) - { - pMaterials[m].pDiffuseTexture9 = NULL; - pMaterials[m].pNormalTexture9 = NULL; - pMaterials[m].pSpecularTexture9 = NULL; - pMaterials[m].pDiffuseRV11 = NULL; - pMaterials[m].pNormalRV11 = NULL; - pMaterials[m].pSpecularRV11 = NULL; - - // load textures - if( pMaterials[m].DiffuseTexture[0] != 0 ) - { - sprintf_s( strPath, MAX_PATH, "%s%s", m_strPath, pMaterials[m].DiffuseTexture ); - if( FAILED( DXUTGetGlobalResourceCache().CreateTextureFromFile( pd3dDevice, - strPath, - &pMaterials[m].pDiffuseTexture9 ) ) ) - pMaterials[m].pDiffuseTexture9 = ( IDirect3DTexture9* )ERROR_RESOURCE_VALUE; - } - if( pMaterials[m].NormalTexture[0] != 0 ) - { - sprintf_s( strPath, MAX_PATH, "%s%s", m_strPath, pMaterials[m].NormalTexture ); - if( FAILED( DXUTGetGlobalResourceCache().CreateTextureFromFile( pd3dDevice, - strPath, - &pMaterials[m].pNormalTexture9 ) ) ) - pMaterials[m].pNormalTexture9 = ( IDirect3DTexture9* )ERROR_RESOURCE_VALUE; - } - if( pMaterials[m].SpecularTexture[0] != 0 ) - { - sprintf_s( strPath, MAX_PATH, "%s%s", m_strPath, pMaterials[m].SpecularTexture ); - if( FAILED( DXUTGetGlobalResourceCache().CreateTextureFromFile( pd3dDevice, - strPath, - &pMaterials[m].pSpecularTexture9 ) ) ) - pMaterials[m].pSpecularTexture9 = ( IDirect3DTexture9* )ERROR_RESOURCE_VALUE; - } - - } - } -} - -//-------------------------------------------------------------------------------------- +_Use_decl_annotations_ HRESULT CDXUTSDKMesh::CreateVertexBuffer( ID3D11Device* pd3dDevice, SDKMESH_VERTEX_BUFFER_HEADER* pHeader, void* pVertices, SDKMESH_CALLBACKS11* pLoaderCallbacks ) { @@ -193,7 +122,10 @@ HRESULT CDXUTSDKMesh::CreateVertexBuffer( ID3D11Device* pd3dDevice, SDKMESH_VERT D3D11_SUBRESOURCE_DATA InitData; InitData.pSysMem = pVertices; hr = pd3dDevice->CreateBuffer( &bufferDesc, &InitData, &pHeader->pVB11 ); - DXUT_SetDebugName( pHeader->pVB11, "CDXUTSDKMesh" ); + if (SUCCEEDED(hr)) + { + DXUT_SetDebugName(pHeader->pVB11, "CDXUTSDKMesh"); + } } return hr; @@ -201,6 +133,7 @@ HRESULT CDXUTSDKMesh::CreateVertexBuffer( ID3D11Device* pd3dDevice, SDKMESH_VERT //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ HRESULT CDXUTSDKMesh::CreateIndexBuffer( ID3D11Device* pd3dDevice, SDKMESH_INDEX_BUFFER_HEADER* pHeader, void* pIndices, SDKMESH_CALLBACKS11* pLoaderCallbacks ) { @@ -224,101 +157,21 @@ HRESULT CDXUTSDKMesh::CreateIndexBuffer( ID3D11Device* pd3dDevice, SDKMESH_INDEX D3D11_SUBRESOURCE_DATA InitData; InitData.pSysMem = pIndices; hr = pd3dDevice->CreateBuffer( &bufferDesc, &InitData, &pHeader->pIB11 ); - DXUT_SetDebugName( pHeader->pIB11, "CDXUTSDKMesh" ); - } - - return hr; -} - - -//-------------------------------------------------------------------------------------- -HRESULT CDXUTSDKMesh::CreateVertexBuffer( IDirect3DDevice9* pd3dDevice, SDKMESH_VERTEX_BUFFER_HEADER* pHeader, - void* pVertices, SDKMESH_CALLBACKS9* pLoaderCallbacks ) -{ - HRESULT hr = S_OK; - - pHeader->DataOffset = 0; - if( pLoaderCallbacks && pLoaderCallbacks->pCreateVertexBuffer ) - { - pLoaderCallbacks->pCreateVertexBuffer( pd3dDevice, &pHeader->pVB9, ( UINT )pHeader->SizeBytes, - D3DUSAGE_WRITEONLY, 0, D3DPOOL_DEFAULT, pVertices, - pLoaderCallbacks->pContext ); - } - else - { - hr = pd3dDevice->CreateVertexBuffer( ( UINT )pHeader->SizeBytes, - D3DUSAGE_WRITEONLY, - 0, - D3DPOOL_DEFAULT, - &pHeader->pVB9, - NULL ); - - //lock - if( SUCCEEDED( hr ) ) + if (SUCCEEDED(hr)) { - void* pLockedVerts = NULL; - V_RETURN( pHeader->pVB9->Lock( 0, 0, &pLockedVerts, 0 ) ); - CopyMemory( pLockedVerts, pVertices, ( size_t )pHeader->SizeBytes ); - pHeader->pVB9->Unlock(); + DXUT_SetDebugName(pHeader->pIB11, "CDXUTSDKMesh"); } } return hr; } -//-------------------------------------------------------------------------------------- -HRESULT CDXUTSDKMesh::CreateIndexBuffer( IDirect3DDevice9* pd3dDevice, SDKMESH_INDEX_BUFFER_HEADER* pHeader, - void* pIndices, SDKMESH_CALLBACKS9* pLoaderCallbacks ) -{ - HRESULT hr = S_OK; - - pHeader->DataOffset = 0; - - D3DFORMAT ibFormat = D3DFMT_INDEX16; - switch( pHeader->IndexType ) - { - case IT_16BIT: - ibFormat = D3DFMT_INDEX16; - break; - case IT_32BIT: - ibFormat = D3DFMT_INDEX32; - break; - }; - - if( pLoaderCallbacks && pLoaderCallbacks->pCreateIndexBuffer ) - { - pLoaderCallbacks->pCreateIndexBuffer( pd3dDevice, &pHeader->pIB9, ( UINT )pHeader->SizeBytes, - D3DUSAGE_WRITEONLY, ibFormat, D3DPOOL_DEFAULT, pIndices, - pLoaderCallbacks->pContext ); - } - else - { - hr = pd3dDevice->CreateIndexBuffer( ( UINT )( pHeader->SizeBytes ), - D3DUSAGE_WRITEONLY, - ibFormat, - D3DPOOL_DEFAULT, - &pHeader->pIB9, - NULL ); - - if( SUCCEEDED( hr ) ) - { - void* pLockedIndices = NULL; - V_RETURN( pHeader->pIB9->Lock( 0, 0, &pLockedIndices, 0 ) ); - CopyMemory( pLockedIndices, pIndices, ( size_t )( pHeader->SizeBytes ) ); - pHeader->pIB9->Unlock(); - } - } - - return hr; -} //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ HRESULT CDXUTSDKMesh::CreateFromFile( ID3D11Device* pDev11, - IDirect3DDevice9* pDev9, - LPCTSTR szFileName, - bool bCreateAdjacencyIndices, - SDKMESH_CALLBACKS11* pLoaderCallbacks11, - SDKMESH_CALLBACKS9* pLoaderCallbacks9 ) + LPCWSTR szFileName, + SDKMESH_CALLBACKS11* pLoaderCallbacks11 ) { HRESULT hr = S_OK; @@ -326,8 +179,8 @@ HRESULT CDXUTSDKMesh::CreateFromFile( ID3D11Device* pDev11, V_RETURN( DXUTFindDXSDKMediaFileCch( m_strPathW, sizeof( m_strPathW ) / sizeof( WCHAR ), szFileName ) ); // Open the file - m_hFile = CreateFile( m_strPathW, FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, - NULL ); + m_hFile = CreateFile( m_strPathW, FILE_READ_DATA, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, + nullptr ); if( INVALID_HANDLE_VALUE == m_hFile ) return DXUTERR_MEDIANOTFOUND; @@ -338,7 +191,7 @@ HRESULT CDXUTSDKMesh::CreateFromFile( ID3D11Device* pDev11, else *m_strPathW = L'\0'; - WideCharToMultiByte( CP_ACP, 0, m_strPathW, -1, m_strPath, MAX_PATH, NULL, FALSE ); + WideCharToMultiByte( CP_ACP, 0, m_strPathW, -1, m_strPath, MAX_PATH, nullptr, FALSE ); // Get the file size LARGE_INTEGER FileSize; @@ -346,7 +199,7 @@ HRESULT CDXUTSDKMesh::CreateFromFile( ID3D11Device* pDev11, UINT cBytes = FileSize.LowPart; // Allocate memory - m_pStaticMeshData = new BYTE[ cBytes ]; + m_pStaticMeshData = new (std::nothrow) BYTE[ cBytes ]; if( !m_pStaticMeshData ) { CloseHandle( m_hFile ); @@ -355,7 +208,7 @@ HRESULT CDXUTSDKMesh::CreateFromFile( ID3D11Device* pDev11, // Read in the file DWORD dwBytesRead; - if( !ReadFile( m_hFile, m_pStaticMeshData, cBytes, &dwBytesRead, NULL ) ) + if( !ReadFile( m_hFile, m_pStaticMeshData, cBytes, &dwBytesRead, nullptr ) ) hr = E_FAIL; CloseHandle( m_hFile ); @@ -363,13 +216,10 @@ HRESULT CDXUTSDKMesh::CreateFromFile( ID3D11Device* pDev11, if( SUCCEEDED( hr ) ) { hr = CreateFromMemory( pDev11, - pDev9, m_pStaticMeshData, cBytes, - bCreateAdjacencyIndices, false, - pLoaderCallbacks11, - pLoaderCallbacks9 ); + pLoaderCallbacks11 ); if( FAILED( hr ) ) delete []m_pStaticMeshData; } @@ -377,37 +227,39 @@ HRESULT CDXUTSDKMesh::CreateFromFile( ID3D11Device* pDev11, return hr; } +_Use_decl_annotations_ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, - IDirect3DDevice9* pDev9, BYTE* pData, - UINT DataBytes, - bool bCreateAdjacencyIndices, + size_t DataBytes, bool bCopyStatic, - SDKMESH_CALLBACKS11* pLoaderCallbacks11, - SDKMESH_CALLBACKS9* pLoaderCallbacks9 ) + SDKMESH_CALLBACKS11* pLoaderCallbacks11 ) { - HRESULT hr = E_FAIL; - D3DXVECTOR3 lower; - D3DXVECTOR3 upper; + XMFLOAT3 lower; + XMFLOAT3 upper; - m_pDev9 = pDev9; - m_pDev11 = pDev11; + m_pDev11 = pDev11; + + if ( DataBytes < sizeof(SDKMESH_HEADER) ) + return E_FAIL; // Set outstanding resources to zero m_NumOutstandingResources = 0; if( bCopyStatic ) { - SDKMESH_HEADER* pHeader = ( SDKMESH_HEADER* )pData; + auto pHeader = reinterpret_cast<SDKMESH_HEADER*>( pData ); SIZE_T StaticSize = ( SIZE_T )( pHeader->HeaderSize + pHeader->NonBufferDataSize ); - m_pHeapData = new BYTE[ StaticSize ]; + if ( DataBytes < StaticSize ) + return E_FAIL; + + m_pHeapData = new (std::nothrow) BYTE[ StaticSize ]; if( !m_pHeapData ) - return hr; + return E_OUTOFMEMORY; m_pStaticMeshData = m_pHeapData; - CopyMemory( m_pStaticMeshData, pData, StaticSize ); + memcpy( m_pStaticMeshData, pData, StaticSize ); } else { @@ -416,7 +268,8 @@ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, } // Pointer fixup - m_pMeshHeader = ( SDKMESH_HEADER* )m_pStaticMeshData; + m_pMeshHeader = reinterpret_cast<SDKMESH_HEADER*>( m_pStaticMeshData ); + m_pVertexBufferArray = ( SDKMESH_VERTEX_BUFFER_HEADER* )( m_pStaticMeshData + m_pMeshHeader->VertexStreamHeadersOffset ); m_pIndexBufferArray = ( SDKMESH_INDEX_BUFFER_HEADER* )( m_pStaticMeshData + @@ -436,8 +289,7 @@ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, // error condition if( m_pMeshHeader->Version != SDKMESH_FILE_VERSION ) { - hr = E_NOINTERFACE; - goto Error; + return E_NOINTERFACE; } // Setup buffer data pointer @@ -447,31 +299,36 @@ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, UINT64 BufferDataStart = m_pMeshHeader->HeaderSize + m_pMeshHeader->NonBufferDataSize; // Create VBs - m_ppVertices = new BYTE*[m_pMeshHeader->NumVertexBuffers]; + m_ppVertices = new (std::nothrow) BYTE*[m_pMeshHeader->NumVertexBuffers]; + if ( !m_ppVertices ) + { + return E_OUTOFMEMORY; + } for( UINT i = 0; i < m_pMeshHeader->NumVertexBuffers; i++ ) { - BYTE* pVertices = NULL; + BYTE* pVertices = nullptr; pVertices = ( BYTE* )( pBufferData + ( m_pVertexBufferArray[i].DataOffset - BufferDataStart ) ); if( pDev11 ) CreateVertexBuffer( pDev11, &m_pVertexBufferArray[i], pVertices, pLoaderCallbacks11 ); - else if( pDev9 ) - CreateVertexBuffer( pDev9, &m_pVertexBufferArray[i], pVertices, pLoaderCallbacks9 ); m_ppVertices[i] = pVertices; } // Create IBs - m_ppIndices = new BYTE*[m_pMeshHeader->NumIndexBuffers]; + m_ppIndices = new (std::nothrow) BYTE*[m_pMeshHeader->NumIndexBuffers]; + if ( !m_ppIndices ) + { + return E_OUTOFMEMORY; + } + for( UINT i = 0; i < m_pMeshHeader->NumIndexBuffers; i++ ) { - BYTE* pIndices = NULL; + BYTE* pIndices = nullptr; pIndices = ( BYTE* )( pBufferData + ( m_pIndexBufferArray[i].DataOffset - BufferDataStart ) ); if( pDev11 ) CreateIndexBuffer( pDev11, &m_pIndexBufferArray[i], pIndices, pLoaderCallbacks11 ); - else if( pDev9 ) - CreateIndexBuffer( pDev9, &m_pIndexBufferArray[i], pIndices, pLoaderCallbacks9 ); m_ppIndices[i] = pIndices; } @@ -479,23 +336,28 @@ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, // Load Materials if( pDev11 ) LoadMaterials( pDev11, m_pMaterialArray, m_pMeshHeader->NumMaterials, pLoaderCallbacks11 ); - else if( pDev9 ) - LoadMaterials( pDev9, m_pMaterialArray, m_pMeshHeader->NumMaterials, pLoaderCallbacks9 ); // Create a place to store our bind pose frame matrices - m_pBindPoseFrameMatrices = new D3DXMATRIX[ m_pMeshHeader->NumFrames ]; + m_pBindPoseFrameMatrices = new (std::nothrow) XMFLOAT4X4[ m_pMeshHeader->NumFrames ]; if( !m_pBindPoseFrameMatrices ) - goto Error; + { + return E_OUTOFMEMORY; + } // Create a place to store our transformed frame matrices - m_pTransformedFrameMatrices = new D3DXMATRIX[ m_pMeshHeader->NumFrames ]; + m_pTransformedFrameMatrices = new (std::nothrow) XMFLOAT4X4[ m_pMeshHeader->NumFrames ]; if( !m_pTransformedFrameMatrices ) - goto Error; - m_pWorldPoseFrameMatrices = new D3DXMATRIX[ m_pMeshHeader->NumFrames ]; + { + return E_OUTOFMEMORY; + } + + m_pWorldPoseFrameMatrices = new (std::nothrow) XMFLOAT4X4[ m_pMeshHeader->NumFrames ]; if( !m_pWorldPoseFrameMatrices ) - goto Error; + { + return E_OUTOFMEMORY; + } - SDKMESH_SUBSET* pSubset = NULL; + SDKMESH_SUBSET* pSubset = nullptr; D3D11_PRIMITIVE_TOPOLOGY PrimType; // update bounding volume @@ -528,10 +390,10 @@ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, IndexStart *= 2; }*/ - //BYTE* pIndices = NULL; + //BYTE* pIndices = nullptr; //m_ppIndices[i] UINT *ind = ( UINT * )m_ppIndices[currentMesh->IndexBuffer]; - FLOAT *verts = ( FLOAT* )m_ppVertices[currentMesh->VertexBuffers[0]]; + float *verts = ( float* )m_ppVertices[currentMesh->VertexBuffers[0]]; UINT stride = (UINT)m_pVertexBufferArray[currentMesh->VertexBuffers[0]].StrideBytes; assert (stride % 4 == 0); stride /=4; @@ -550,7 +412,7 @@ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, current_ind = ind[vertind]; } tris++; - D3DXVECTOR3 *pt = (D3DXVECTOR3*)&(verts[stride * current_ind]); + XMFLOAT3 *pt = (XMFLOAT3*)&(verts[stride * current_ind]); if (pt->x < lower.x) { lower.x = pt->x; } @@ -575,153 +437,137 @@ HRESULT CDXUTSDKMesh::CreateFromMemory( ID3D11Device* pDev11, //pd3dDeviceContext->DrawIndexed( IndexCount, IndexStart, VertexStart ); } - D3DXVECTOR3 half = upper - lower; - half *=0.5f; + XMFLOAT3 half( ( upper.x - lower.x ) * 0.5f, + ( upper.y - lower.y ) * 0.5f, + ( upper.z - lower.z ) * 0.5f ); + + currentMesh->BoundingBoxCenter.x = lower.x + half.x; + currentMesh->BoundingBoxCenter.y = lower.y + half.y; + currentMesh->BoundingBoxCenter.z = lower.z + half.z; - currentMesh->BoundingBoxCenter = lower + half; currentMesh->BoundingBoxExtents = half; } // Update - - - hr = S_OK; -Error: - - if( !pLoaderCallbacks9 ) - { - CheckLoadDone(); - } - - return hr; + return S_OK; } + //-------------------------------------------------------------------------------------- // transform bind pose frame using a recursive traversal //-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::TransformBindPoseFrame( UINT iFrame, D3DXMATRIX* pParentWorld ) +_Use_decl_annotations_ +void CDXUTSDKMesh::TransformBindPoseFrame( UINT iFrame, CXMMATRIX parentWorld ) { if( !m_pBindPoseFrameMatrices ) return; // Transform ourselves - D3DXMATRIX LocalWorld; - D3DXMatrixMultiply( &LocalWorld, &m_pFrameArray[iFrame].Matrix, pParentWorld ); - m_pBindPoseFrameMatrices[iFrame] = LocalWorld; + XMMATRIX m = XMLoadFloat4x4( &m_pFrameArray[iFrame].Matrix ); + XMMATRIX mLocalWorld = XMMatrixMultiply( m, parentWorld ); + XMStoreFloat4x4( &m_pBindPoseFrameMatrices[iFrame], mLocalWorld ); // Transform our siblings if( m_pFrameArray[iFrame].SiblingFrame != INVALID_FRAME ) - TransformBindPoseFrame( m_pFrameArray[iFrame].SiblingFrame, pParentWorld ); + { + TransformBindPoseFrame( m_pFrameArray[iFrame].SiblingFrame, parentWorld ); + } // Transform our children if( m_pFrameArray[iFrame].ChildFrame != INVALID_FRAME ) - TransformBindPoseFrame( m_pFrameArray[iFrame].ChildFrame, &LocalWorld ); + { + TransformBindPoseFrame( m_pFrameArray[iFrame].ChildFrame, mLocalWorld ); + } } + //-------------------------------------------------------------------------------------- // transform frame using a recursive traversal //-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::TransformFrame( UINT iFrame, D3DXMATRIX* pParentWorld, double fTime ) +_Use_decl_annotations_ +void CDXUTSDKMesh::TransformFrame( UINT iFrame, CXMMATRIX parentWorld, double fTime ) { // Get the tick data - D3DXMATRIX LocalTransform; + XMMATRIX mLocalTransform; + UINT iTick = GetAnimationKeyFromTime( fTime ); if( INVALID_ANIMATION_DATA != m_pFrameArray[iFrame].AnimationDataIndex ) { - SDKANIMATION_FRAME_DATA* pFrameData = &m_pAnimationFrameData[ m_pFrameArray[iFrame].AnimationDataIndex ]; - SDKANIMATION_DATA* pData = &pFrameData->pAnimationData[ iTick ]; + auto pFrameData = &m_pAnimationFrameData[ m_pFrameArray[iFrame].AnimationDataIndex ]; + auto pData = &pFrameData->pAnimationData[ iTick ]; // turn it into a matrix (Ignore scaling for now) - D3DXVECTOR3 parentPos = pData->Translation; - D3DXMATRIX mTranslate; - D3DXMatrixTranslation( &mTranslate, parentPos.x, parentPos.y, parentPos.z ); - - D3DXQUATERNION quat; - D3DXMATRIX mQuat; - quat.w = pData->Orientation.w; - quat.x = pData->Orientation.x; - quat.y = pData->Orientation.y; - quat.z = pData->Orientation.z; - if( quat.w == 0 && quat.x == 0 && quat.y == 0 && quat.z == 0 ) - D3DXQuaternionIdentity( &quat ); - D3DXQuaternionNormalize( &quat, &quat ); - D3DXMatrixRotationQuaternion( &mQuat, &quat ); - LocalTransform = ( mQuat * mTranslate ); + XMFLOAT3 parentPos = pData->Translation; + XMMATRIX mTranslate = XMMatrixTranslation( parentPos.x, parentPos.y, parentPos.z ); + + XMVECTOR quat = XMVectorSet( pData->Orientation.x, pData->Orientation.y, pData->Orientation.z, pData->Orientation.w ); + if ( XMVector4Equal( quat, g_XMZero ) ) + quat = XMQuaternionIdentity(); + quat = XMQuaternionNormalize( quat ); + XMMATRIX mQuat = XMMatrixRotationQuaternion( quat ); + mLocalTransform = ( mQuat * mTranslate ); } else { - LocalTransform = m_pFrameArray[iFrame].Matrix; + mLocalTransform = XMLoadFloat4x4( &m_pFrameArray[iFrame].Matrix ); } // Transform ourselves - D3DXMATRIX LocalWorld; - D3DXMatrixMultiply( &LocalWorld, &LocalTransform, pParentWorld ); - m_pTransformedFrameMatrices[iFrame] = LocalWorld; - m_pWorldPoseFrameMatrices[iFrame] = LocalWorld; + XMMATRIX mLocalWorld = XMMatrixMultiply( mLocalTransform, parentWorld ); + XMStoreFloat4x4( &m_pTransformedFrameMatrices[iFrame], mLocalWorld ); + XMStoreFloat4x4( &m_pWorldPoseFrameMatrices[iFrame], mLocalWorld ); // Transform our siblings if( m_pFrameArray[iFrame].SiblingFrame != INVALID_FRAME ) - TransformFrame( m_pFrameArray[iFrame].SiblingFrame, pParentWorld, fTime ); + { + TransformFrame( m_pFrameArray[iFrame].SiblingFrame, parentWorld, fTime ); + } // Transform our children if( m_pFrameArray[iFrame].ChildFrame != INVALID_FRAME ) - TransformFrame( m_pFrameArray[iFrame].ChildFrame, &LocalWorld, fTime ); + { + TransformFrame( m_pFrameArray[iFrame].ChildFrame, mLocalWorld, fTime ); + } } + //-------------------------------------------------------------------------------------- // transform frame assuming that it is an absolute transformation //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ void CDXUTSDKMesh::TransformFrameAbsolute( UINT iFrame, double fTime ) { - D3DXMATRIX mTrans1; - D3DXMATRIX mTrans2; - D3DXMATRIX mRot1; - D3DXMATRIX mRot2; - D3DXQUATERNION quat1; - D3DXQUATERNION quat2; - D3DXMATRIX mTo; - D3DXMATRIX mInvTo; - D3DXMATRIX mFrom; - UINT iTick = GetAnimationKeyFromTime( fTime ); if( INVALID_ANIMATION_DATA != m_pFrameArray[iFrame].AnimationDataIndex ) { - SDKANIMATION_FRAME_DATA* pFrameData = &m_pAnimationFrameData[ m_pFrameArray[iFrame].AnimationDataIndex ]; - SDKANIMATION_DATA* pData = &pFrameData->pAnimationData[ iTick ]; - SDKANIMATION_DATA* pDataOrig = &pFrameData->pAnimationData[ 0 ]; - - D3DXMatrixTranslation( &mTrans1, -pDataOrig->Translation.x, - -pDataOrig->Translation.y, - -pDataOrig->Translation.z ); - D3DXMatrixTranslation( &mTrans2, pData->Translation.x, - pData->Translation.y, - pData->Translation.z ); - - quat1.x = pDataOrig->Orientation.x; - quat1.y = pDataOrig->Orientation.y; - quat1.z = pDataOrig->Orientation.z; - quat1.w = pDataOrig->Orientation.w; - D3DXQuaternionInverse( &quat1, &quat1 ); - D3DXMatrixRotationQuaternion( &mRot1, &quat1 ); - mInvTo = mTrans1 * mRot1; - - quat2.x = pData->Orientation.x; - quat2.y = pData->Orientation.y; - quat2.z = pData->Orientation.z; - quat2.w = pData->Orientation.w; - D3DXMatrixRotationQuaternion( &mRot2, &quat2 ); - mFrom = mRot2 * mTrans2; - - D3DXMATRIX mOutput = mInvTo * mFrom; - m_pTransformedFrameMatrices[iFrame] = mOutput; + auto pFrameData = &m_pAnimationFrameData[ m_pFrameArray[iFrame].AnimationDataIndex ]; + auto pData = &pFrameData->pAnimationData[ iTick ]; + auto pDataOrig = &pFrameData->pAnimationData[ 0 ]; + + XMMATRIX mTrans1 = XMMatrixTranslation( -pDataOrig->Translation.x, -pDataOrig->Translation.y, -pDataOrig->Translation.z ); + XMMATRIX mTrans2 = XMMatrixTranslation( pData->Translation.x, pData->Translation.y, pData->Translation.z ); + + XMVECTOR quat1 = XMVectorSet( pDataOrig->Orientation.x, pDataOrig->Orientation.y, pDataOrig->Orientation.z, pDataOrig->Orientation.w ); + quat1 = XMQuaternionInverse( quat1 ); + XMMATRIX mRot1 = XMMatrixRotationQuaternion( quat1 ); + XMMATRIX mInvTo = mTrans1 * mRot1; + + XMVECTOR quat2 = XMVectorSet( pData->Orientation.x, pData->Orientation.y, pData->Orientation.z, pData->Orientation.w ); + XMMATRIX mRot2 = XMMatrixRotationQuaternion( quat2 ); + XMMATRIX mFrom = mRot2 * mTrans2; + + XMMATRIX mOutput = mInvTo * mFrom; + XMStoreFloat4x4( &m_pTransformedFrameMatrices[iFrame], mOutput ); } } #define MAX_D3D11_VERTEX_STREAMS D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT + //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ void CDXUTSDKMesh::RenderMesh( UINT iMesh, bool bAdjacent, ID3D11DeviceContext* pd3dDeviceContext, @@ -732,7 +578,7 @@ void CDXUTSDKMesh::RenderMesh( UINT iMesh, if( 0 < GetOutstandingBufferResources() ) return; - SDKMESH_MESH* pMesh = &m_pMeshArray[iMesh]; + auto pMesh = &m_pMeshArray[iMesh]; UINT Strides[MAX_D3D11_VERTEX_STREAMS]; UINT Offsets[MAX_D3D11_VERTEX_STREAMS]; @@ -754,7 +600,7 @@ void CDXUTSDKMesh::RenderMesh( UINT iMesh, else pIndexBufferArray = m_pIndexBufferArray; - ID3D11Buffer* pIB = pIndexBufferArray[ pMesh->IndexBuffer ].pIB11; + auto pIB = pIndexBufferArray[ pMesh->IndexBuffer ].pIB11; DXGI_FORMAT ibFormat = DXGI_FORMAT_R16_UINT; switch( pIndexBufferArray[ pMesh->IndexBuffer ].IndexType ) { @@ -769,8 +615,8 @@ void CDXUTSDKMesh::RenderMesh( UINT iMesh, pd3dDeviceContext->IASetVertexBuffers( 0, pMesh->NumVertexBuffers, pVB, Strides, Offsets ); pd3dDeviceContext->IASetIndexBuffer( pIB, ibFormat, 0 ); - SDKMESH_SUBSET* pSubset = NULL; - SDKMESH_MATERIAL* pMat = NULL; + SDKMESH_SUBSET* pSubset = nullptr; + SDKMESH_MATERIAL* pMat = nullptr; D3D11_PRIMITIVE_TOPOLOGY PrimType; for( UINT subset = 0; subset < pMesh->NumSubsets; subset++ ) @@ -821,6 +667,7 @@ void CDXUTSDKMesh::RenderMesh( UINT iMesh, } //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ void CDXUTSDKMesh::RenderFrame( UINT iFrame, bool bAdjacent, ID3D11DeviceContext* pd3dDeviceContext, @@ -853,140 +700,22 @@ void CDXUTSDKMesh::RenderFrame( UINT iFrame, } //-------------------------------------------------------------------------------------- - -//-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::RenderMesh( UINT iMesh, - LPDIRECT3DDEVICE9 pd3dDevice, - LPD3DXEFFECT pEffect, - D3DXHANDLE hTechnique, - D3DXHANDLE htxDiffuse, - D3DXHANDLE htxNormal, - D3DXHANDLE htxSpecular ) -{ - if( 0 < GetOutstandingBufferResources() ) - return; - - SDKMESH_MESH* pMesh = &m_pMeshArray[iMesh]; - - // set vb streams - for( UINT i = 0; i < ( UINT )pMesh->NumVertexBuffers; i++ ) - { - pd3dDevice->SetStreamSource( i, - m_pVertexBufferArray[ pMesh->VertexBuffers[i] ].pVB9, - 0, - ( UINT )m_pVertexBufferArray[ pMesh->VertexBuffers[i] ].StrideBytes ); - } - - // Set our index buffer as well - pd3dDevice->SetIndices( m_pIndexBufferArray[ pMesh->IndexBuffer ].pIB9 ); - - // Render the scene with this technique - pEffect->SetTechnique( hTechnique ); - - SDKMESH_SUBSET* pSubset = NULL; - SDKMESH_MATERIAL* pMat = NULL; - D3DPRIMITIVETYPE PrimType; - UINT cPasses = 0; - pEffect->Begin( &cPasses, 0 ); - - for( UINT p = 0; p < cPasses; ++p ) - { - pEffect->BeginPass( p ); - - for( UINT subset = 0; subset < pMesh->NumSubsets; subset++ ) - { - pSubset = &m_pSubsetArray[ pMesh->pSubsets[subset] ]; - - PrimType = GetPrimitiveType9( ( SDKMESH_PRIMITIVE_TYPE )pSubset->PrimitiveType ); - - if( INVALID_MATERIAL != pSubset->MaterialID && m_pMeshHeader->NumMaterials > 0 ) - { - pMat = &m_pMaterialArray[ pSubset->MaterialID ]; - if( htxDiffuse && !IsErrorResource( pMat->pDiffuseTexture9 ) ) - pEffect->SetTexture( htxDiffuse, pMat->pDiffuseTexture9 ); - if( htxNormal && !IsErrorResource( pMat->pNormalTexture9 ) ) - pEffect->SetTexture( htxNormal, pMat->pNormalTexture9 ); - if( htxSpecular && !IsErrorResource( pMat->pSpecularTexture9 ) ) - pEffect->SetTexture( htxSpecular, pMat->pSpecularTexture9 ); - } - - pEffect->CommitChanges(); - - UINT PrimCount = ( UINT )pSubset->IndexCount; - UINT IndexStart = ( UINT )pSubset->IndexStart; - UINT VertexStart = ( UINT )pSubset->VertexStart; - UINT VertexCount = ( UINT )pSubset->VertexCount; - if( D3DPT_TRIANGLELIST == PrimType ) - PrimCount /= 3; - if( D3DPT_LINELIST == PrimType ) - PrimCount /= 2; - if( D3DPT_TRIANGLESTRIP == PrimType ) - PrimCount = ( PrimCount - 3 ) + 1; - if( D3DPT_LINESTRIP == PrimType ) - PrimCount -= 1; - - pd3dDevice->DrawIndexedPrimitive( PrimType, VertexStart, 0, VertexCount, IndexStart, PrimCount ); - } - - pEffect->EndPass(); - } - - pEffect->End(); -} - -//-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::RenderFrame( UINT iFrame, - LPDIRECT3DDEVICE9 pd3dDevice, - LPD3DXEFFECT pEffect, - D3DXHANDLE hTechnique, - D3DXHANDLE htxDiffuse, - D3DXHANDLE htxNormal, - D3DXHANDLE htxSpecular ) -{ - if( !m_pStaticMeshData || !m_pFrameArray ) - return; - - if( m_pFrameArray[iFrame].Mesh != INVALID_MESH ) - { - RenderMesh( m_pFrameArray[iFrame].Mesh, - pd3dDevice, - pEffect, - hTechnique, - htxDiffuse, - htxNormal, - htxSpecular ); - } - - // Render our children - if( m_pFrameArray[iFrame].ChildFrame != INVALID_FRAME ) - RenderFrame( m_pFrameArray[iFrame].ChildFrame, pd3dDevice, pEffect, hTechnique, htxDiffuse, htxNormal, - htxSpecular ); - - // Render our siblings - if( m_pFrameArray[iFrame].SiblingFrame != INVALID_FRAME ) - RenderFrame( m_pFrameArray[iFrame].SiblingFrame, pd3dDevice, pEffect, hTechnique, htxDiffuse, htxNormal, - htxSpecular ); -} - - -//-------------------------------------------------------------------------------------- CDXUTSDKMesh::CDXUTSDKMesh() : m_NumOutstandingResources( 0 ), m_bLoading( false ), m_hFile( 0 ), m_hFileMappingObject( 0 ), - m_pMeshHeader( NULL ), - m_pStaticMeshData( NULL ), - m_pHeapData( NULL ), - m_pAdjacencyIndexBufferArray( NULL ), - m_pAnimationData( NULL ), - m_pAnimationHeader( NULL ), - m_ppVertices( NULL ), - m_ppIndices( NULL ), - m_pBindPoseFrameMatrices( NULL ), - m_pTransformedFrameMatrices( NULL ), - m_pWorldPoseFrameMatrices( NULL ), - m_pDev9( NULL ), - m_pDev11( NULL ) + m_pMeshHeader( nullptr ), + m_pStaticMeshData( nullptr ), + m_pHeapData( nullptr ), + m_pAdjacencyIndexBufferArray( nullptr ), + m_pAnimationData( nullptr ), + m_pAnimationHeader( nullptr ), + m_ppVertices( nullptr ), + m_ppIndices( nullptr ), + m_pBindPoseFrameMatrices( nullptr ), + m_pTransformedFrameMatrices( nullptr ), + m_pWorldPoseFrameMatrices( nullptr ), + m_pDev11( nullptr ) { } @@ -998,38 +727,22 @@ CDXUTSDKMesh::~CDXUTSDKMesh() } //-------------------------------------------------------------------------------------- -HRESULT CDXUTSDKMesh::Create( ID3D11Device* pDev11, LPCTSTR szFileName, bool bCreateAdjacencyIndices, - SDKMESH_CALLBACKS11* pLoaderCallbacks ) +_Use_decl_annotations_ +HRESULT CDXUTSDKMesh::Create( ID3D11Device* pDev11, LPCWSTR szFileName, SDKMESH_CALLBACKS11* pLoaderCallbacks ) { - return CreateFromFile( pDev11, NULL, szFileName, bCreateAdjacencyIndices, pLoaderCallbacks, NULL ); + return CreateFromFile( pDev11, szFileName, pLoaderCallbacks ); } //-------------------------------------------------------------------------------------- -HRESULT CDXUTSDKMesh::Create( IDirect3DDevice9* pDev9, LPCTSTR szFileName, bool bCreateAdjacencyIndices, - SDKMESH_CALLBACKS9* pLoaderCallbacks ) +_Use_decl_annotations_ +HRESULT CDXUTSDKMesh::Create( ID3D11Device* pDev11, BYTE* pData, size_t DataBytes, bool bCopyStatic, SDKMESH_CALLBACKS11* pLoaderCallbacks ) { - return CreateFromFile( NULL, pDev9, szFileName, bCreateAdjacencyIndices, NULL, pLoaderCallbacks ); + return CreateFromMemory( pDev11, pData, DataBytes, bCopyStatic, pLoaderCallbacks ); } -//-------------------------------------------------------------------------------------- -HRESULT CDXUTSDKMesh::Create( ID3D11Device* pDev11, BYTE* pData, UINT DataBytes, bool bCreateAdjacencyIndices, - bool bCopyStatic, SDKMESH_CALLBACKS11* pLoaderCallbacks ) -{ - return CreateFromMemory( pDev11, NULL, pData, DataBytes, bCreateAdjacencyIndices, bCopyStatic, - pLoaderCallbacks, NULL ); -} - - -//-------------------------------------------------------------------------------------- -HRESULT CDXUTSDKMesh::Create( IDirect3DDevice9* pDev9, BYTE* pData, UINT DataBytes, bool bCreateAdjacencyIndices, - bool bCopyStatic, SDKMESH_CALLBACKS9* pLoaderCallbacks ) -{ - return CreateFromMemory( NULL, pDev9, pData, DataBytes, bCreateAdjacencyIndices, bCopyStatic, NULL, - pLoaderCallbacks ); -} //-------------------------------------------------------------------------------------- -HRESULT CDXUTSDKMesh::LoadAnimation( WCHAR* szFileName ) +HRESULT CDXUTSDKMesh::LoadAnimation( _In_z_ const WCHAR* szFileName ) { HRESULT hr = E_FAIL; DWORD dwBytesRead = 0; @@ -1040,32 +753,42 @@ HRESULT CDXUTSDKMesh::LoadAnimation( WCHAR* szFileName ) V_RETURN( DXUTFindDXSDKMediaFileCch( strPath, MAX_PATH, szFileName ) ); // Open the file - HANDLE hFile = CreateFile( strPath, FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, - FILE_FLAG_SEQUENTIAL_SCAN, NULL ); + HANDLE hFile = CreateFile( strPath, FILE_READ_DATA, FILE_SHARE_READ, nullptr, OPEN_EXISTING, + FILE_FLAG_SEQUENTIAL_SCAN, nullptr ); if( INVALID_HANDLE_VALUE == hFile ) return DXUTERR_MEDIANOTFOUND; ///////////////////////// // Header SDKANIMATION_FILE_HEADER fileheader; - if( !ReadFile( hFile, &fileheader, sizeof( SDKANIMATION_FILE_HEADER ), &dwBytesRead, NULL ) ) - goto Error; + if( !ReadFile( hFile, &fileheader, sizeof( SDKANIMATION_FILE_HEADER ), &dwBytesRead, nullptr ) ) + { + CloseHandle(hFile); + return HRESULT_FROM_WIN32(GetLastError()); + } //allocate - m_pAnimationData = new BYTE[ ( size_t )( sizeof( SDKANIMATION_FILE_HEADER ) + fileheader.AnimationDataSize ) ]; + m_pAnimationData = new (std::nothrow) BYTE[ ( size_t )( sizeof( SDKANIMATION_FILE_HEADER ) + fileheader.AnimationDataSize ) ]; if( !m_pAnimationData ) { - hr = E_OUTOFMEMORY; - goto Error; + CloseHandle(hFile); + return E_OUTOFMEMORY; } // read it all in liMove.QuadPart = 0; - if( !SetFilePointerEx( hFile, liMove, NULL, FILE_BEGIN ) ) - goto Error; + if( !SetFilePointerEx( hFile, liMove, nullptr, FILE_BEGIN ) ) + { + CloseHandle(hFile); + return HRESULT_FROM_WIN32(GetLastError()); + } + if( !ReadFile( hFile, m_pAnimationData, ( DWORD )( sizeof( SDKANIMATION_FILE_HEADER ) + - fileheader.AnimationDataSize ), &dwBytesRead, NULL ) ) - goto Error; + fileheader.AnimationDataSize ), &dwBytesRead, nullptr ) ) + { + CloseHandle(hFile); + return HRESULT_FROM_WIN32(GetLastError()); + } // pointer fixup m_pAnimationHeader = ( SDKANIMATION_FILE_HEADER* )m_pAnimationData; @@ -1077,17 +800,14 @@ HRESULT CDXUTSDKMesh::LoadAnimation( WCHAR* szFileName ) m_pAnimationFrameData[i].pAnimationData = ( SDKANIMATION_DATA* )( m_pAnimationData + m_pAnimationFrameData[i].DataOffset + BaseOffset ); - SDKMESH_FRAME* pFrame = FindFrame( m_pAnimationFrameData[i].FrameName ); + auto pFrame = FindFrame( m_pAnimationFrameData[i].FrameName ); if( pFrame ) { pFrame->AnimationDataIndex = i; } } - hr = S_OK; -Error: - CloseHandle( hFile ); - return hr; + return S_OK; } //-------------------------------------------------------------------------------------- @@ -1102,18 +822,8 @@ void CDXUTSDKMesh::Destroy() { for( UINT64 m = 0; m < m_pMeshHeader->NumMaterials; m++ ) { - if( m_pDev9 ) - { - if( !IsErrorResource( m_pMaterialArray[m].pDiffuseTexture9 ) ) - SAFE_RELEASE( m_pMaterialArray[m].pDiffuseTexture9 ); - if( !IsErrorResource( m_pMaterialArray[m].pNormalTexture9 ) ) - SAFE_RELEASE( m_pMaterialArray[m].pNormalTexture9 ); - if( !IsErrorResource( m_pMaterialArray[m].pSpecularTexture9 ) ) - SAFE_RELEASE( m_pMaterialArray[m].pSpecularTexture9 ); - } - else if( m_pDev11 ) + if( m_pDev11 ) { - //ID3D11Resource* pRes = NULL; if( m_pMaterialArray[m].pDiffuseRV11 && !IsErrorResource( m_pMaterialArray[m].pDiffuseRV11 ) ) { //m_pMaterialArray[m].pDiffuseRV11->GetResource( &pRes ); @@ -1138,17 +848,14 @@ void CDXUTSDKMesh::Destroy() } } } - for( UINT64 i = 0; i < m_pMeshHeader->NumVertexBuffers; i++ ) { - if( !IsErrorResource( m_pVertexBufferArray[i].pVB9 ) ) - SAFE_RELEASE( m_pVertexBufferArray[i].pVB9 ); + SAFE_RELEASE( m_pVertexBufferArray[i].pVB11 ); } for( UINT64 i = 0; i < m_pMeshHeader->NumIndexBuffers; i++ ) { - if( !IsErrorResource( m_pIndexBufferArray[i].pIB9 ) ) - SAFE_RELEASE( m_pIndexBufferArray[i].pIB9 ); + SAFE_RELEASE( m_pIndexBufferArray[i].pIB11 ); } } @@ -1162,7 +869,7 @@ void CDXUTSDKMesh::Destroy() SAFE_DELETE_ARRAY( m_pAdjacencyIndexBufferArray ); SAFE_DELETE_ARRAY( m_pHeapData ); - m_pStaticMeshData = NULL; + m_pStaticMeshData = nullptr; SAFE_DELETE_ARRAY( m_pAnimationData ); SAFE_DELETE_ARRAY( m_pBindPoseFrameMatrices ); SAFE_DELETE_ARRAY( m_pTransformedFrameMatrices ); @@ -1171,45 +878,39 @@ void CDXUTSDKMesh::Destroy() SAFE_DELETE_ARRAY( m_ppVertices ); SAFE_DELETE_ARRAY( m_ppIndices ); - m_pMeshHeader = NULL; - m_pVertexBufferArray = NULL; - m_pIndexBufferArray = NULL; - m_pMeshArray = NULL; - m_pSubsetArray = NULL; - m_pFrameArray = NULL; - m_pMaterialArray = NULL; + m_pMeshHeader = nullptr; + m_pVertexBufferArray = nullptr; + m_pIndexBufferArray = nullptr; + m_pMeshArray = nullptr; + m_pSubsetArray = nullptr; + m_pFrameArray = nullptr; + m_pMaterialArray = nullptr; - m_pAnimationHeader = NULL; - m_pAnimationFrameData = NULL; + m_pAnimationHeader = nullptr; + m_pAnimationFrameData = nullptr; } -//-------------------------------------------------------------------------------------- -// transform the bind pose -//-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::TransformBindPose( D3DXMATRIX* pWorld ) -{ - TransformBindPoseFrame( 0, pWorld ); -} //-------------------------------------------------------------------------------------- // transform the mesh frames according to the animation for time fTime //-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::TransformMesh( D3DXMATRIX* pWorld, double fTime ) +_Use_decl_annotations_ +void CDXUTSDKMesh::TransformMesh( CXMMATRIX world, double fTime ) { - if( m_pAnimationHeader == NULL || FTT_RELATIVE == m_pAnimationHeader->FrameTransformType ) + if( !m_pAnimationHeader || FTT_RELATIVE == m_pAnimationHeader->FrameTransformType ) { - TransformFrame( 0, pWorld, fTime ); + TransformFrame( 0, world, fTime ); // For each frame, move the transform to the bind pose, then // move it to the final position - D3DXMATRIX mInvBindPose; - D3DXMATRIX mFinal; for( UINT i = 0; i < m_pMeshHeader->NumFrames; i++ ) { - D3DXMatrixInverse( &mInvBindPose, NULL, &m_pBindPoseFrameMatrices[i] ); - mFinal = mInvBindPose * m_pTransformedFrameMatrices[i]; - m_pTransformedFrameMatrices[i] = mFinal; + XMMATRIX m = XMLoadFloat4x4( &m_pBindPoseFrameMatrices[i] ); + XMMATRIX mInvBindPose = XMMatrixInverse( nullptr, m ); + m = XMLoadFloat4x4( &m_pTransformedFrameMatrices[i] ); + XMMATRIX mFinal = mInvBindPose * m; + XMStoreFloat4x4( &m_pTransformedFrameMatrices[i], mFinal ); } } else if( FTT_ABSOLUTE == m_pAnimationHeader->FrameTransformType ) @@ -1221,6 +922,7 @@ void CDXUTSDKMesh::TransformMesh( D3DXMATRIX* pWorld, double fTime ) //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ void CDXUTSDKMesh::Render( ID3D11DeviceContext* pd3dDeviceContext, UINT iDiffuseSlot, UINT iNormalSlot, @@ -1230,6 +932,7 @@ void CDXUTSDKMesh::Render( ID3D11DeviceContext* pd3dDeviceContext, } //-------------------------------------------------------------------------------------- +_Use_decl_annotations_ void CDXUTSDKMesh::RenderAdjacent( ID3D11DeviceContext* pd3dDeviceContext, UINT iDiffuseSlot, UINT iNormalSlot, @@ -1240,18 +943,7 @@ void CDXUTSDKMesh::RenderAdjacent( ID3D11DeviceContext* pd3dDeviceContext, //-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::Render( LPDIRECT3DDEVICE9 pd3dDevice, - LPD3DXEFFECT pEffect, - D3DXHANDLE hTechnique, - D3DXHANDLE htxDiffuse, - D3DXHANDLE htxNormal, - D3DXHANDLE htxSpecular ) -{ - RenderFrame( 0, pd3dDevice, pEffect, hTechnique, htxDiffuse, htxNormal, htxSpecular ); -} - -//-------------------------------------------------------------------------------------- -D3D11_PRIMITIVE_TOPOLOGY CDXUTSDKMesh::GetPrimitiveType11( SDKMESH_PRIMITIVE_TYPE PrimType ) +D3D11_PRIMITIVE_TOPOLOGY CDXUTSDKMesh::GetPrimitiveType11( _In_ SDKMESH_PRIMITIVE_TYPE PrimType ) { D3D11_PRIMITIVE_TOPOLOGY retType = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST; @@ -1290,7 +982,7 @@ D3D11_PRIMITIVE_TOPOLOGY CDXUTSDKMesh::GetPrimitiveType11( SDKMESH_PRIMITIVE_TYP } //-------------------------------------------------------------------------------------- -DXGI_FORMAT CDXUTSDKMesh::GetIBFormat11( UINT iMesh ) +DXGI_FORMAT CDXUTSDKMesh::GetIBFormat11( _In_ UINT iMesh ) const { switch( m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].IndexType ) { @@ -1303,92 +995,40 @@ DXGI_FORMAT CDXUTSDKMesh::GetIBFormat11( UINT iMesh ) } //-------------------------------------------------------------------------------------- -ID3D11Buffer* CDXUTSDKMesh::GetVB11( UINT iMesh, UINT iVB ) +ID3D11Buffer* CDXUTSDKMesh::GetVB11( _In_ UINT iMesh, _In_ UINT iVB ) const { return m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].pVB11; } //-------------------------------------------------------------------------------------- -ID3D11Buffer* CDXUTSDKMesh::GetIB11( UINT iMesh ) +ID3D11Buffer* CDXUTSDKMesh::GetIB11( _In_ UINT iMesh ) const { return m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].pIB11; } -SDKMESH_INDEX_TYPE CDXUTSDKMesh::GetIndexType( UINT iMesh ) +SDKMESH_INDEX_TYPE CDXUTSDKMesh::GetIndexType( _In_ UINT iMesh ) const { return ( SDKMESH_INDEX_TYPE ) m_pIndexBufferArray[m_pMeshArray[ iMesh ].IndexBuffer].IndexType; } //-------------------------------------------------------------------------------------- -ID3D11Buffer* CDXUTSDKMesh::GetAdjIB11( UINT iMesh ) +ID3D11Buffer* CDXUTSDKMesh::GetAdjIB11( _In_ UINT iMesh ) const { return m_pAdjacencyIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].pIB11; } //-------------------------------------------------------------------------------------- -D3DPRIMITIVETYPE CDXUTSDKMesh::GetPrimitiveType9( SDKMESH_PRIMITIVE_TYPE PrimType ) -{ - D3DPRIMITIVETYPE retType = D3DPT_TRIANGLELIST; - - switch( PrimType ) - { - case PT_TRIANGLE_LIST: - retType = D3DPT_TRIANGLELIST; - break; - case PT_TRIANGLE_STRIP: - retType = D3DPT_TRIANGLESTRIP; - break; - case PT_LINE_LIST: - retType = D3DPT_LINELIST; - break; - case PT_LINE_STRIP: - retType = D3DPT_LINESTRIP; - break; - case PT_POINT_LIST: - retType = D3DPT_POINTLIST; - break; - }; - - return retType; -} - -//-------------------------------------------------------------------------------------- -D3DFORMAT CDXUTSDKMesh::GetIBFormat9( UINT iMesh ) -{ - switch( m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].IndexType ) - { - case IT_16BIT: - return D3DFMT_INDEX16; - case IT_32BIT: - return D3DFMT_INDEX32; - }; - return D3DFMT_INDEX16; -} - -//-------------------------------------------------------------------------------------- -IDirect3DVertexBuffer9* CDXUTSDKMesh::GetVB9( UINT iMesh, UINT iVB ) -{ - return m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].pVB9; -} - -//-------------------------------------------------------------------------------------- -IDirect3DIndexBuffer9* CDXUTSDKMesh::GetIB9( UINT iMesh ) -{ - return m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].pIB9; -} - -//-------------------------------------------------------------------------------------- -char* CDXUTSDKMesh::GetMeshPathA() +const char* CDXUTSDKMesh::GetMeshPathA() const { return m_strPath; } //-------------------------------------------------------------------------------------- -WCHAR* CDXUTSDKMesh::GetMeshPathW() +const WCHAR* CDXUTSDKMesh::GetMeshPathW() const { return m_strPathW; } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetNumMeshes() +UINT CDXUTSDKMesh::GetNumMeshes() const { if( !m_pMeshHeader ) return 0; @@ -1396,7 +1036,7 @@ UINT CDXUTSDKMesh::GetNumMeshes() } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetNumMaterials() +UINT CDXUTSDKMesh::GetNumMaterials() const { if( !m_pMeshHeader ) return 0; @@ -1404,7 +1044,7 @@ UINT CDXUTSDKMesh::GetNumMaterials() } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetNumVBs() +UINT CDXUTSDKMesh::GetNumVBs() const { if( !m_pMeshHeader ) return 0; @@ -1412,7 +1052,7 @@ UINT CDXUTSDKMesh::GetNumVBs() } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetNumIBs() +UINT CDXUTSDKMesh::GetNumIBs() const { if( !m_pMeshHeader ) return 0; @@ -1420,86 +1060,74 @@ UINT CDXUTSDKMesh::GetNumIBs() } //-------------------------------------------------------------------------------------- -ID3D11Buffer* CDXUTSDKMesh::GetVB11At( UINT iVB ) +ID3D11Buffer* CDXUTSDKMesh::GetVB11At( _In_ UINT iVB ) const { return m_pVertexBufferArray[ iVB ].pVB11; } //-------------------------------------------------------------------------------------- -ID3D11Buffer* CDXUTSDKMesh::GetIB11At( UINT iIB ) +ID3D11Buffer* CDXUTSDKMesh::GetIB11At( _In_ UINT iIB ) const { return m_pIndexBufferArray[ iIB ].pIB11; } //-------------------------------------------------------------------------------------- -IDirect3DVertexBuffer9* CDXUTSDKMesh::GetVB9At( UINT iVB ) -{ - return m_pVertexBufferArray[ iVB ].pVB9; -} - -//-------------------------------------------------------------------------------------- -IDirect3DIndexBuffer9* CDXUTSDKMesh::GetIB9At( UINT iIB ) -{ - return m_pIndexBufferArray[ iIB ].pIB9; -} - -//-------------------------------------------------------------------------------------- -BYTE* CDXUTSDKMesh::GetRawVerticesAt( UINT iVB ) +BYTE* CDXUTSDKMesh::GetRawVerticesAt( _In_ UINT iVB ) const { return m_ppVertices[iVB]; } //-------------------------------------------------------------------------------------- -BYTE* CDXUTSDKMesh::GetRawIndicesAt( UINT iIB ) +BYTE* CDXUTSDKMesh::GetRawIndicesAt( _In_ UINT iIB ) const { return m_ppIndices[iIB]; } //-------------------------------------------------------------------------------------- -SDKMESH_MATERIAL* CDXUTSDKMesh::GetMaterial( UINT iMaterial ) +SDKMESH_MATERIAL* CDXUTSDKMesh::GetMaterial( _In_ UINT iMaterial ) const { return &m_pMaterialArray[ iMaterial ]; } //-------------------------------------------------------------------------------------- -SDKMESH_MESH* CDXUTSDKMesh::GetMesh( UINT iMesh ) +SDKMESH_MESH* CDXUTSDKMesh::GetMesh( _In_ UINT iMesh ) const { return &m_pMeshArray[ iMesh ]; } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetNumSubsets( UINT iMesh ) +UINT CDXUTSDKMesh::GetNumSubsets( _In_ UINT iMesh ) const { return m_pMeshArray[ iMesh ].NumSubsets; } //-------------------------------------------------------------------------------------- -SDKMESH_SUBSET* CDXUTSDKMesh::GetSubset( UINT iMesh, UINT iSubset ) +SDKMESH_SUBSET* CDXUTSDKMesh::GetSubset( _In_ UINT iMesh, _In_ UINT iSubset ) const { return &m_pSubsetArray[ m_pMeshArray[ iMesh ].pSubsets[iSubset] ]; } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetVertexStride( UINT iMesh, UINT iVB ) +UINT CDXUTSDKMesh::GetVertexStride( _In_ UINT iMesh, _In_ UINT iVB ) const { return ( UINT )m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].StrideBytes; } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetNumFrames() +UINT CDXUTSDKMesh::GetNumFrames() const { return m_pMeshHeader->NumFrames; } //-------------------------------------------------------------------------------------- -SDKMESH_FRAME* CDXUTSDKMesh::GetFrame( UINT iFrame ) +SDKMESH_FRAME* CDXUTSDKMesh::GetFrame( _In_ UINT iFrame ) const { assert( iFrame < m_pMeshHeader->NumFrames ); return &m_pFrameArray[ iFrame ]; } //-------------------------------------------------------------------------------------- -SDKMESH_FRAME* CDXUTSDKMesh::FindFrame( char* pszName ) +SDKMESH_FRAME* CDXUTSDKMesh::FindFrame( _In_z_ const char* pszName ) const { for( UINT i = 0; i < m_pMeshHeader->NumFrames; i++ ) { @@ -1508,35 +1136,35 @@ SDKMESH_FRAME* CDXUTSDKMesh::FindFrame( char* pszName ) return &m_pFrameArray[i]; } } - return NULL; + return nullptr; } //-------------------------------------------------------------------------------------- -UINT64 CDXUTSDKMesh::GetNumVertices( UINT iMesh, UINT iVB ) +UINT64 CDXUTSDKMesh::GetNumVertices( _In_ UINT iMesh, _In_ UINT iVB ) const { return m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].NumVertices; } //-------------------------------------------------------------------------------------- -UINT64 CDXUTSDKMesh::GetNumIndices( UINT iMesh ) +UINT64 CDXUTSDKMesh::GetNumIndices( _In_ UINT iMesh ) const { return m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].NumIndices; } //-------------------------------------------------------------------------------------- -D3DXVECTOR3 CDXUTSDKMesh::GetMeshBBoxCenter( UINT iMesh ) +XMVECTOR CDXUTSDKMesh::GetMeshBBoxCenter( _In_ UINT iMesh ) const { - return m_pMeshArray[iMesh].BoundingBoxCenter; + return XMLoadFloat3( &m_pMeshArray[iMesh].BoundingBoxCenter ); } //-------------------------------------------------------------------------------------- -D3DXVECTOR3 CDXUTSDKMesh::GetMeshBBoxExtents( UINT iMesh ) +XMVECTOR CDXUTSDKMesh::GetMeshBBoxExtents( _In_ UINT iMesh ) const { - return m_pMeshArray[iMesh].BoundingBoxExtents; + return XMLoadFloat3( &m_pMeshArray[iMesh].BoundingBoxExtents ); } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetOutstandingResources() +UINT CDXUTSDKMesh::GetOutstandingResources() const { UINT outstandingResources = 0; if( !m_pMeshHeader ) @@ -1544,9 +1172,9 @@ UINT CDXUTSDKMesh::GetOutstandingResources() outstandingResources += GetOutstandingBufferResources(); - if( m_pDev11 ) - { - for( UINT i = 0; i < m_pMeshHeader->NumMaterials; i++ ) + if( m_pDev11 ) + { + for( UINT i = 0; i < m_pMeshHeader->NumMaterials; i++ ) { if( m_pMaterialArray[i].DiffuseTexture[0] != 0 ) { @@ -1566,54 +1194,18 @@ UINT CDXUTSDKMesh::GetOutstandingResources() outstandingResources ++; } } - } - else - { - for( UINT i = 0; i < m_pMeshHeader->NumMaterials; i++ ) - { - if( m_pMaterialArray[i].DiffuseTexture[0] != 0 ) - { - if( !m_pMaterialArray[i].pDiffuseTexture9 && !IsErrorResource( m_pMaterialArray[i].pDiffuseTexture9 ) ) - outstandingResources ++; - } - - if( m_pMaterialArray[i].NormalTexture[0] != 0 ) - { - if( !m_pMaterialArray[i].pNormalTexture9 && !IsErrorResource( m_pMaterialArray[i].pNormalTexture9 ) ) - outstandingResources ++; - } - - if( m_pMaterialArray[i].SpecularTexture[0] != 0 ) - { - if( !m_pMaterialArray[i].pSpecularTexture9 && - !IsErrorResource( m_pMaterialArray[i].pSpecularTexture9 ) ) - outstandingResources ++; - } - } } return outstandingResources; } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetOutstandingBufferResources() +UINT CDXUTSDKMesh::GetOutstandingBufferResources() const { UINT outstandingResources = 0; if( !m_pMeshHeader ) return 1; - for( UINT i = 0; i < m_pMeshHeader->NumVertexBuffers; i++ ) - { - if( !m_pVertexBufferArray[i].pVB9 && !IsErrorResource( m_pVertexBufferArray[i].pVB9 ) ) - outstandingResources ++; - } - - for( UINT i = 0; i < m_pMeshHeader->NumIndexBuffers; i++ ) - { - if( !m_pIndexBufferArray[i].pIB9 && !IsErrorResource( m_pIndexBufferArray[i].pIB9 ) ) - outstandingResources ++; - } - return outstandingResources; } @@ -1630,7 +1222,7 @@ bool CDXUTSDKMesh::CheckLoadDone() } //-------------------------------------------------------------------------------------- -bool CDXUTSDKMesh::IsLoaded() +bool CDXUTSDKMesh::IsLoaded() const { if( m_pStaticMeshData && !m_bLoading ) { @@ -1641,65 +1233,51 @@ bool CDXUTSDKMesh::IsLoaded() } //-------------------------------------------------------------------------------------- -bool CDXUTSDKMesh::IsLoading() +bool CDXUTSDKMesh::IsLoading() const { return m_bLoading; } //-------------------------------------------------------------------------------------- -void CDXUTSDKMesh::SetLoading( bool bLoading ) +void CDXUTSDKMesh::SetLoading( _In_ bool bLoading ) { m_bLoading = bLoading; } //-------------------------------------------------------------------------------------- -BOOL CDXUTSDKMesh::HadLoadingError() +BOOL CDXUTSDKMesh::HadLoadingError() const { - if( m_pMeshHeader ) - { - for( UINT i = 0; i < m_pMeshHeader->NumVertexBuffers; i++ ) - { - if( IsErrorResource( m_pVertexBufferArray[i].pVB9 ) ) - return TRUE; - } - - for( UINT i = 0; i < m_pMeshHeader->NumIndexBuffers; i++ ) - { - if( IsErrorResource( m_pIndexBufferArray[i].pIB9 ) ) - return TRUE; - } - } - return FALSE; } //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetNumInfluences( UINT iMesh ) +UINT CDXUTSDKMesh::GetNumInfluences( _In_ UINT iMesh ) const { return m_pMeshArray[iMesh].NumFrameInfluences; } //-------------------------------------------------------------------------------------- -const D3DXMATRIX* CDXUTSDKMesh::GetMeshInfluenceMatrix( UINT iMesh, UINT iInfluence ) +XMMATRIX CDXUTSDKMesh::GetMeshInfluenceMatrix( _In_ UINT iMesh, _In_ UINT iInfluence ) const { UINT iFrame = m_pMeshArray[iMesh].pFrameInfluences[ iInfluence ]; - return &m_pTransformedFrameMatrices[iFrame]; + return XMLoadFloat4x4( &m_pTransformedFrameMatrices[iFrame] ); } -const D3DXMATRIX* CDXUTSDKMesh::GetWorldMatrix( UINT iFrameIndex ) +XMMATRIX CDXUTSDKMesh::GetWorldMatrix( _In_ UINT iFrameIndex ) const { - return &m_pWorldPoseFrameMatrices[iFrameIndex]; + return XMLoadFloat4x4( &m_pWorldPoseFrameMatrices[iFrameIndex] ); } -const D3DXMATRIX* CDXUTSDKMesh::GetInfluenceMatrix( UINT iFrameIndex ) +XMMATRIX CDXUTSDKMesh::GetInfluenceMatrix( _In_ UINT iFrameIndex ) const { - return &m_pTransformedFrameMatrices[iFrameIndex]; + return XMLoadFloat4x4( &m_pTransformedFrameMatrices[iFrameIndex] ); } + //-------------------------------------------------------------------------------------- -UINT CDXUTSDKMesh::GetAnimationKeyFromTime( double fTime ) +UINT CDXUTSDKMesh::GetAnimationKeyFromTime( _In_ double fTime ) const { - if( m_pAnimationHeader == NULL ) + if( !m_pAnimationHeader ) { return 0; } @@ -1712,638 +1290,18 @@ UINT CDXUTSDKMesh::GetAnimationKeyFromTime( double fTime ) return iTick; } -bool CDXUTSDKMesh::GetAnimationProperties( UINT* pNumKeys, FLOAT* pFrameTime ) +_Use_decl_annotations_ +bool CDXUTSDKMesh::GetAnimationProperties( UINT* pNumKeys, float* pFrameTime ) const { - if( m_pAnimationHeader == NULL ) + if( !m_pAnimationHeader ) { + *pNumKeys = 0; + *pFrameTime = 0; return false; } *pNumKeys = m_pAnimationHeader->NumAnimationKeys; - *pFrameTime = 1.0f / (FLOAT)m_pAnimationHeader->AnimationFPS; + *pFrameTime = 1.0f / (float)m_pAnimationHeader->AnimationFPS; return true; } - - -//------------------------------------------------------------------------------------- -// CDXUTXFileMesh implementation. -//------------------------------------------------------------------------------------- - -//----------------------------------------------------------------------------- -CDXUTXFileMesh::CDXUTXFileMesh( LPCWSTR strName ) -{ - wcscpy_s( m_strName, 512, strName ); - m_pMesh = NULL; - m_pMaterials = NULL; - m_pTextures = NULL; - m_bUseMaterials = TRUE; - m_pVB = NULL; - m_pIB = NULL; - m_pDecl = NULL; - m_strMaterials = NULL; - m_dwNumMaterials = 0; - m_dwNumVertices = 0; - m_dwNumFaces = 0; - m_dwBytesPerVertex = 0; -} - - - - -//----------------------------------------------------------------------------- -CDXUTXFileMesh::~CDXUTXFileMesh() -{ - Destroy(); -} - - - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice, LPCWSTR strFilename ) -{ - WCHAR strPath[MAX_PATH]; - LPD3DXBUFFER pAdjacencyBuffer = NULL; - LPD3DXBUFFER pMtrlBuffer = NULL; - HRESULT hr; - - // Cleanup previous mesh if any - Destroy(); - - // Find the path for the file, and convert it to ANSI (for the D3DX API) - DXUTFindDXSDKMediaFileCch( strPath, sizeof( strPath ) / sizeof( WCHAR ), strFilename ); - - // Load the mesh - if( FAILED( hr = D3DXLoadMeshFromX( strPath, D3DXMESH_MANAGED, pd3dDevice, - &pAdjacencyBuffer, &pMtrlBuffer, NULL, - &m_dwNumMaterials, &m_pMesh ) ) ) - { - return hr; - } - - // Optimize the mesh for performance - if( FAILED( hr = m_pMesh->OptimizeInplace( - D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, - ( DWORD* )pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) ) - { - SAFE_RELEASE( pAdjacencyBuffer ); - SAFE_RELEASE( pMtrlBuffer ); - return hr; - } - - // Set strPath to the path of the mesh file - WCHAR* pLastBSlash = wcsrchr( strPath, L'\\' ); - if( pLastBSlash ) - *( pLastBSlash + 1 ) = L'\0'; - else - *strPath = L'\0'; - - D3DXMATERIAL* d3dxMtrls = ( D3DXMATERIAL* )pMtrlBuffer->GetBufferPointer(); - hr = CreateMaterials( strPath, pd3dDevice, d3dxMtrls, m_dwNumMaterials ); - - SAFE_RELEASE( pAdjacencyBuffer ); - SAFE_RELEASE( pMtrlBuffer ); - - // Extract data from m_pMesh for easy access - D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE]; - m_dwNumVertices = m_pMesh->GetNumVertices(); - m_dwNumFaces = m_pMesh->GetNumFaces(); - m_dwBytesPerVertex = m_pMesh->GetNumBytesPerVertex(); - m_pMesh->GetIndexBuffer( &m_pIB ); - m_pMesh->GetVertexBuffer( &m_pVB ); - m_pMesh->GetDeclaration( decl ); - pd3dDevice->CreateVertexDeclaration( decl, &m_pDecl ); - - return hr; -} - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice, - LPD3DXFILEDATA pFileData ) -{ - LPD3DXBUFFER pMtrlBuffer = NULL; - LPD3DXBUFFER pAdjacencyBuffer = NULL; - HRESULT hr; - - // Cleanup previous mesh if any - Destroy(); - - // Load the mesh from the DXFILEDATA object - if( FAILED( hr = D3DXLoadMeshFromXof( pFileData, D3DXMESH_MANAGED, pd3dDevice, - &pAdjacencyBuffer, &pMtrlBuffer, NULL, - &m_dwNumMaterials, &m_pMesh ) ) ) - { - return hr; - } - - // Optimize the mesh for performance - if( FAILED( hr = m_pMesh->OptimizeInplace( - D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, - ( DWORD* )pAdjacencyBuffer->GetBufferPointer(), NULL, NULL, NULL ) ) ) - { - SAFE_RELEASE( pAdjacencyBuffer ); - SAFE_RELEASE( pMtrlBuffer ); - return hr; - } - - D3DXMATERIAL* d3dxMtrls = ( D3DXMATERIAL* )pMtrlBuffer->GetBufferPointer(); - hr = CreateMaterials( L"", pd3dDevice, d3dxMtrls, m_dwNumMaterials ); - - SAFE_RELEASE( pAdjacencyBuffer ); - SAFE_RELEASE( pMtrlBuffer ); - - // Extract data from m_pMesh for easy access - D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE]; - m_dwNumVertices = m_pMesh->GetNumVertices(); - m_dwNumFaces = m_pMesh->GetNumFaces(); - m_dwBytesPerVertex = m_pMesh->GetNumBytesPerVertex(); - m_pMesh->GetIndexBuffer( &m_pIB ); - m_pMesh->GetVertexBuffer( &m_pVB ); - m_pMesh->GetDeclaration( decl ); - pd3dDevice->CreateVertexDeclaration( decl, &m_pDecl ); - - return hr; -} - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::Create( LPDIRECT3DDEVICE9 pd3dDevice, ID3DXMesh* pInMesh, - D3DXMATERIAL* pd3dxMaterials, DWORD dwMaterials ) -{ - // Cleanup previous mesh if any - Destroy(); - - // Optimize the mesh for performance - DWORD* rgdwAdjacency = NULL; - rgdwAdjacency = new DWORD[pInMesh->GetNumFaces() * 3]; - if( rgdwAdjacency == NULL ) - return E_OUTOFMEMORY; - pInMesh->GenerateAdjacency( 1e-6f, rgdwAdjacency ); - - D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE]; - pInMesh->GetDeclaration( decl ); - - DWORD dwOptions = pInMesh->GetOptions(); - dwOptions &= ~( D3DXMESH_32BIT | D3DXMESH_SYSTEMMEM | D3DXMESH_WRITEONLY ); - dwOptions |= D3DXMESH_MANAGED; - dwOptions |= D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE; - - ID3DXMesh* pTempMesh = NULL; - if( FAILED( pInMesh->Optimize( dwOptions, rgdwAdjacency, NULL, NULL, NULL, &pTempMesh ) ) ) - { - SAFE_DELETE_ARRAY( rgdwAdjacency ); - return E_FAIL; - } - - SAFE_DELETE_ARRAY( rgdwAdjacency ); - SAFE_RELEASE( m_pMesh ); - m_pMesh = pTempMesh; - - HRESULT hr; - hr = CreateMaterials( L"", pd3dDevice, pd3dxMaterials, dwMaterials ); - - // Extract data from m_pMesh for easy access - m_dwNumVertices = m_pMesh->GetNumVertices(); - m_dwNumFaces = m_pMesh->GetNumFaces(); - m_dwBytesPerVertex = m_pMesh->GetNumBytesPerVertex(); - m_pMesh->GetIndexBuffer( &m_pIB ); - m_pMesh->GetVertexBuffer( &m_pVB ); - m_pMesh->GetDeclaration( decl ); - pd3dDevice->CreateVertexDeclaration( decl, &m_pDecl ); - - return hr; -} - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::CreateMaterials( LPCWSTR strPath, IDirect3DDevice9* pd3dDevice, D3DXMATERIAL* d3dxMtrls, - DWORD dwNumMaterials ) -{ - // Get material info for the mesh - // Get the array of materials out of the buffer - m_dwNumMaterials = dwNumMaterials; - if( d3dxMtrls && m_dwNumMaterials > 0 ) - { - // Allocate memory for the materials and textures - m_pMaterials = new D3DMATERIAL9[m_dwNumMaterials]; - if( m_pMaterials == NULL ) - return E_OUTOFMEMORY; - m_pTextures = new LPDIRECT3DBASETEXTURE9[m_dwNumMaterials]; - if( m_pTextures == NULL ) - return E_OUTOFMEMORY; - m_strMaterials = new CHAR[m_dwNumMaterials][MAX_PATH]; - if( m_strMaterials == NULL ) - return E_OUTOFMEMORY; - - // Copy each material and create its texture - for( DWORD i = 0; i < m_dwNumMaterials; i++ ) - { - // Copy the material - m_pMaterials[i] = d3dxMtrls[i].MatD3D; - m_pTextures[i] = NULL; - - // Create a texture - if( d3dxMtrls[i].pTextureFilename ) - { - strcpy_s( m_strMaterials[i], MAX_PATH, d3dxMtrls[i].pTextureFilename ); - - WCHAR strTexture[MAX_PATH]; - WCHAR strTextureTemp[MAX_PATH]; - D3DXIMAGE_INFO ImgInfo; - - // First attempt to look for texture in the same folder as the input folder. - MultiByteToWideChar( CP_ACP, 0, d3dxMtrls[i].pTextureFilename, -1, strTextureTemp, MAX_PATH ); - strTextureTemp[MAX_PATH - 1] = 0; - - wcscpy_s( strTexture, MAX_PATH, strPath ); - wcscat_s( strTexture, MAX_PATH, strTextureTemp ); - - // Inspect the texture file to determine the texture type. - if( FAILED( D3DXGetImageInfoFromFile( strTexture, &ImgInfo ) ) ) - { - // Search the media folder - if( FAILED( DXUTFindDXSDKMediaFileCch( strTexture, MAX_PATH, strTextureTemp ) ) ) - continue; // Can't find. Skip. - - D3DXGetImageInfoFromFile( strTexture, &ImgInfo ); - } - - // Call the appropriate loader according to the texture type. - switch( ImgInfo.ResourceType ) - { - case D3DRTYPE_TEXTURE: - { - IDirect3DTexture9* pTex; - if( SUCCEEDED( D3DXCreateTextureFromFile( pd3dDevice, strTexture, &pTex ) ) ) - { - // Obtain the base texture interface - pTex->QueryInterface( IID_IDirect3DBaseTexture9, ( LPVOID* )&m_pTextures[i] ); - // Release the specialized instance - pTex->Release(); - } - break; - } - case D3DRTYPE_CUBETEXTURE: - { - IDirect3DCubeTexture9* pTex; - if( SUCCEEDED( D3DXCreateCubeTextureFromFile( pd3dDevice, strTexture, &pTex ) ) ) - { - // Obtain the base texture interface - pTex->QueryInterface( IID_IDirect3DBaseTexture9, ( LPVOID* )&m_pTextures[i] ); - // Release the specialized instance - pTex->Release(); - } - break; - } - case D3DRTYPE_VOLUMETEXTURE: - { - IDirect3DVolumeTexture9* pTex; - if( SUCCEEDED( D3DXCreateVolumeTextureFromFile( pd3dDevice, strTexture, &pTex ) ) ) - { - // Obtain the base texture interface - pTex->QueryInterface( IID_IDirect3DBaseTexture9, ( LPVOID* )&m_pTextures[i] ); - // Release the specialized instance - pTex->Release(); - } - break; - } - } - } - } - } - return S_OK; -} - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::SetFVF( LPDIRECT3DDEVICE9 pd3dDevice, DWORD dwFVF ) -{ - LPD3DXMESH pTempMesh = NULL; - - if( m_pMesh ) - { - if( FAILED( m_pMesh->CloneMeshFVF( m_pMesh->GetOptions(), dwFVF, - pd3dDevice, &pTempMesh ) ) ) - { - SAFE_RELEASE( pTempMesh ); - return E_FAIL; - } - - DWORD dwOldFVF = 0; - dwOldFVF = m_pMesh->GetFVF(); - SAFE_RELEASE( m_pMesh ); - m_pMesh = pTempMesh; - - // Compute normals if they are being requested and - // the old mesh does not have them. - if( !( dwOldFVF & D3DFVF_NORMAL ) && dwFVF & D3DFVF_NORMAL ) - { - D3DXComputeNormals( m_pMesh, NULL ); - } - } - - return S_OK; -} - - - - -//----------------------------------------------------------------------------- -// Convert the mesh to the format specified by the given vertex declarations. -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::SetVertexDecl( LPDIRECT3DDEVICE9 pd3dDevice, const D3DVERTEXELEMENT9* pDecl, - bool bAutoComputeNormals, bool bAutoComputeTangents, - bool bSplitVertexForOptimalTangents ) -{ - LPD3DXMESH pTempMesh = NULL; - - if( m_pMesh ) - { - if( FAILED( m_pMesh->CloneMesh( m_pMesh->GetOptions(), pDecl, - pd3dDevice, &pTempMesh ) ) ) - { - SAFE_RELEASE( pTempMesh ); - return E_FAIL; - } - } - - - // Check if the old declaration contains a normal. - bool bHadNormal = false; - bool bHadTangent = false; - D3DVERTEXELEMENT9 aOldDecl[MAX_FVF_DECL_SIZE]; - if( m_pMesh && SUCCEEDED( m_pMesh->GetDeclaration( aOldDecl ) ) ) - { - for( UINT index = 0; index < D3DXGetDeclLength( aOldDecl ); ++index ) - { - if( aOldDecl[index].Usage == D3DDECLUSAGE_NORMAL ) - { - bHadNormal = true; - } - if( aOldDecl[index].Usage == D3DDECLUSAGE_TANGENT ) - { - bHadTangent = true; - } - } - } - - // Check if the new declaration contains a normal. - bool bHaveNormalNow = false; - bool bHaveTangentNow = false; - D3DVERTEXELEMENT9 aNewDecl[MAX_FVF_DECL_SIZE]; - if( pTempMesh && SUCCEEDED( pTempMesh->GetDeclaration( aNewDecl ) ) ) - { - for( UINT index = 0; index < D3DXGetDeclLength( aNewDecl ); ++index ) - { - if( aNewDecl[index].Usage == D3DDECLUSAGE_NORMAL ) - { - bHaveNormalNow = true; - } - if( aNewDecl[index].Usage == D3DDECLUSAGE_TANGENT ) - { - bHaveTangentNow = true; - } - } - } - - SAFE_RELEASE( m_pMesh ); - - if( pTempMesh ) - { - m_pMesh = pTempMesh; - - if( !bHadNormal && bHaveNormalNow && bAutoComputeNormals ) - { - // Compute normals in case the meshes have them - D3DXComputeNormals( m_pMesh, NULL ); - } - - if( bHaveNormalNow && !bHadTangent && bHaveTangentNow && bAutoComputeTangents ) - { - ID3DXMesh* pNewMesh; - HRESULT hr; - - DWORD* rgdwAdjacency = NULL; - rgdwAdjacency = new DWORD[m_pMesh->GetNumFaces() * 3]; - if( rgdwAdjacency == NULL ) - return E_OUTOFMEMORY; - V( m_pMesh->GenerateAdjacency( 1e-6f, rgdwAdjacency ) ); - - float fPartialEdgeThreshold; - float fSingularPointThreshold; - float fNormalEdgeThreshold; - if( bSplitVertexForOptimalTangents ) - { - fPartialEdgeThreshold = 0.01f; - fSingularPointThreshold = 0.25f; - fNormalEdgeThreshold = 0.01f; - } - else - { - fPartialEdgeThreshold = -1.01f; - fSingularPointThreshold = 0.01f; - fNormalEdgeThreshold = -1.01f; - } - - // Compute tangents, which are required for normal mapping - hr = D3DXComputeTangentFrameEx( m_pMesh, - D3DDECLUSAGE_TEXCOORD, 0, - D3DDECLUSAGE_TANGENT, 0, - D3DX_DEFAULT, 0, - D3DDECLUSAGE_NORMAL, 0, - 0, rgdwAdjacency, - fPartialEdgeThreshold, fSingularPointThreshold, fNormalEdgeThreshold, - &pNewMesh, NULL ); - - SAFE_DELETE_ARRAY( rgdwAdjacency ); - if( FAILED( hr ) ) - return hr; - - SAFE_RELEASE( m_pMesh ); - m_pMesh = pNewMesh; - } - } - - return S_OK; -} - - - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::RestoreDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice ) -{ - return S_OK; -} - - - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::InvalidateDeviceObjects() -{ - SAFE_RELEASE( m_pIB ); - SAFE_RELEASE( m_pVB ); - SAFE_RELEASE( m_pDecl ); - - return S_OK; -} - - - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::Destroy() -{ - InvalidateDeviceObjects(); - for( UINT i = 0; i < m_dwNumMaterials; i++ ) - SAFE_RELEASE( m_pTextures[i] ); - SAFE_DELETE_ARRAY( m_pTextures ); - SAFE_DELETE_ARRAY( m_pMaterials ); - SAFE_DELETE_ARRAY( m_strMaterials ); - - SAFE_RELEASE( m_pMesh ); - - m_dwNumMaterials = 0L; - - return S_OK; -} - - - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::Render( LPDIRECT3DDEVICE9 pd3dDevice, bool bDrawOpaqueSubsets, - bool bDrawAlphaSubsets ) -{ - if( NULL == m_pMesh ) - return E_FAIL; - - // Frist, draw the subsets without alpha - if( bDrawOpaqueSubsets ) - { - for( DWORD i = 0; i < m_dwNumMaterials; i++ ) - { - if( m_bUseMaterials ) - { - if( m_pMaterials[i].Diffuse.a < 1.0f ) - continue; - pd3dDevice->SetMaterial( &m_pMaterials[i] ); - pd3dDevice->SetTexture( 0, m_pTextures[i] ); - } - m_pMesh->DrawSubset( i ); - } - } - - // Then, draw the subsets with alpha - if( bDrawAlphaSubsets && m_bUseMaterials ) - { - for( DWORD i = 0; i < m_dwNumMaterials; i++ ) - { - if( m_pMaterials[i].Diffuse.a == 1.0f ) - continue; - - // Set the material and texture - pd3dDevice->SetMaterial( &m_pMaterials[i] ); - pd3dDevice->SetTexture( 0, m_pTextures[i] ); - m_pMesh->DrawSubset( i ); - } - } - - return S_OK; -} - - - - -//----------------------------------------------------------------------------- -HRESULT CDXUTXFileMesh::Render( ID3DXEffect* pEffect, - D3DXHANDLE hTexture, - D3DXHANDLE hDiffuse, - D3DXHANDLE hAmbient, - D3DXHANDLE hSpecular, - D3DXHANDLE hEmissive, - D3DXHANDLE hPower, - bool bDrawOpaqueSubsets, - bool bDrawAlphaSubsets ) -{ - if( NULL == m_pMesh ) - return E_FAIL; - - UINT cPasses; - // Frist, draw the subsets without alpha - if( bDrawOpaqueSubsets ) - { - pEffect->Begin( &cPasses, 0 ); - for( UINT p = 0; p < cPasses; ++p ) - { - pEffect->BeginPass( p ); - for( DWORD i = 0; i < m_dwNumMaterials; i++ ) - { - if( m_bUseMaterials ) - { - if( m_pMaterials[i].Diffuse.a < 1.0f ) - continue; - if( hTexture ) - pEffect->SetTexture( hTexture, m_pTextures[i] ); - // D3DCOLORVALUE and D3DXVECTOR4 are data-wise identical. - // No conversion is needed. - if( hDiffuse ) - pEffect->SetVector( hDiffuse, ( D3DXVECTOR4* )&m_pMaterials[i].Diffuse ); - if( hAmbient ) - pEffect->SetVector( hAmbient, ( D3DXVECTOR4* )&m_pMaterials[i].Ambient ); - if( hSpecular ) - pEffect->SetVector( hSpecular, ( D3DXVECTOR4* )&m_pMaterials[i].Specular ); - if( hEmissive ) - pEffect->SetVector( hEmissive, ( D3DXVECTOR4* )&m_pMaterials[i].Emissive ); - if( hPower ) - pEffect->SetFloat( hPower, m_pMaterials[i].Power ); - pEffect->CommitChanges(); - } - m_pMesh->DrawSubset( i ); - } - pEffect->EndPass(); - } - pEffect->End(); - } - - // Then, draw the subsets with alpha - if( bDrawAlphaSubsets && m_bUseMaterials ) - { - pEffect->Begin( &cPasses, 0 ); - for( UINT p = 0; p < cPasses; ++p ) - { - pEffect->BeginPass( p ); - for( DWORD i = 0; i < m_dwNumMaterials; i++ ) - { - if( m_bUseMaterials ) - { - if( m_pMaterials[i].Diffuse.a == 1.0f ) - continue; - if( hTexture ) - pEffect->SetTexture( hTexture, m_pTextures[i] ); - // D3DCOLORVALUE and D3DXVECTOR4 are data-wise identical. - // No conversion is needed. - if( hDiffuse ) - pEffect->SetVector( hDiffuse, ( D3DXVECTOR4* )&m_pMaterials[i].Diffuse ); - if( hAmbient ) - pEffect->SetVector( hAmbient, ( D3DXVECTOR4* )&m_pMaterials[i].Ambient ); - if( hSpecular ) - pEffect->SetVector( hSpecular, ( D3DXVECTOR4* )&m_pMaterials[i].Specular ); - if( hEmissive ) - pEffect->SetVector( hEmissive, ( D3DXVECTOR4* )&m_pMaterials[i].Emissive ); - if( hPower ) - pEffect->SetFloat( hPower, m_pMaterials[i].Power ); - pEffect->CommitChanges(); - } - m_pMesh->DrawSubset( i ); - } - pEffect->EndPass(); - } - pEffect->End(); - } - - return S_OK; -} |