Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

3 files changed, 702 insertions, 0 deletions

diff --git a/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleMesh.cpp b/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleMesh.cpp
new file mode 100644
index 00000000..522b426f
--- /dev/null
+++ b/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleMesh.cpp
@@ -0,0 +1,225 @@
+// TAGRELEASE: PUBLIC
+#include <assert.h>
+
+// Direct3D9 includes
+#include <d3d9.h>
+
+// Direct3D11 includes
+#include <d3dcommon.h>
+#include <dxgi.h>
+#include <d3d11.h>
+#include <d3dcompiler.h>
+
+// XInput includes
+#include <xinput.h>
+
+#ifndef V
+#define V(x)           { hr = (x); }
+#endif
+#ifndef V_RETURN
+#define V_RETURN(x)    { hr = (x); if( FAILED(hr) ) { return hr; } }
+#endif
+
+#ifndef SAFE_DELETE
+#define SAFE_DELETE(p)       { if (p) { delete (p);     (p)=NULL; } }
+#endif
+#ifndef SAFE_DELETE_ARRAY
+#define SAFE_DELETE_ARRAY(p) { if (p) { delete[] (p);   (p)=NULL; } }
+#endif
+#ifndef SAFE_RELEASE
+#define SAFE_RELEASE(p)      { if (p) { (p)->Release(); (p)=NULL; } }
+#endif
+
+
+#include "strsafe.h"
+#include <string>
+
+#include "NvSimpleRawMesh.h"
+#include "NvSimpleMesh.h"
+#include "NvSimpleMeshLoader.h"
+
+NvSimpleMesh::NvSimpleMesh() :
+    iNumVertices(0),
+    iNumIndices(0),
+    IndexFormat(DXGI_FORMAT_R16_UINT),
+    VertexStride(0),
+    pVB(NULL),
+    pIB(NULL),
+    pDiffuseTexture(NULL),
+    pDiffuseSRV(NULL),
+    pNormalsTexture(NULL),
+    pNormalsSRV(NULL),
+    pInputLayout(NULL)
+{
+    memset(szName,0,260);
+}
+
+inline ID3D11ShaderResourceView * UtilCreateTexture2DSRV(ID3D11Device *pd3dDevice,ID3D11Texture2D *pTex)
+{
+    HRESULT hr;
+    ID3D11ShaderResourceView *pSRV = NULL;
+
+    D3D11_TEXTURE2D_DESC TexDesc;
+    ((ID3D11Texture2D*)pTex)->GetDesc(&TexDesc);
+
+    D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
+    ::ZeroMemory(&SRVDesc,sizeof(D3D11_SHADER_RESOURCE_VIEW_DESC));
+    SRVDesc.Texture2D.MipLevels = TexDesc.MipLevels;
+    SRVDesc.Texture2D.MostDetailedMip = 0;
+    SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+    SRVDesc.Format = TexDesc.Format;
+
+    hr = pd3dDevice->CreateShaderResourceView(pTex,&SRVDesc,&pSRV);
+
+    return pSRV;
+}
+
+HRESULT NvSimpleMesh::Initialize(ID3D11Device *pd3dDevice,NvSimpleRawMesh *pRawMesh)
+{
+    HRESULT hr = S_OK;
+    
+    if(pRawMesh)
+    {
+        memcpy(&Extents,pRawMesh->GetExtents(),3*sizeof(float));
+        memcpy(&Center,pRawMesh->GetCenter(),3*sizeof(float));
+
+        // Copy out d3d buffers and data for rendering and add references input mesh can be cleaned.
+        pVB = pRawMesh->CreateD3D11VertexBufferFor(pd3dDevice);
+        pIB = pRawMesh->CreateD3D11IndexBufferFor(pd3dDevice);
+        IndexFormat = pRawMesh->GetIndexSize()==2?DXGI_FORMAT_R16_UINT:DXGI_FORMAT_R32_UINT;
+        iNumIndices = pRawMesh->GetNumIndices();
+        iNumVertices = pRawMesh->GetNumVertices();
+        VertexStride = pRawMesh->GetVertexStride();
+
+        // Make a texture object and SRV for it.
+        pDiffuseTexture = pRawMesh->CreateD3D11DiffuseTextureFor(pd3dDevice);
+        if(pDiffuseTexture)
+            pDiffuseSRV = UtilCreateTexture2DSRV(pd3dDevice,pDiffuseTexture);
+        pNormalsTexture = pRawMesh->CreateD3D11NormalsTextureFor(pd3dDevice);
+        if(pNormalsTexture)
+            pNormalsSRV = UtilCreateTexture2DSRV(pd3dDevice,pNormalsTexture);
+    }
+
+    return hr;
+}
+
+HRESULT NvSimpleMesh::InitializeWithInputLayout(ID3D11Device *pd3dDevice,NvSimpleRawMesh *pRawMesh,BYTE*pIAsig, SIZE_T pIAsigSize)
+{
+    HRESULT hr = S_OK;
+    V_RETURN(CreateInputLayout(pd3dDevice,pIAsig,pIAsigSize));
+    V_RETURN(Initialize(pd3dDevice,pRawMesh));
+    return hr;
+}
+
+HRESULT NvSimpleMesh::CreateInputLayout(ID3D11Device *pd3dDevice,BYTE*pIAsig, SIZE_T pIAsigSize)
+{
+    HRESULT hr = S_OK;
+    SAFE_RELEASE(pInputLayout);
+    V_RETURN( pd3dDevice->CreateInputLayout( NvSimpleRawMesh::D3D11InputElements, NvSimpleRawMesh::D3D11ElementsSize, pIAsig, pIAsigSize, &pInputLayout ) );
+    return hr;
+}
+
+void NvSimpleMesh::Release()
+{
+    SAFE_RELEASE(pVB);
+    SAFE_RELEASE(pIB);
+    SAFE_RELEASE(pDiffuseTexture);
+    SAFE_RELEASE(pDiffuseSRV);
+    SAFE_RELEASE(pNormalsTexture);
+    SAFE_RELEASE(pNormalsSRV);
+    SAFE_RELEASE(pInputLayout);
+}
+
+void NvSimpleMesh::SetupDraw(ID3D11DeviceContext *pd3dContext, int iDiffuseTexSlot, int iNormalsTexSlot)
+{
+    if(iDiffuseTexSlot >= 0)
+        pd3dContext->PSSetShaderResources(iDiffuseTexSlot,1,&pDiffuseSRV);
+    if(iNormalsTexSlot >= 0)
+        pd3dContext->PSSetShaderResources(iNormalsTexSlot,1,&pNormalsSRV);
+
+    D3D11_PRIMITIVE_TOPOLOGY topology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
+
+    UINT Offsets[1];
+    UINT Strides[1];
+    ID3D11Buffer *ppVB[1];
+    Offsets[0] = 0;
+    Strides[0] = VertexStride;
+    ppVB[0] = pVB;
+
+    if(pInputLayout)    // optionally set an input layout if we have one
+        pd3dContext->IASetInputLayout(pInputLayout);
+    pd3dContext->IASetVertexBuffers(0,1,ppVB,Strides,Offsets);
+    pd3dContext->IASetIndexBuffer( pIB,IndexFormat, 0 );
+    pd3dContext->IASetPrimitiveTopology(topology);
+}
+
+void NvSimpleMesh::Draw(ID3D11DeviceContext *pd3dContext)
+{
+    if(!pVB) 
+    {
+        return;
+    }
+
+    pd3dContext->DrawIndexed(iNumIndices,0,0);
+}
+
+
+void NvSimpleMesh::DrawInstanced(ID3D11DeviceContext *pd3dContext, int iNumInstances)
+{
+    pd3dContext->DrawIndexedInstanced(iNumIndices,iNumInstances,0,0,0);
+}
+
+NvAggregateSimpleMesh::NvAggregateSimpleMesh()
+{
+    pSimpleMeshes = NULL;
+    NumSimpleMeshes = 0;
+}
+
+NvAggregateSimpleMesh::~NvAggregateSimpleMesh()
+{
+    SAFE_DELETE_ARRAY(pSimpleMeshes);
+}
+
+HRESULT NvAggregateSimpleMesh::Initialize(ID3D11Device *pd3dDevice,NvSimpleMeshLoader *pMeshLoader)
+{
+    HRESULT hr = S_OK;
+    if(pMeshLoader->pMeshes == NULL) return E_FAIL;
+    NumSimpleMeshes = pMeshLoader->NumMeshes;
+    pSimpleMeshes = new NvSimpleMesh[NumSimpleMeshes];
+    for(int iMesh=0;iMesh<NumSimpleMeshes;iMesh++)
+    {
+        V_RETURN(pSimpleMeshes[iMesh].Initialize(pd3dDevice,&pMeshLoader->pMeshes[iMesh]));
+    }
+    return hr;
+}
+HRESULT NvAggregateSimpleMesh::InitializeWithInputLayout(ID3D11Device *pd3dDevice,NvSimpleMeshLoader *pMeshLoader,BYTE*pIAsig, SIZE_T pIAsigSize)
+{
+    HRESULT hr = S_OK;
+    if(pMeshLoader->pMeshes == NULL) return E_FAIL;
+    NumSimpleMeshes = pMeshLoader->NumMeshes;
+    pSimpleMeshes = new NvSimpleMesh[NumSimpleMeshes];
+    for(int iMesh=0;iMesh<NumSimpleMeshes;iMesh++)
+    {
+        V_RETURN(pSimpleMeshes[iMesh].InitializeWithInputLayout(pd3dDevice,&pMeshLoader->pMeshes[iMesh],pIAsig,pIAsigSize));
+    }
+    return hr;
+}
+
+void NvAggregateSimpleMesh::Release()
+{
+    if(pSimpleMeshes == NULL) return;
+    for(int iMesh=0;iMesh<NumSimpleMeshes;iMesh++)
+    {
+        pSimpleMeshes[iMesh].Release();
+    }
+}
+
+void NvAggregateSimpleMesh::Draw(ID3D11DeviceContext *pd3dContext, int iDiffuseTexSlot, int iNormalsTexSlot)
+{
+    if(pSimpleMeshes == NULL) return;
+    for(int iMesh=0;iMesh<NumSimpleMeshes;iMesh++)
+    {
+        pSimpleMeshes[iMesh].SetupDraw(pd3dContext,iDiffuseTexSlot,iNormalsTexSlot);
+        pSimpleMeshes[iMesh].Draw(pd3dContext);
+    }
+}
diff --git a/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleMeshLoader.cpp b/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleMeshLoader.cpp
new file mode 100644
index 00000000..12a6152d
--- /dev/null
+++ b/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleMeshLoader.cpp
@@ -0,0 +1,256 @@
+// TAGRELEASE: PUBLIC
+#include <assert.h>
+
+// Direct3D9 includes
+#include <d3d9.h>
+
+// Direct3D11 includes
+#include <d3dcommon.h>
+#include <dxgi.h>
+#include <d3d11.h>
+#include <d3dcompiler.h>
+
+// XInput includes
+#include <xinput.h>
+
+#ifndef V
+#define V(x)           { hr = (x); }
+#endif
+#ifndef V_RETURN
+#define V_RETURN(x)    { hr = (x); if( FAILED(hr) ) { return hr; } }
+#endif
+
+#ifndef SAFE_DELETE
+#define SAFE_DELETE(p)       { if (p) { delete (p);     (p)=NULL; } }
+#endif
+#ifndef SAFE_DELETE_ARRAY
+#define SAFE_DELETE_ARRAY(p) { if (p) { delete[] (p);   (p)=NULL; } }
+#endif
+#ifndef SAFE_RELEASE
+#define SAFE_RELEASE(p)      { if (p) { (p)->Release(); (p)=NULL; } }
+#endif
+
+
+#include "strsafe.h"
+#include <string>
+
+#pragma warning(push)
+#pragma warning(disable: 4100)	// unreferenced formal parameter
+#include "assimp\assimp.hpp"
+#pragma warning(pop)
+#include "assimp\aiScene.h"
+#include "assimp\DefaultLogger.h"
+#include "assimp\aiPostProcess.h"
+#include "assimp\aiMesh.h"
+
+using namespace Assimp;
+
+#include "NvSimpleRawMesh.h"
+#include "NvSimpleMeshLoader.h"
+
+
+NvSimpleMeshLoader::NvSimpleMeshLoader()
+{
+    pMeshes = NULL;
+    NumMeshes = 0;
+}
+
+NvSimpleMeshLoader::~NvSimpleMeshLoader()
+{
+    SAFE_DELETE_ARRAY(pMeshes);
+}
+
+bool NvSimpleMeshLoader::LoadFile(LPWSTR szFilename)
+{
+    bool bLoaded = false;
+    (void)bLoaded;
+
+    // Create a logger instance 
+    Assimp::DefaultLogger::create("",Logger::VERBOSE);
+
+    // Create an instance of the Importer class
+    Assimp::Importer importer;
+
+    CHAR szFilenameA[MAX_PATH];
+    WideCharToMultiByte(CP_ACP,0,szFilename,MAX_PATH,szFilenameA,MAX_PATH,NULL,false);
+
+    mediaPath = szFilenameA;
+    auto index = mediaPath.find_last_of('\\');
+    if(index != -1)
+        mediaPath = mediaPath.substr(0,index) + "\\";
+    else
+        mediaPath = ".\\";
+
+    // Set some flags for the removal of various data that we don't use
+    importer.SetPropertyInteger("AI_CONFIG_PP_RVC_FLAGS",aiComponent_ANIMATIONS | aiComponent_BONEWEIGHTS | aiComponent_COLORS | aiComponent_LIGHTS | aiComponent_CAMERAS);
+    //importer.SetPropertyInteger("AI_CONFIG_PP_SBP_REMOVE",aiPrimitiveType_POINTS | aiPrimitiveType_LINES );
+
+    // load the scene and preprocess it into the form we want
+    const aiScene *scene = importer.ReadFile(szFilenameA,
+                                                aiProcess_Triangulate|    // only higher order primitives will be triangulated
+                                                aiProcess_GenNormals|    // if normals exist, will not be generated
+                                                aiProcess_CalcTangentSpace|
+                                                aiProcess_PreTransformVertices| // rolls all node hierarchy(if existant) into the local space of meshes
+                                                //aiProcess_RemoveRedundantMaterials|
+                                                //aiProcess_FixInfacingNormals|
+                                                aiProcess_FindDegenerates|
+                                                aiProcess_SortByPType|
+                                                aiProcess_RemoveComponent|    // processes the above flags set to remove data we don't want
+                                                aiProcess_FindInvalidData|
+                                                aiProcess_GenUVCoords|
+                                                aiProcess_TransformUVCoords|
+                                                aiProcess_OptimizeMeshes |
+
+                                                aiProcessPreset_TargetRealtime_Quality
+                                                );
+
+    // can't load?
+    if(!scene)
+        return false;
+
+    if(scene->HasMeshes())
+    {
+        pMeshes = new NvSimpleRawMesh[scene->mNumMeshes];
+        NumMeshes = scene->mNumMeshes;
+
+        DirectX::XMMATRIX identity = DirectX::XMMatrixIdentity();
+
+        RecurseAddMeshes(scene,scene->mRootNode,identity,true);
+    }
+
+    // cleanup
+    Assimp::DefaultLogger::kill();
+
+    return NumMeshes > 0;
+}
+
+void XM_CALLCONV NvSimpleMeshLoader::RecurseAddMeshes(const aiScene *scene, aiNode*pNode, DirectX::FXMMATRIX parentCompositeTransformD3D, bool bFlattenTransforms)
+{
+    // Convert the scene node's transform into DirectXMath, transposing it as we go
+    aiMatrix4x4* paiNodeTrans = &(pNode->mTransformation);
+    DirectX::XMFLOAT4X4 LocalFrameTransformXM(paiNodeTrans->a1, paiNodeTrans->b1, paiNodeTrans->c1, paiNodeTrans->d1,
+                                              paiNodeTrans->a2, paiNodeTrans->b2, paiNodeTrans->c2, paiNodeTrans->d2,
+                                              paiNodeTrans->a3, paiNodeTrans->b3, paiNodeTrans->c3, paiNodeTrans->d3,
+                                              paiNodeTrans->a4, paiNodeTrans->b4, paiNodeTrans->c4, paiNodeTrans->d4);
+
+    DirectX::XMMATRIX LocalFrameTransformD3D = DirectX::XMLoadFloat4x4(&LocalFrameTransformXM);
+    DirectX::XMMATRIX LocalCompositeTransformD3D = DirectX::XMMatrixMultiply(LocalFrameTransformD3D, parentCompositeTransformD3D);
+
+
+    DirectX::XMMATRIX* pActiveTransform = &LocalFrameTransformD3D;
+    if(bFlattenTransforms) pActiveTransform = &LocalCompositeTransformD3D;
+
+    if(pNode->mNumMeshes > 0)
+    {
+        for(int iSubMesh=0;iSubMesh < (int)pNode->mNumMeshes;iSubMesh++)
+        {
+            aiMesh *pMesh = scene->mMeshes[pNode->mMeshes[iSubMesh]];
+            NvSimpleRawMesh &activeMesh = pMeshes[pNode->mMeshes[iSubMesh]];    // we'll use the same ordering as the aiScene
+
+            float emin[3]; ::ZeroMemory(emin,3*sizeof(float));
+            float emax[3]; ::ZeroMemory(emax,3*sizeof(float));
+
+            if(pMesh->HasPositions() && pMesh->HasNormals() && pMesh->HasTextureCoords(0) && pMesh->HasTangentsAndBitangents())
+            {
+                activeMesh.m_iNumIndices = pMesh->mNumFaces*3;
+                activeMesh.m_iNumVertices = pMesh->mNumVertices;
+
+                // copy loaded mesh data into our vertex struct
+                activeMesh.m_pVertexData = new NvSimpleRawMesh::Vertex[pMesh->mNumVertices];
+                for(unsigned int i=0;i<pMesh->mNumVertices;i++)
+                {
+                    memcpy((void*)&(activeMesh.m_pVertexData[i].Position),(void*)&(pMesh->mVertices[i]),sizeof(aiVector3D));
+                    memcpy((void*)&(activeMesh.m_pVertexData[i].Normal),(void*)&(pMesh->mNormals[i]),sizeof(aiVector3D));
+                    memcpy((void*)&(activeMesh.m_pVertexData[i].Tangent),(void*)&(pMesh->mTangents[i]),sizeof(aiVector3D));
+                    memcpy((void*)&(activeMesh.m_pVertexData[i].UV),(void*)&(pMesh->mTextureCoords[0][i]),sizeof(aiVector2D));
+
+                    for(int m=0;m<3;m++)
+                    {
+                        emin[m] = min(emin[m],activeMesh.m_pVertexData[i].Position[m]);
+                        emax[m] = max(emin[m],activeMesh.m_pVertexData[i].Position[m]);
+                    }
+                }
+
+                // create an index buffer
+                activeMesh.m_IndexSize = sizeof(UINT16);
+                if(pMesh->mNumFaces > MAXINT16)
+                    activeMesh.m_IndexSize = sizeof(UINT32);
+
+                activeMesh.m_pIndexData = new BYTE[pMesh->mNumFaces * 3 * activeMesh.m_IndexSize];
+                for(unsigned int i=0;i<pMesh->mNumFaces;i++)
+                {
+                    assert(pMesh->mFaces[i].mNumIndices == 3);
+                    if(activeMesh.m_IndexSize == sizeof(UINT32))
+                    {
+                        memcpy((void*)&(activeMesh.m_pIndexData[i*3*activeMesh.m_IndexSize]),(void*)pMesh->mFaces[i].mIndices,sizeof(3*activeMesh.m_IndexSize));
+                    }
+                    else    // 16 bit indices
+                    {
+                        UINT16*pFaceIndices = (UINT16*)&(activeMesh.m_pIndexData[i*3*activeMesh.m_IndexSize]);
+                        pFaceIndices[0] = (UINT16)pMesh->mFaces[i].mIndices[0];
+                        pFaceIndices[1] = (UINT16)pMesh->mFaces[i].mIndices[1];
+                        pFaceIndices[2] = (UINT16)pMesh->mFaces[i].mIndices[2];
+                    }
+                }
+
+                // assign extents
+                activeMesh.m_extents[0] = (emax[0] - emin[0]) * 0.5f;
+                activeMesh.m_extents[1] = (emax[1] - emin[1]) * 0.5f;
+                activeMesh.m_extents[2] = (emax[2] - emin[2]) * 0.5f;
+
+                // get the center
+                activeMesh.m_center[0] = emin[0] + activeMesh.m_extents[0];
+                activeMesh.m_center[1] = emin[1] + activeMesh.m_extents[1];
+                activeMesh.m_center[2] = emin[2] + activeMesh.m_extents[2];
+
+                // materials
+                if(scene->HasMaterials())
+                {
+                    aiMaterial *pMaterial = scene->mMaterials[pMesh->mMaterialIndex];
+
+                    if(pMaterial->GetTextureCount(aiTextureType_DIFFUSE) > 0)
+                    {
+                        aiString texPath;
+                        pMaterial->GetTexture(aiTextureType_DIFFUSE,0,&texPath);
+
+                        CHAR szFilenameA[MAX_PATH];
+                        StringCchCopyA(szFilenameA,MAX_PATH,texPath.data);
+                        MultiByteToWideChar(CP_ACP,0,szFilenameA,MAX_PATH,activeMesh.m_szDiffuseTexture,MAX_PATH);
+
+                        //WCHAR szFullPath[MAX_PATH];
+                        //if(DXUTFindDXSDKMediaFileCch(szFullPath,MAX_PATH,activeMesh.m_szDiffuseTexture) != S_OK)
+                        {
+                            std::string qualifiedPath = mediaPath + texPath.data;
+
+                            StringCchCopyA(szFilenameA,MAX_PATH,qualifiedPath.c_str());
+                            MultiByteToWideChar(CP_ACP,0,szFilenameA,MAX_PATH,activeMesh.m_szDiffuseTexture,MAX_PATH);
+                        }    
+                    }
+                    if(pMaterial->GetTextureCount(aiTextureType_NORMALS) > 0)
+                    {
+                        aiString texPath;
+                        pMaterial->GetTexture(aiTextureType_NORMALS,0,&texPath);
+
+                        CHAR szFilenameA[MAX_PATH];
+                        StringCchCopyA(szFilenameA,MAX_PATH,texPath.data);
+                        MultiByteToWideChar(CP_ACP,0,szFilenameA,MAX_PATH,activeMesh.m_szNormalTexture,MAX_PATH);
+
+                        //WCHAR szFullPath[MAX_PATH];
+                        //if(DXUTFindDXSDKMediaFileCch(szFullPath,MAX_PATH,activeMesh.m_szNormalTexture) != S_OK)
+                        {
+                            std::string qualifiedPath = mediaPath + texPath.data;
+
+                            StringCchCopyA(szFilenameA,MAX_PATH,qualifiedPath.c_str());
+                            MultiByteToWideChar(CP_ACP,0,szFilenameA,MAX_PATH,activeMesh.m_szNormalTexture,MAX_PATH);
+                        }    
+                    }
+                }
+            }
+        }
+    }
+
+    for(int iChild=0;iChild<(int)pNode->mNumChildren;iChild++)
+    {
+        RecurseAddMeshes(scene, pNode->mChildren[iChild],LocalCompositeTransformD3D,bFlattenTransforms);
+    }
+}
diff --git a/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleRawMesh.cpp b/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleRawMesh.cpp
new file mode 100644
index 00000000..feaa11ac
--- /dev/null
+++ b/APEX_1.4/externals/extensions/src/nvsimplemesh/NvSimpleRawMesh.cpp
@@ -0,0 +1,221 @@
+// TAGRELEASE: PUBLIC
+
+#include <assert.h>
+
+// Direct3D9 includes
+#include <d3d9.h>
+
+// Direct3D11 includes
+#include <d3dcommon.h>
+#include <dxgi.h>
+#include <d3d11.h>
+#include <d3dcompiler.h>
+
+// DXUT Includes
+#include "dxut\Core\DDSTextureLoader.h"
+
+// XInput includes
+#include <xinput.h>
+
+#ifndef V
+#define V(x)           { hr = (x); }
+#endif
+#ifndef V_RETURN
+#define V_RETURN(x)    { hr = (x); if( FAILED(hr) ) { return hr; } }
+#endif
+
+#ifndef SAFE_DELETE
+#define SAFE_DELETE(p)       { if (p) { delete (p);     (p)=NULL; } }
+#endif
+#ifndef SAFE_DELETE_ARRAY
+#define SAFE_DELETE_ARRAY(p) { if (p) { delete[] (p);   (p)=NULL; } }
+#endif
+#ifndef SAFE_RELEASE
+#define SAFE_RELEASE(p)      { if (p) { (p)->Release(); (p)=NULL; } }
+#endif
+#include "strsafe.h"
+#include <string>
+#include "NvSimpleRawMesh.h"
+
+const D3D11_INPUT_ELEMENT_DESC NvSimpleRawMesh::D3D11InputElements[] =
+{
+    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,  0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+    { "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+    { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+    { "TANGENT",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 }
+};
+
+const int NvSimpleRawMesh::D3D11ElementsSize = sizeof(NvSimpleRawMesh::D3D11InputElements)/sizeof(D3D11_INPUT_ELEMENT_DESC);
+
+
+NvSimpleRawMesh::NvSimpleRawMesh() : 
+    m_pVertexData(NULL),
+    m_pIndexData(NULL),
+    m_iNumVertices(0),
+    m_iNumIndices(0),
+    m_IndexSize(sizeof(UINT16))
+{
+    m_szMeshFilename[0] = 0;
+    m_szDiffuseTexture[0] = 0;
+    m_szNormalTexture[0] = 0;
+
+    m_extents[0] = m_extents[1] = m_extents[2] = 0.f;
+    m_center[0] = m_center[1] = m_center[2] = 0.f;
+}
+
+
+NvSimpleRawMesh::~NvSimpleRawMesh()
+{
+    SAFE_DELETE_ARRAY(m_pVertexData);
+    SAFE_DELETE_ARRAY(m_pIndexData);
+}
+
+UINT NvSimpleRawMesh::GetIndexSize()
+{
+    return m_IndexSize;
+}
+
+INT NvSimpleRawMesh::GetVertexStride()
+{
+    return sizeof(Vertex);
+}
+INT NvSimpleRawMesh::GetNumVertices()
+{
+    return m_iNumVertices;
+}
+INT NvSimpleRawMesh::GetNumIndices()
+{
+    return m_iNumIndices;
+}
+
+BYTE * NvSimpleRawMesh::GetRawVertices()
+{
+    return (BYTE*)m_pVertexData;
+}
+
+NvSimpleRawMesh::Vertex * NvSimpleRawMesh::GetVertices()
+{
+    return m_pVertexData;
+}
+
+BYTE * NvSimpleRawMesh::GetRawIndices()
+{
+    return m_pIndexData;
+}
+
+HRESULT NvSimpleRawMesh::TryGuessFilename(WCHAR* /*szDestBuffer*/,WCHAR* /*szMeshFilename*/, WCHAR* /*szGuessSuffix*/)
+{
+    HRESULT hr = E_FAIL;
+
+/*
+    WCHAR szBaseFilename[MAX_PATH];
+    WCHAR szGuessFilename[MAX_PATH];
+    // Start with mesh file
+    StringCchCopyW(szBaseFilename,MAX_PATH,szMeshFilename);
+    size_t len = 0;
+    StringCchLength(szBaseFilename,MAX_PATH,&len);
+
+    // work backwards to first "." and null which strips extension
+    for(int i=(int)len-1;i>=0;i--) 
+    {
+        if(szBaseFilename[i] == L'.') {szBaseFilename[i] = 0; break;}
+    }
+
+    StringCchCopy(szGuessFilename,MAX_PATH,szBaseFilename);
+    StringCchCat(szGuessFilename,MAX_PATH,szGuessSuffix);
+
+    hr = DXUTFindDXSDKMediaFileCch(szDestBuffer,MAX_PATH,szGuessFilename);
+    */
+    return hr;
+}
+
+ID3D11Texture2D *NvSimpleRawMesh::CreateD3D11DiffuseTextureFor(ID3D11Device *pd3dDevice)
+{
+    HRESULT hr = S_OK;
+    //if(m_szDiffuseTexture[0] == 0) return NULL;
+/*
+    WCHAR szTextureFilename[MAX_PATH];
+
+    if(m_szDiffuseTexture[0] != 0)
+    {
+        hr = DXUTFindDXSDKMediaFileCch(szTextureFilename,MAX_PATH,m_szDiffuseTexture);
+    }
+
+    // Try to guess a file name in same location 
+    if(hr != S_OK)
+    {
+        hr = TryGuessFilename(szTextureFilename,m_szMeshFilename,L"_diffuse.dds");
+    }
+    */
+    ID3D11Resource *pTexture = NULL;
+    hr = DirectX::CreateDDSTextureFromFile(pd3dDevice, m_szDiffuseTexture, &pTexture, nullptr);
+
+    return (ID3D11Texture2D*)pTexture;
+}
+
+ID3D11Texture2D *NvSimpleRawMesh::CreateD3D11NormalsTextureFor(ID3D11Device *pd3dDevice)
+{
+    HRESULT hr = S_OK;
+    //if(m_szNormalTexture[0] == 0) return NULL;
+/*
+    WCHAR szTextureFilename[MAX_PATH];
+    
+
+    if(m_szNormalTexture[0] != 0)
+    {
+        hr = DXUTFindDXSDKMediaFileCch(szTextureFilename,MAX_PATH,m_szNormalTexture);
+    }
+
+    // Try to guess a file name in same location for normals
+    if(hr != S_OK)
+    {
+        hr = TryGuessFilename(szTextureFilename,m_szMeshFilename,L"_normals.dds");
+    }
+    if(hr != S_OK)
+    {
+        hr = TryGuessFilename(szTextureFilename,m_szDiffuseTexture,L"_nm.dds");
+    }
+    */
+    ID3D11Resource *pTexture = NULL;
+    hr = DirectX::CreateDDSTextureFromFile(pd3dDevice, m_szNormalTexture, &pTexture, nullptr);
+
+    return (ID3D11Texture2D*)pTexture;
+
+}
+
+ID3D11Buffer *NvSimpleRawMesh::CreateD3D11IndexBufferFor(ID3D11Device *pd3dDevice)
+{
+    ID3D11Buffer *pIB = NULL;
+
+    D3D11_BUFFER_DESC Desc;
+    ::ZeroMemory(&Desc,sizeof(D3D11_BUFFER_DESC));
+    Desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
+    Desc.ByteWidth = GetNumIndices() * GetIndexSize();
+    Desc.Usage = D3D11_USAGE_DEFAULT;
+
+    D3D11_SUBRESOURCE_DATA SubResData;
+    ::ZeroMemory(&SubResData,sizeof(D3D11_SUBRESOURCE_DATA));
+    SubResData.pSysMem = (void*)GetRawIndices();
+
+    pd3dDevice->CreateBuffer(&Desc,&SubResData,&pIB);
+
+    return pIB;
+}
+ID3D11Buffer *NvSimpleRawMesh::CreateD3D11VertexBufferFor(ID3D11Device *pd3dDevice)
+{
+    ID3D11Buffer *pVB = NULL;
+
+    D3D11_BUFFER_DESC Desc;
+    ::ZeroMemory(&Desc,sizeof(D3D11_BUFFER_DESC));
+    Desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+    Desc.ByteWidth = GetNumVertices() * GetVertexStride();
+    Desc.Usage = D3D11_USAGE_DEFAULT;
+
+    D3D11_SUBRESOURCE_DATA SubResData;
+    ::ZeroMemory(&SubResData,sizeof(D3D11_SUBRESOURCE_DATA));
+    SubResData.pSysMem = (void*)GetRawVertices();
+
+    pd3dDevice->CreateBuffer(&Desc,&SubResData,&pVB);
+
+    return pVB;
+}
\ No newline at end of file