Picking up lastest bug fixes & SHA2 signing1.1.232

[SNG-2803] GFE-SDK : SHA-2 sign task

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;
-}