Minor update - frustum rework

Complete overhaul of frustum culling

.gitignore

@@ -12,11 +12,7 @@
 *.obj
 
 # Don't ignore 3d model in OBJ
-!enginecustom/monke.obj
-!enginecustom/isosphere.obj
-!enginecustom/cone.obj
-!enginecustom/vaisseau.obj
-!enginecustom/86.obj
+!enginecustom/assets/Model/OBJ/*.obj
 
 # Precompiled Headers
 *.gch

.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "C/C++ Runner: Debug Session",
+      "type": "cppdbg",
+      "request": "launch",
+      "args": [],
+      "stopAtEntry": false,
+      "externalConsole": true,
+      "cwd": "c:/Users/arivas/Documents/GitHub/khaotic-engine-Reborn/enginecustom",
+      "program": "c:/Users/arivas/Documents/GitHub/khaotic-engine-Reborn/enginecustom/build/Debug/outDebug",
+      "MIMode": "gdb",
+      "miDebuggerPath": "gdb",
+      "setupCommands": [
+        {
+          "description": "Enable pretty-printing for gdb",
+          "text": "-enable-pretty-printing",
+          "ignoreFailures": true
+        }
+      ]
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,59 @@
+{
+  "C_Cpp_Runner.cCompilerPath": "gcc",
+  "C_Cpp_Runner.cppCompilerPath": "g++",
+  "C_Cpp_Runner.debuggerPath": "gdb",
+  "C_Cpp_Runner.cStandard": "",
+  "C_Cpp_Runner.cppStandard": "",
+  "C_Cpp_Runner.msvcBatchPath": "C:/Program Files/Microsoft Visual Studio/VR_NR/Community/VC/Auxiliary/Build/vcvarsall.bat",
+  "C_Cpp_Runner.useMsvc": false,
+  "C_Cpp_Runner.warnings": [
+    "-Wall",
+    "-Wextra",
+    "-Wpedantic",
+    "-Wshadow",
+    "-Wformat=2",
+    "-Wcast-align",
+    "-Wconversion",
+    "-Wsign-conversion",
+    "-Wnull-dereference"
+  ],
+  "C_Cpp_Runner.msvcWarnings": [
+    "/W4",
+    "/permissive-",
+    "/w14242",
+    "/w14287",
+    "/w14296",
+    "/w14311",
+    "/w14826",
+    "/w44062",
+    "/w44242",
+    "/w14905",
+    "/w14906",
+    "/w14263",
+    "/w44265",
+    "/w14928"
+  ],
+  "C_Cpp_Runner.enableWarnings": true,
+  "C_Cpp_Runner.warningsAsError": false,
+  "C_Cpp_Runner.compilerArgs": [],
+  "C_Cpp_Runner.linkerArgs": [],
+  "C_Cpp_Runner.includePaths": [],
+  "C_Cpp_Runner.includeSearch": [
+    "*",
+    "**/*"
+  ],
+  "C_Cpp_Runner.excludeSearch": [
+    "**/build",
+    "**/build/**",
+    "**/.*",
+    "**/.*/**",
+    "**/.vscode",
+    "**/.vscode/**"
+  ],
+  "C_Cpp_Runner.useAddressSanitizer": false,
+  "C_Cpp_Runner.useUndefinedSanitizer": false,
+  "C_Cpp_Runner.useLeakSanitizer": false,
+  "C_Cpp_Runner.showCompilationTime": false,
+  "C_Cpp_Runner.useLinkTimeOptimization": false,
+  "C_Cpp_Runner.msvcSecureNoWarnings": false
+}

README.md

@@ -1,8 +1,8 @@
-#  Khaotic Engine - C++ Custom Engine
+#  Khaotic Engine Reborn - C++ Custom Engine
 
-Khaotic Engine est un moteur de rendu fait en **C++** réalisé par une petite équipe dans le but d'apprendre à utiliser les API de rendu (OpenGL,DirectX 11/12 et Vulkan).
+Khaotic Engine Reborn reprend comme base le moteur Khaotic Engine pour lui ajouter plus de fonctionalité.
 
-Ce moteur est basé sur **DirectX11** utilise **ImGui** et **Boost** avec une couche d'abstraction pour permetre son usage avec d'autres API.
+Ce moteur est basé sur **DirectX11** utilise **ImGui** avec une couche d'abstraction pour permetre son usage avec d'autres API.
 
 ---
 
@@ -31,77 +31,23 @@ This **DirectX11** based engine uses **ImGui** with an abstraction layer to enab
 
 
 
-## Shaders list:
+## Nouvauté Aporté par Khaotic Engine Reborn
 
+**SHADER** :
 
- - **Diffuse Lighting**
- - **Ambiant Lighting**
- - **Specular Lighting**
- - **Light Shader**
- - **Light Map Shader**
- - **Alpha Mapping**
- - **Normal Mapping**
- - **Specular Mapping**
- - **Clipping Planes** 
- - **Texture Translation** 
- - **Transparency**
- - **Water**
-   - **Refraction**
-   - *Reflection (cassé / broken)*
- 
-
-*Plus de shaders seront disponibles dans le futur*
-
----
-
-*More shaders will be added in the future*
-
-
-
-## ImGui:
-
-*Cette partie du moteur est encore en développement, d'autres fonctionnalitées seront ajoutées dans le futur*
-
-La librairie ImGui est utilisée afin d'intéragir avec les éléments du moteur comme les objets.
-
-### Fonctionnalitées:
-- Importer des objets 3D sous format **.obj**
-- Ajout d'un cube à la scène
-- Modifier les propriétées d'un objet (Position, Rotation, Taille)
-- Modifier les objets présents dans la scène
-- Création d'un terrain
-- Modifier les propriétées des lumières (Position, Couleur RVB)
-
-----
-*This part of the engine is still in development, other features will be added in the future*
-
-ImGui is used to allow interaction between the user and the objects in the scene.
-
-### Features:
-- Import 3D objects with the **.obj** format
-- Can add a cube to the scene
-- Edit an object properties (Position, Rotation, Scale)
-- Edit objects in the current scene
-- Terrain generation
-- Edit lights properties (Position, RGB Color)
+- Cel Shading
 
+**Interface Graphique** :
 
+- Shader Manager
 
 ## Demo :
 
 [![Demo Video](https://img.youtube.com/vi/qCOCTyB_97c/0.jpg)](https://www.youtube.com/watch?v=qCOCTyB_97c)
 
-
-## Bug Report :
-
-Vous pouvez signalez les problèmes en ouvrant un ticket dans [Issues](https://github.com/GamingCampus-AdrienBourgois/khaotic-engine/issues)
-
-----
-You can report bugs with the program by creating a ticket in [Issues](https://github.com/GamingCampus-AdrienBourgois/khaotic-engine/issues)
-
 ## Engine Build by :
 
-[](https://github.com/GamingCampus-AdrienBourgois/khaotic-engine?tab=readme-ov-file#engine-build-by-)
+**Moteur D'origine** :
 
 -   [@CatChow0](https://github.com/CatChow0)
 -   [@miragefr0st](https://github.com/miragefr0st)
@@ -113,6 +59,6 @@ You can report bugs with the program by creating a ticket in [Issues](https://gi
 -  [@sutabasuto](https://github.com/sutabasuto)
 
 
+**Moteur Reborn** :
 
-
-
+-   [@CatChow0](https://github.com/CatChow0)

enginecustom/CelShadingShader.cpp

@@ -0,0 +1,410 @@
+#include "CelShadingShader.h"
+#include <iostream>
+
+CelShadingShader::CelShadingShader()
+{
+    m_vertexShader = 0;
+    m_pixelShader = 0;
+    m_layout = 0;
+    m_matrixBuffer = 0;
+    m_sampleState = 0;
+    m_lightBuffer = 0;
+}
+
+CelShadingShader::CelShadingShader(const CelShadingShader& other)
+{
+}
+
+CelShadingShader::~CelShadingShader()
+{
+}
+
+bool CelShadingShader::Initialize(ID3D11Device* device, HWND hwnd)
+{
+    Logger::Get().Log("Initializing CelShadingShader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+
+    bool result;
+    wchar_t vsFilename[128];
+    wchar_t psFilename[128];
+    int error;
+
+    // Set the filename of the vertex shader.
+    error = wcscpy_s(vsFilename, 128, L"celshading.vs");
+    if (error != 0)
+    {
+        Logger::Get().Log("Failed to set the filename of the vertex shader", __FILE__, __LINE__);
+        return false;
+    }
+
+    // Set the filename of the pixel shader.
+    error = wcscpy_s(psFilename, 128, L"celshading.ps");
+    if (error != 0)
+    {
+        Logger::Get().Log("Failed to set the filename of the pixel shader", __FILE__, __LINE__);
+        return false;
+    }
+
+    // Initialize the vertex and pixel shaders.
+    result = InitializeShader(device, hwnd, vsFilename, psFilename);
+    if (!result)
+    {
+        Logger::Get().Log("Failed to initialize the vertex and pixel shaders", __FILE__, __LINE__);
+        return false;
+    }
+
+    Logger::Get().Log("Successfully initialized CelShadingShader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+
+    return true;
+}
+
+void CelShadingShader::Shutdown()
+{
+    // Shutdown the vertex and pixel shaders as well as the related objects.
+    ShutdownShader();
+}
+
+bool CelShadingShader::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
+	ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection, XMFLOAT4 diffuseColor, XMFLOAT3 lightPosition)
+{
+    bool result;
+    // Set the shader parameters that it will use for rendering.
+    result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, diffuseColor, lightPosition);
+    if (!result)
+    {
+        Logger::Get().Log("CelShading Error", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Now render the prepared buffers with the shader.
+    RenderShader(deviceContext, indexCount);
+
+    return true;
+}
+
+bool CelShadingShader::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
+{
+    HRESULT result;
+    ID3D10Blob* errorMessage = nullptr;
+    ID3D10Blob* vertexShaderBuffer = nullptr;
+    ID3D10Blob* pixelShaderBuffer = nullptr;
+    D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
+    unsigned int numElements;
+    D3D11_BUFFER_DESC matrixBufferDesc;
+    D3D11_SAMPLER_DESC samplerDesc;
+    D3D11_BUFFER_DESC lightBufferDesc;
+
+    // Compile the vertex shader code.
+    result = D3DCompileFromFile(vsFilename, nullptr, nullptr, "CelShadingVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
+    if (FAILED(result))
+    {
+        // If the shader failed to compile it should have written something to the error message.
+        if (errorMessage)
+        {
+            OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
+        }
+        // If there was nothing in the error message then it simply could not find the shader file itself.
+        else
+        {
+            MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
+        }
+
+        return false;
+    }
+
+    // Compile the pixel shader code.
+    result = D3DCompileFromFile(psFilename, nullptr, nullptr, "CelShadingPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
+    if (FAILED(result))
+    {
+        // If the shader failed to compile it should have written something to the error message.
+        if (errorMessage)
+        {
+            OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
+        }
+        // If there was nothing in the error message then it simply could not find the file itself.
+        else
+        {
+            MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
+        }
+
+        return false;
+    }
+
+    // Create the vertex shader from the buffer.
+    result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), nullptr, &m_vertexShader);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Create the pixel shader from the buffer.
+    result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), nullptr, &m_pixelShader);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Create the vertex input layout description.
+    // This setup needs to match the VertexType structure in the ModelClass and in the shader.
+    polygonLayout[0].SemanticName = "POSITION";
+    polygonLayout[0].SemanticIndex = 0;
+    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
+    polygonLayout[0].InputSlot = 0;
+    polygonLayout[0].AlignedByteOffset = 0;
+    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[0].InstanceDataStepRate = 0;
+
+    polygonLayout[1].SemanticName = "NORMAL";
+    polygonLayout[1].SemanticIndex = 0;
+    polygonLayout[1].Format = DXGI_FORMAT_R32G32B32_FLOAT;
+    polygonLayout[1].InputSlot = 0;
+    polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
+    polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[1].InstanceDataStepRate = 0;
+
+    polygonLayout[2].SemanticName = "TEXCOORD";
+    polygonLayout[2].SemanticIndex = 0;
+    polygonLayout[2].Format = DXGI_FORMAT_R32G32_FLOAT;
+    polygonLayout[2].InputSlot = 0;
+    polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
+    polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[2].InstanceDataStepRate = 0;
+
+    // Get a count of the elements in the layout.
+    numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
+
+    // Create the vertex input layout.
+    result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
+    vertexShaderBuffer->Release();
+    vertexShaderBuffer = nullptr;
+
+    pixelShaderBuffer->Release();
+    pixelShaderBuffer = nullptr;
+
+    // Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
+    matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+    matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
+    matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    matrixBufferDesc.MiscFlags = 0;
+    matrixBufferDesc.StructureByteStride = 0;
+
+    // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
+    result = device->CreateBuffer(&matrixBufferDesc, nullptr, &m_matrixBuffer);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Create a texture sampler state description.
+    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
+    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
+    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
+    samplerDesc.MipLODBias = 0.0f;
+    samplerDesc.MaxAnisotropy = 1;
+    samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
+    samplerDesc.BorderColor[0] = 0;
+    samplerDesc.BorderColor[1] = 0;
+    samplerDesc.BorderColor[2] = 0;
+    samplerDesc.BorderColor[3] = 0;
+    samplerDesc.MinLOD = 0;
+    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
+
+    // Create the texture sampler state.
+    result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Setup the description of the light dynamic constant buffer that is in the pixel shader.
+    lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+    lightBufferDesc.ByteWidth = sizeof(LightBufferType);
+    lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    lightBufferDesc.MiscFlags = 0;
+    lightBufferDesc.StructureByteStride = 0;
+
+    // Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class.
+    result = device->CreateBuffer(&lightBufferDesc, nullptr, &m_lightBuffer);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+
+void CelShadingShader::ShutdownShader()
+{
+    // Release the light constant buffer.
+    if (m_lightBuffer)
+    {
+        m_lightBuffer->Release();
+        m_lightBuffer = nullptr;
+    }
+
+    // Release the sampler state.
+    if (m_sampleState)
+    {
+        m_sampleState->Release();
+        m_sampleState = nullptr;
+    }
+
+    // Release the matrix constant buffer.
+    if (m_matrixBuffer)
+    {
+        m_matrixBuffer->Release();
+        m_matrixBuffer = nullptr;
+    }
+
+    // Release the layout.
+    if (m_layout)
+    {
+        m_layout->Release();
+        m_layout = nullptr;
+    }
+
+    // Release the pixel shader.
+    if (m_pixelShader)
+    {
+        m_pixelShader->Release();
+        m_pixelShader = nullptr;
+    }
+
+    // Release the vertex shader.
+    if (m_vertexShader)
+    {
+        m_vertexShader->Release();
+        m_vertexShader = nullptr;
+    }
+}
+
+void CelShadingShader::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
+{
+    char* compileErrors;
+    unsigned long bufferSize, i;
+    std::ofstream fout;
+
+    // Get a pointer to the error message text buffer.
+    compileErrors = (char*)(errorMessage->GetBufferPointer());
+
+    // Get the length of the message.
+    bufferSize = errorMessage->GetBufferSize();
+
+    // Open a file to write the error message to.
+    fout.open("shader-error.txt");
+
+    // Write out the error message.
+    for (i = 0; i < bufferSize; i++)
+    {
+        fout << compileErrors[i];
+    }
+
+    // Close the file.
+    fout.close();
+
+    // Release the error message.
+    errorMessage->Release();
+    errorMessage = nullptr;
+
+    // Pop a message up on the screen to notify the user to check the text file for compile errors.
+    MessageBox(hwnd, L"Error compiling shader. Check shader-error.txt for message.", shaderFilename, MB_OK);
+}
+
+
+bool CelShadingShader::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
+    ID3D11ShaderResourceView* texture, XMFLOAT3 lightDirection, XMFLOAT4 diffuseColor, XMFLOAT3 lightPosition)
+{
+    HRESULT result;
+    D3D11_MAPPED_SUBRESOURCE mappedResource;
+    MatrixBufferType* dataPtr;
+    LightBufferType* dataPtr2;
+    unsigned int bufferNumber;
+
+    // Transpose the matrices to prepare them for the shader.
+    worldMatrix = XMMatrixTranspose(worldMatrix);
+    viewMatrix = XMMatrixTranspose(viewMatrix);
+    projectionMatrix = XMMatrixTranspose(projectionMatrix);
+
+    // Lock the constant buffer so it can be written to.
+    result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Get a pointer to the data in the constant buffer.
+    dataPtr = (MatrixBufferType*)mappedResource.pData;
+
+    // Copy the matrices into the constant buffer.
+    dataPtr->world = worldMatrix;
+    dataPtr->view = viewMatrix;
+    dataPtr->projection = projectionMatrix;
+
+    // Unlock the constant buffer.
+    deviceContext->Unmap(m_matrixBuffer, 0);
+
+    // Set the position of the constant buffer in the vertex shader.
+    bufferNumber = 0;
+
+    // Finally set the constant buffer in the vertex shader with the updated values.
+    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
+
+    // Lock the light constant buffer so it can be written to.
+    result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Get a pointer to the data in the constant buffer.
+    dataPtr2 = (LightBufferType*)mappedResource.pData;
+
+    // Copy the lighting variables into the constant buffer.
+    dataPtr2->diffuseColor = diffuseColor;
+    dataPtr2->lightDirection = lightDirection;
+    dataPtr2->lightPosition = lightPosition;
+    dataPtr2->constantAttenuation = 0.5f; // Set your attenuation values here
+    dataPtr2->linearAttenuation = 0.1f;
+    dataPtr2->quadraticAttenuation = 0.01f;
+
+    // Unlock the constant buffer.
+    deviceContext->Unmap(m_lightBuffer, 0);
+
+    // Set the position of the light constant buffer in the pixel shader.
+    bufferNumber = 0;
+
+    // Finally set the light constant buffer in the pixel shader with the updated values.
+    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer);
+
+    // Set shader texture resource in the pixel shader.
+    deviceContext->PSSetShaderResources(0, 1, &texture);
+
+    return true;
+}
+
+
+
+void CelShadingShader::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount)
+{
+    // Set the vertex input layout.
+    deviceContext->IASetInputLayout(m_layout);
+
+    // Set the vertex and pixel shaders that will be used to render this triangle.
+    deviceContext->VSSetShader(m_vertexShader, nullptr, 0);
+    deviceContext->PSSetShader(m_pixelShader, nullptr, 0);
+
+    // Set the sampler state in the pixel shader.
+    deviceContext->PSSetSamplers(0, 1, &m_sampleState);
+
+    // Render the triangle.
+    deviceContext->DrawIndexed(indexCount, 0, 0);
+}

enginecustom/CelShadingShader.h

@@ -0,0 +1,68 @@
+#ifndef _CELSHADINGSHADER_H_
+#define _CELSHADINGSHADER_H_
+
+//////////////
+// INCLUDES //
+//////////////
+#include "Logger.h"
+#include <d3d11.h>
+#include <d3dcompiler.h>
+#include <directxmath.h>
+#include <fstream>
+using namespace DirectX;
+using namespace std;
+
+////////////////////////////////////////////////////////////////////////////////
+// Class name: CelShadingShader
+////////////////////////////////////////////////////////////////////////////////
+class CelShadingShader
+{
+private:
+    struct MatrixBufferType
+    {
+        XMMATRIX world;
+        XMMATRIX view;
+        XMMATRIX projection;
+    };
+
+    struct LightBufferType
+    {
+        XMFLOAT4 diffuseColor;
+        XMFLOAT3 lightDirection;
+        float padding;  // Padding to ensure the structure is a multiple of 16 bytes.
+        XMFLOAT3 lightPosition; // Add light position
+        float padding2; // Padding to ensure the structure is a multiple of 16 bytes.
+        float constantAttenuation;
+        float linearAttenuation;
+        float quadraticAttenuation;
+        float padding3; // Padding to ensure the structure is a multiple of 16 bytes.
+    };
+
+
+public:
+    CelShadingShader();
+    CelShadingShader(const CelShadingShader&);
+    ~CelShadingShader();
+
+    bool Initialize(ID3D11Device*, HWND);
+    void Shutdown();
+    bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4, XMFLOAT3);
+
+private:
+    bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*);
+    void ShutdownShader();
+    void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);
+
+    bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4, XMFLOAT3);
+    void RenderShader(ID3D11DeviceContext*, int);
+
+private:
+    ID3D11VertexShader* m_vertexShader;
+    ID3D11PixelShader* m_pixelShader;
+    ID3D11InputLayout* m_layout;
+    ID3D11Buffer* m_matrixBuffer;
+    ID3D11SamplerState* m_sampleState;
+    ID3D11Buffer* m_lightBuffer;
+};
+
+#endif

enginecustom/Main.cpp

@@ -6,6 +6,16 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline,
 	SystemClass* System;
 	bool result;
 
+	wchar_t path[MAX_PATH];
+	HMODULE hmodule = GetModuleHandle(NULL);
+	if (hmodule != NULL)
+	{
+		GetModuleFileName(hmodule, path, (sizeof(path) / sizeof(wchar_t)));
+	}
+
+	std::filesystem::path exePath(path);
+	std::filesystem::path WFolder = exePath.parent_path();
+
 	// Create the system object.
 	System = new SystemClass;
 
@@ -14,6 +24,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline,
 	if (result)
 	{
 		Logger::Get().Log("System initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+		System->SendPath(path,WFolder);
 		System->Run();
 	}
 

enginecustom/Spriteclass.cpp

@@ -329,7 +329,7 @@ void SpriteClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
 
 bool SpriteClass::LoadTextures(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* filename)
 {
-    std::string textureFilename;
+    std::string textureFilename(256, '0');
     std::ifstream fin;
     int i, j;
     char input;

enginecustom/Systemclass.cpp

@@ -9,34 +9,28 @@ SystemClass::SystemClass()
 	m_Input = 0;
 	m_Application = 0;
 	m_imguiManager = 0;
+	m_applicationName = 0;
+	m_hinstance = 0;
+	m_hwnd = 0;
+	m_initialWindowWidth = 0;
+	m_initialWindowHeight = 0;
+	m_isDirect3DInitialized = false;
 	
 }
 
-SystemClass::SystemClass(const SystemClass& other)
-{
-}
-
 SystemClass::~SystemClass()
 {
 }
 
 bool SystemClass::Initialize()
 {
-	int screenWidth, screenHeight;
+	int screenHeight, screenWidth = 0;
 	bool result;
 
 	Logger::Get().Log("Initializing system class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
 	try
 	{
-		// Initialize the width and height of the screen to zero before sending the variables into the function.
-		screenWidth = 0;
-		screenHeight = 0;
-
-		m_initialWindowWidth = 0;
-		m_initialWindowHeight = 0;
-		m_isDirect3DInitialized = false;
-
 		// Initialize the windows api.
 		InitializeWindows(screenWidth, screenHeight);
 
@@ -149,6 +143,10 @@ void SystemClass::Run()
 
 	// Loop until there is a quit message from the window or the user.
 	done = false;
+
+	auto fixedUpdateInterval = std::chrono::milliseconds(16);
+	auto m_lastFixedUpdateTime = std::chrono::steady_clock::now();
+
 	while (!done)
 	{
 		// Handle the windows messages.
@@ -180,6 +178,13 @@ void SystemClass::Run()
 				Logger::Get().Log("Failed to process frame", __FILE__, __LINE__, Logger::LogLevel::Error);
 				done = true;
 			}
+
+			auto now = std::chrono::steady_clock::now();
+			if (now - m_lastFixedUpdateTime >= fixedUpdateInterval)
+			{
+				FixedUpdate();
+				m_lastFixedUpdateTime = now;
+			}
 		}
 
 	}
@@ -257,6 +262,8 @@ LRESULT CALLBACK SystemClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam
 			//  If Direct3D is initialized, update the swap chain. Otherwise, store the window dimensions
 			if (m_isDirect3DInitialized && m_Application && m_Application->GetDirect3D())
 			{
+				m_Application->SetScreenWidth(newWidth);
+				m_Application->SetScreenHeight(newHeight);
 				m_Application->GetDirect3D()->ResizeSwapChain(newWidth, newHeight);
 			}
 			else
@@ -264,6 +271,7 @@ LRESULT CALLBACK SystemClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam
 				m_initialWindowWidth = newWidth;
 				m_initialWindowHeight = newHeight;
 			}
+			return 0;
 		}
 		case WM_ENTERSIZEMOVE:
 		{
@@ -463,3 +471,14 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
 	}
 	}
 }
+
+void SystemClass::SendPath(wchar_t* path, std::filesystem::path WFolder)
+{
+	m_Application->SetPath(path);
+	m_Application->SetWFolder(WFolder);
+}
+
+void SystemClass::FixedUpdate()
+{
+	m_Application->GetPhysics()->Update();
+}

enginecustom/applicationclass.cpp

@@ -17,7 +17,6 @@ ApplicationClass::ApplicationClass() : m_ShouldQuit(false)
 	m_RenderCountString = 0;
 	m_ModelList = 0;
 	m_Position = 0;
-	m_Frustum = 0;
 	m_DisplayPlane = 0;
 	m_BathModel = 0;
 	m_WaterModel = 0;
@@ -25,14 +24,12 @@ ApplicationClass::ApplicationClass() : m_ShouldQuit(false)
 	m_RefractionTexture = 0;
 	m_ReflectionTexture = 0;
 	m_Physics = 0;
+	m_cubes.clear();
+	m_terrainChunk.clear();
+	m_object.clear();
+	m_RenderQueues.clear();
 }
 
-
-ApplicationClass::ApplicationClass(const ApplicationClass& other)
-{
-}
-
-
 ApplicationClass::~ApplicationClass()
 {
 }
@@ -51,11 +48,20 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 		char spriteFilename[128];
 		char fpsString[32];
 		bool result;
-		std::vector<std::string> Filename;
+		HRESULT Hresult;
+
+		m_RenderQueues.push_back(std::ref(m_object));
+		m_RenderQueues.push_back(std::ref(m_cubes));
+		m_RenderQueues.push_back(std::ref(m_terrainChunk));
 
 		m_screenWidth = screenWidth;
 		m_screenHeight = screenHeight;
 
+		SetHwnd(hwnd);
+		SetWindowed(FULL_SCREEN);
+		SetScreenHeight(screenHeight);
+		SetScreenWidth(screenWidth);
+
 		// Create the Direct3D object.
 		m_Direct3D = new D3DClass;
 		if (!m_Direct3D)
@@ -127,6 +133,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 
 
 		// Set the sprite info file we will be using.
+		// 
 		strcpy_s(spriteFilename, "sprite_data_01.txt");
 
 		// Create and initialize the sprite object.
@@ -159,7 +166,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 		}
 
 		// Set the file name of the bitmap file.
-		strcpy_s(bitmapFilename, "stone01.tga");
+		strcpy_s(bitmapFilename, "assets/Texture/stone01.tga");
 
 		// Create and initialize the bitmap object.
 		m_Bitmap = new BitmapClass;
@@ -172,20 +179,29 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 		}
 
 		// Set the file name of the model.
-		strcpy_s(modelFilename, "cube.txt");
+		strcpy_s(modelFilename, "assets/Model/TXT/cube.txt");
 
-		// Set the file name of the textures.
-		Filename.push_back("stone01.tga");
-		Filename.push_back("normal01.tga");
-		Filename.push_back("spec02.tga");
-		Filename.push_back("alpha01.tga");
-		Filename.push_back("light01.tga");
-		Filename.push_back("moss01.tga");
+		// Charger les textures
+		std::vector<std::wstring> textureFilenames = {
+			L"assets/Texture/stone01.png"
+		};
+
+		for (const auto& textureFilename : textureFilenames)
+		{
+			ID3D11ShaderResourceView* texture = nullptr;
+			Hresult = DirectX::CreateWICTextureFromFile(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), textureFilename.c_str(), nullptr, &texture);
+			if (FAILED(Hresult))
+			{
+				Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Error);
+				return false;
+			}
+			textures.push_back(texture);
+		}
 
 		// Create and initialize the model object.
 		m_Model = new ModelClass;
 
-		result = m_Model->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, Filename);
+		result = m_Model->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, textures);
 		if (!result)
 		{
 			Logger::Get().Log("Could not initialize the model object", __FILE__, __LINE__, Logger::LogLevel::Error);
@@ -265,15 +281,31 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 		m_ModelList = new ModelListClass;
 		m_ModelList->Initialize(25);
 
-		// Set the file names of the bath model.
-		strcpy_s(modelFilename, "bath.txt");
-		// replace first element with the new filename
-		Filename[0] = "marble01.tga";
+		// Charger les textures initiales pour m_BathModel
+		std::vector<std::wstring> bathTextures = {
+			L"assets/Texture/marble01.png"
+		};
+
+		textures.clear();
+		for (const auto& textureFilename : bathTextures)
+		{
+			ID3D11ShaderResourceView* texture = nullptr;
+			Hresult = DirectX::CreateWICTextureFromFile(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), textureFilename.c_str(), nullptr, &texture);
+			if (FAILED(Hresult))
+			{
+				Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Error);
+				return false;
+			}
+			textures.push_back(texture);
+		}
+
+		// Set the file name of the bath model.
+		strcpy_s(modelFilename, "assets/Model/TXT/bath.txt");
 
 		// Create and initialize the bath model object.
 		m_BathModel = new ModelClass;
 
-		result = m_BathModel->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, Filename);
+		result = m_BathModel->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, textures);
 		if (!result)
 		{
 			MessageBox(hwnd, L"Could not initialize the bath model object.", L"Error", MB_OK);
@@ -281,14 +313,29 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 		}
 
 		// Set the file names of the water model.
-		strcpy_s(modelFilename, "water.txt");
+		strcpy_s(modelFilename, "assets/Model/TXT/water.txt");
 		// replace first element with the new filename
-		Filename[1] = "water01.tga";
+		std::vector<std::wstring> waterTextures = {
+			L"assets/Texture/water01.png"
+		};
+
+		textures.clear();
+		for (const auto& textureFilename : waterTextures)
+		{
+			ID3D11ShaderResourceView* texture = nullptr;
+			Hresult = DirectX::CreateWICTextureFromFile(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), textureFilename.c_str(), nullptr, &texture);
+			if (FAILED(Hresult))
+			{
+				Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Error);
+				return false;
+			}
+			textures.push_back(texture);
+		}
 
 		// Create and initialize the water model object.
 		m_WaterModel = new ModelClass;
 
-		result = m_WaterModel->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, Filename);
+		result = m_WaterModel->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, textures);
 		if (!result)
 		{
 			MessageBox(hwnd, L"Could not initialize the water model object.", L"Error", MB_OK);
@@ -334,9 +381,6 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 		// Create the position class object.
 		m_Position = new PositionClass;
 
-		// Create the frustum class object.
-		m_Frustum = new FrustumClass;
-
 		// Create and initialize the fps object.
 		m_Fps = new FpsClass();
 
@@ -355,6 +399,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 			Logger::Get().Log("Could not initialize the fps string", __FILE__, __LINE__, Logger::LogLevel::Error);
 			return false;
 		}
+
 	}
 	catch (const std::exception& e)
 	{
@@ -423,17 +468,6 @@ void ApplicationClass::Shutdown()
 		m_Physics = 0;
 	}
 
-	// Release the frustum class object.
-	if (m_Frustum)
-	{
-		Logger::Get().Log("Releasing the frustum class object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
-
-		delete m_Frustum;
-		m_Frustum = 0;
-
-		Logger::Get().Log("Frustum class object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
-	}
-
 	// Release the display plane object.
 	if (m_DisplayPlane)
 	{
@@ -678,7 +712,7 @@ bool ApplicationClass::Frame(InputClass* Input)
 	m_Camera->SetRotation(rotationX, rotationY, 0.0f);
 	m_Camera->Render();
 
-	// Render the graphics scene.
+	// Render the static graphics scene.
 	result = Render(rotation, x, y, z, textureTranslation);
 	if (!result)
 	{
@@ -804,7 +838,7 @@ bool ApplicationClass::Frame(InputClass* Input)
 			position = position + object->GetVelocity() * frameTime;
 			object->SetPosition(position);
 			
-			m_Physics->ApplyGravity(object, 1.0f, frameTime);
+			m_Physics->ApplyGravity(object, 1.0f);
 
 			// Check if the object has fallen below a certain position
 			if (XMVectorGetY(object->GetPosition()) < -30.0f)
@@ -868,9 +902,9 @@ bool ApplicationClass::RenderRefractionToTexture()
 	m_Camera->Render();
 
 	// Get the world, view, and projection matrices from the camera and d3d objects.
-	m_Direct3D->GetWorldMatrix(worldMatrix);
+	worldMatrix = m_Direct3D->GetWorldMatrix();
 	m_Camera->GetViewMatrix(viewMatrix);
-	m_Direct3D->GetProjectionMatrix(projectionMatrix);
+	projectionMatrix = m_Direct3D->GetProjectionMatrix();
 
 	// Get the light properties.
 	for (i = 0; i < m_numLights; i++)
@@ -923,8 +957,8 @@ bool ApplicationClass::RenderReflectionToTexture()
 	m_Camera->GetReflectionViewMatrix(reflectionViewMatrix);
 
 	// Get the world and projection matrices from the d3d object.
-	m_Direct3D->GetWorldMatrix(worldMatrix);
-	m_Direct3D->GetProjectionMatrix(projectionMatrix);
+	worldMatrix = m_Direct3D->GetWorldMatrix();
+	projectionMatrix = m_Direct3D->GetProjectionMatrix();
 
 
 	// Reset the render target back to the original back buffer and not the render to texture anymore.  And reset the viewport back to the original.
@@ -947,7 +981,7 @@ bool ApplicationClass::RenderSceneToTexture(float rotation)
 	m_Camera->Render();
 
 	// Get the matrices.
-	m_Direct3D->GetWorldMatrix(worldMatrix);
+	worldMatrix = m_Direct3D->GetWorldMatrix();
 	m_Camera->GetViewMatrix(viewMatrix);
 	m_RenderTexture->GetProjectionMatrix(projectionMatrix);
 
@@ -988,10 +1022,10 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
 	
 
 	// Get the world, view, and projection matrices from the camera and d3d objects.
-	m_Direct3D->GetWorldMatrix(worldMatrix);
+	worldMatrix = m_Direct3D->GetWorldMatrix();
 	m_Camera->GetViewMatrix(viewMatrix);
-	m_Direct3D->GetProjectionMatrix(projectionMatrix);
-	m_Direct3D->GetOrthoMatrix(orthoMatrix);
+	projectionMatrix = m_Direct3D->GetProjectionMatrix();
+	orthoMatrix = m_Direct3D->GetOrthoMatrix();
 
 	// Get the light properties.
 	for (i = 0; i < m_numLights; i++)
@@ -1006,6 +1040,12 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
 		ambientColor[i] = m_Lights[i]->GetPosition();
 	}
 
+	//Add the 3 first value of the first light position to the TrueLightPosition XMFLOAT3
+	positionX = lightPosition[0].x;
+	positionY = lightPosition[0].y;
+	positionZ = lightPosition[0].z;
+	XMFLOAT3 TrueLightPosition = XMFLOAT3(positionX, positionY, positionZ);
+
 	scaleMatrix = XMMatrixScaling(0.5f, 0.5f, 0.5f);  // Build the scaling matrix.
 	rotateMatrix = XMMatrixRotationY(rotation);  // Build the rotation matrix.
 	translateMatrix = XMMatrixTranslation(x, y, z);  // Build the translation matrix.
@@ -1021,97 +1061,25 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
 	result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture(0),
 		diffuseColor, lightPosition, ambientColor);
 
-	for (auto cube : m_cubes)
-	{
 
-		scaleMatrix = cube->GetScaleMatrix();
-
-		if (cube->m_demoSpinning)
-			rotateMatrix = XMMatrixRotationY(rotation);
-		else
-		{
-			rotateMatrix = cube->GetRotateMatrix();
-		}
-
-
-		translateMatrix = cube->GetTranslateMatrix();
-		srMatrix = XMMatrixMultiply(scaleMatrix, rotateMatrix);
-		worldMatrix = XMMatrixMultiply(srMatrix, translateMatrix);
-
-		cube->Render(m_Direct3D->GetDeviceContext());
-
-		// render the texture using the texture shader.
-		result = m_ShaderManager->RenderTextureShader(m_Direct3D->GetDeviceContext(), cube->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, cube->GetTexture(0));
+	// -------------------------------------------------------- //
+	// ------------ Render the object in the queue ------------ //
+	// -------------------------------------------------------- //
+	result = RenderPass(m_RenderQueues, diffuseColor, lightPosition, ambientColor, viewMatrix, projectionMatrix);
 	if (!result)
 	{
-			Logger::Get().Log("Could not render the cube model using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+		Logger::Get().Log("Could not render the model using any shader", __FILE__, __LINE__, Logger::LogLevel::Error);
 		return false;
 	}
 
-		result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, cube->GetTexture(0),
-			diffuseColor, lightPosition,ambientColor);
+	// Update the render count text.
+	result = UpdateRenderCountString(GetRenderCount());
 	if (!result)
 	{
-			Logger::Get().Log("Could not render the cube model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-			return false;
-		}
-	}
-
-	for (auto& object : m_object)
-	{
-		scaleMatrix = object->GetScaleMatrix();
-		if (object->m_demoSpinning)
-			rotateMatrix = XMMatrixRotationY(rotation);
-		else
-		{
-			rotateMatrix = object->GetRotateMatrix();
-		}
-		translateMatrix = object->GetTranslateMatrix();
-		srMatrix = XMMatrixMultiply(scaleMatrix, rotateMatrix);
-		worldMatrix = XMMatrixMultiply(srMatrix, translateMatrix);
-
-		object->Render(m_Direct3D->GetDeviceContext());
-
-		// render the texture using the texture shader.
-		result = m_ShaderManager->RenderTextureShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, object->GetTexture(0));
-		if (!result)
-		{
-			Logger::Get().Log("Could not render the cube model using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+		Logger::Get().Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
 		return false;
 	}
 
-		result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture(0),
-			diffuseColor, lightPosition, ambientColor);
-
-		if (!result)
-		{
-			Logger::Get().Log("Could not render the object model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-			return false;
-		}
-	}
-
-	// Render terrain
-	for (auto& chunk : m_terrainChunk)
-	{
-
-		scaleMatrix = chunk->GetScaleMatrix();
-		rotateMatrix = chunk->GetRotateMatrix();
-		translateMatrix = chunk->GetTranslateMatrix();
-
-		srMatrix = XMMatrixMultiply(scaleMatrix, rotateMatrix);
-		worldMatrix = XMMatrixMultiply(srMatrix, translateMatrix);
-
-		chunk->Render(m_Direct3D->GetDeviceContext());
-
-		result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), chunk->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, chunk->GetTexture(5),
-			diffuseColor, lightPosition, ambientColor);
-			
-		if (!result)
-		{
-			Logger::Get().Log("Could not render the terrain model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-			return false;
-		}
-	}
 
 	// Translate to where the bath model will be rendered.
 	worldMatrix = XMMatrixTranslation(0.0f, -10.0f, 0.0f);
@@ -1120,15 +1088,15 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
 	m_BathModel->Render(m_Direct3D->GetDeviceContext());
 
 	// Render the bath model using the light shader.
-	result = m_ShaderManager->RenderTextureShader(m_Direct3D->GetDeviceContext(), m_BathModel->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix,
-		m_BathModel->GetTexture(0));
+	result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), m_BathModel->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix,
+		m_BathModel->GetTexture(0), diffuseColor, lightPosition, ambientColor);
 	if (!result)
 	{
 		return false;
 	}
 
 	// Reset the world matrix.
-	m_Direct3D->GetWorldMatrix(worldMatrix);
+	worldMatrix = m_Direct3D->GetWorldMatrix();
 
 	// Get the camera reflection view matrix.
 	m_Camera->GetReflectionViewMatrix(reflectionMatrix);
@@ -1190,63 +1158,12 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
 		return false;
 	}
 
-	// Construct the frustum.
-	m_Frustum->ConstructFrustum(viewMatrix, projectionMatrix, SCREEN_DEPTH);
-
-	// Get the number of models that will be rendered.
-	modelCount = m_ModelList->GetModelCount();
-
-	// Initialize the count of models that have been rendered.
-	renderCount = 0;
-
-	// Go through all the models and render them only if they can be seen by the camera view.
-	for (i = 0; i < modelCount; i++)
-	{
-		// Get the position and color of the sphere model at this index.
-		m_ModelList->GetData(i, positionX, positionY, positionZ);
-
-		// Set the radius of the sphere to 1.0 since this is already known.
-		radius = 1.0f;
-
-		// Check if the sphere model is in the view frustum.
-		renderModel = m_Frustum->CheckSphere(positionX, positionY, positionZ, radius);
-
-		// If it can be seen then render it, if not skip this model and check the next sphere.
-		if (renderModel)
-		{
-			// Move the model to the location it should be rendered at.
-			worldMatrix = XMMatrixTranslation(positionX, positionY, positionZ);
-
-			// Render the model using the light shader.
-			m_Model->Render(m_Direct3D->GetDeviceContext());
-
-			result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture(0),
-				diffuseColor, lightPosition, ambientColor);
-			if (!result)
-			{
-				Logger::Get().Log("Could not render the model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
-				return false;
-			}
-
-			// Since this model was rendered then increase the count for this frame.
-			renderCount++;
-		}
-	}
-
-	// Update the render count text.
-	result = UpdateRenderCountString(renderCount);
-	if (!result)
-	{
-		Logger::Get().Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
-		return false;
-	}
-
 	// Disable the Z buffer and enable alpha blending for 2D rendering.
 	m_Direct3D->TurnZBufferOff();
 	m_Direct3D->EnableAlphaBlending();
 
 	// Reset the world matrix.
-	m_Direct3D->GetWorldMatrix(worldMatrix);
+	worldMatrix = m_Direct3D->GetWorldMatrix();
 
 	// Render the render count text string using the font shader.
 	m_RenderCountString->Render(m_Direct3D->GetDeviceContext());
@@ -1491,7 +1408,7 @@ void ApplicationClass::GenerateTerrain()
 	Logger::Get().Log("Generating terrain", __FILE__, __LINE__);
 
 	char modelFilename[128];
-	std::vector<string> Filename;
+	bool result;
 
 	XMMATRIX scaleMatrix;
 	float scaleX, scaleY, scaleZ;
@@ -1503,29 +1420,60 @@ void ApplicationClass::GenerateTerrain()
 	scaleMatrix = XMMatrixScaling(scaleX, scaleY, scaleZ);
 
 	// Set the file name of the model.
-	strcpy_s(modelFilename, "plane.txt");
+	strcpy_s(modelFilename, "assets/Model/OBJ/plane.obj");
 
-	Filename.push_back("stone01.tga");
-	Filename.push_back("normal01.tga");
-	Filename.push_back("spec02.tga");
-	Filename.push_back("alpha01.tga");
-	Filename.push_back("light01.tga");
-	Filename.push_back("moss01.tga");
+	// Liste des fichiers de texture
+	std::vector<std::wstring> terrainTexture = {
+		L"assets/Texture/Bricks2K.png",
+		L"assets/Texture/BricksNRM2K.png",
+		L"assets/Texture/BricksGLOSS2K.png"
+	};
+
+
+	textures.clear();
+	for (const auto& textureFilename : terrainTexture)
+	{
+
+		ID3D11ShaderResourceView* texture = nullptr;
+		HRESULT result = DirectX::CreateWICTextureFromFile(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), textureFilename.c_str(), nullptr, &texture);
+		if (FAILED(result))
+		{
+			// Utiliser _com_error pour obtenir des informations d<>taill<6C>es sur l'erreur
+			_com_error err(result);
+			LPCTSTR errMsg = err.ErrorMessage();
+
+			//convertie errMessage en std::wstring
+			std::wstring ws(errMsg);
+			std::string str(ws.begin(), ws.end());
+
+			Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()) +
+				"\nError: " + std::to_string(result) +
+				"\nDescription: " + str,
+				__FILE__, __LINE__, Logger::LogLevel::Error);
+			return ; // Assurez-vous de retourner false ou de g<>rer l'erreur de mani<6E>re appropri<72>e
+		}
+		textures.push_back(texture);
+
+		// log success message
+		Logger::Get().Log("Texture loaded: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Initialize);
+		
+	}
 
 	std::filesystem::path p(modelFilename);
 	std::string filenameWithoutExtension = p.stem().string();
 
+
 	// for loop to generate terrain chunks for a 10x10 grid
-	for (int i = 0; i < 10; i++)
+	for (int i = 0; i < 20; i++)
 	{
-		for (int j = 0; j < 10; j++)
+		for (int j = 0; j < 20; j++)
 		{
 			Object* newTerrain = new Object();
-			newTerrain->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, Filename);
+			newTerrain->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, textures);
 
 			newTerrain->SetScaleMatrix(scaleMatrix);
 
-			newTerrain->SetTranslateMatrix(XMMatrixTranslation(i / 2 * (scaleX * 2), -12.0f, j * (scaleZ * 2)));
+			newTerrain->SetTranslateMatrix(XMMatrixTranslation(i / 2 * scaleX , -12.0f, j * scaleZ));
 
 			newTerrain->SetName(filenameWithoutExtension);
 
@@ -1543,6 +1491,7 @@ void ApplicationClass::AddKobject(WCHAR* filepath)
 
 	char modelFilename[128];
 	vector<string> Filename;
+	HRESULT result;
 
 	filesystem::path p(filepath);
 	string filename = p.stem().string();
@@ -1550,17 +1499,44 @@ void ApplicationClass::AddKobject(WCHAR* filepath)
 	size_t convertedChars = 0;
 	wcstombs_s(&convertedChars, modelFilename, sizeof(modelFilename), filepath, _TRUNCATE);
 
+	filesystem::current_path(m_WFolder);
 
-	// Set the name of the texture file that we will be loading.
-	Filename.push_back("stone01.tga");
-	Filename.push_back("normal01.tga");
-	Filename.push_back("spec02.tga");
-	Filename.push_back("alpha01.tga");
-	Filename.push_back("light01.tga");
-	Filename.push_back("moss01.tga");
+	// Liste des fichiers de texture
+	std::vector<std::wstring> kobjTexture = {
+		L"assets/Texture/Bricks2K.png",
+		L"assets/Texture/EmptyTexture.png"
+	};
+
+	textures.clear();
+	for (const auto& textureFilename : kobjTexture)
+	{
+		ID3D11ShaderResourceView* texture = nullptr;
+		result = DirectX::CreateWICTextureFromFile(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), textureFilename.c_str(), nullptr, &texture);
+		if (FAILED(result))
+		{
+			// Utiliser _com_error pour obtenir des informations d<>taill<6C>es sur l'erreur
+			_com_error err(result);
+			LPCTSTR errMsg = err.ErrorMessage();
+
+			//convertie errMessage en std::wstring
+			std::wstring ws(errMsg);
+			std::string str(ws.begin(), ws.end());
+
+			// Log the current working directory
+			std::filesystem::path cwd = std::filesystem::current_path();
+			Logger::Get().Log("Current working directory: " + cwd.string(), __FILE__, __LINE__, Logger::LogLevel::Error);
+
+			Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()) +
+				"\nError: " + std::to_string(result) +
+				"\nDescription: " + str,
+				__FILE__, __LINE__, Logger::LogLevel::Error);
+			return; // Assurez-vous de retourner false ou de g<>rer l'erreur de mani<6E>re appropri<72>e
+		}
+		textures.push_back(texture);
+	}
 
 	Object* newObject = new Object();
-	newObject->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, Filename);
+	newObject->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, textures);
 	newObject->SetMass(1.0f);
 	newObject->SetTranslateMatrix(XMMatrixTranslation(0.0f, 50.0f, 0.0f));
 	newObject->SetName(filename);
@@ -1569,6 +1545,13 @@ void ApplicationClass::AddKobject(WCHAR* filepath)
 	m_ObjectId++;
 
 	m_object.push_back(newObject);
+
+
+	// V<>rifiez que l'objet a bien re<72>u les textures
+	if (newObject->GetTexture(0) == nullptr)
+	{
+		Logger::Get().Log("Object texture is null after initialization", __FILE__, __LINE__, Logger::LogLevel::Error);
+	}
 }
 
 void ApplicationClass::AddCube()
@@ -1577,27 +1560,39 @@ void ApplicationClass::AddCube()
 	Logger::Get().Log("Adding cube", __FILE__, __LINE__);
 
 	char modelFilename[128];
-	vector<string> Filename;
+	HRESULT result;
 
 	// Set the file name of the model.
-	strcpy_s(modelFilename, "cube.txt");
+	strcpy_s(modelFilename, "assets/Model/TXT/cube.txt");
 
-	// Set the name of the texture file that we will be loading.
-	Filename.push_back("stone01.tga");
-	Filename.push_back("normal01.tga");
-	Filename.push_back("spec02.tga");
-	Filename.push_back("alpha01.tga");
-	Filename.push_back("light01.tga");
-	Filename.push_back("moss01.tga");
+	// Liste des fichiers de texture
+	std::vector<std::wstring> cubeTexture = {
+		L"assets/Texture/Bricks2K.png"
+	};
+
+
+	textures.clear();
+	for (const auto& textureFilename : cubeTexture)
+	{
+		ID3D11ShaderResourceView* texture = nullptr;
+		result = DirectX::CreateWICTextureFromFile(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), textureFilename.c_str(), nullptr, &texture);
+		if (FAILED(result))
+		{
+			Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Error);
+			return;
+		}
+		textures.push_back(texture);
+	}
 
 	static int cubeCount = 0;
 	float position = cubeCount * 2.0f;
 	Object* newCube = new Object();
-	newCube->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, Filename);
+	newCube->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, textures);
 
 	newCube->SetTranslateMatrix(XMMatrixTranslation(position, 0.0f, 0.0f));
 
 	m_cubes.push_back(newCube);
+
 }
 
 void ApplicationClass::DeleteKobject(int index)
@@ -1812,3 +1807,153 @@ void ApplicationClass::SetLightPosition(int index, XMVECTOR position)
 	//set the position
 	m_Lights[index]->SetPosition(lightPosition.x, lightPosition.y, lightPosition.z);
 }
+
+void ApplicationClass::SetVsync(bool vsync)
+{
+	VSYNC_ENABLED = vsync;
+
+	if (m_Direct3D)
+	{
+		Logger::Get().Log("Setting Vsync to " + std::to_string(vsync) + " with a screen width : " + std::to_string(GetScreenWidth()) + "and a screen height : " + std::to_string(GetScreenHeight()), __FILE__, __LINE__);
+		m_Direct3D->SetVsync(vsync);
+	}
+}
+
+HWND ApplicationClass::GetHwnd() const
+{
+	return m_hwnd;
+}
+
+void ApplicationClass::SetHwnd(HWND hwnd)
+{
+	m_hwnd = hwnd;
+}
+
+bool ApplicationClass::IsWindowed() const
+{
+	return m_windowed;
+}
+
+void ApplicationClass::SetWindowed(bool windowed)
+{
+	// log the new windowed mode
+	Logger::Get().Log("Setting windowed mode to " + std::to_string(windowed), __FILE__, __LINE__);
+	m_windowed = windowed;
+}
+
+void ApplicationClass::SetScreenHeight(int height)
+{
+	// log the new screen height
+	Logger::Get().Log("Setting screen height to " + std::to_string(height), __FILE__, __LINE__);
+	m_screenHeight = height;
+}
+
+void ApplicationClass::SetScreenWidth(int width)
+{
+	// log the new screen width
+	Logger::Get().Log("Setting screen width to " + std::to_string(width), __FILE__, __LINE__);
+	m_screenWidth = width;
+}
+
+bool ApplicationClass::RenderPass(const std::vector<std::reference_wrapper<std::vector<Object*>>>& RenderQueues, XMFLOAT4* diffuse, XMFLOAT4* position, XMFLOAT4* ambient, XMMATRIX view, XMMATRIX projection)
+{
+	XMMATRIX worldMatrix, scaleMatrix, rotateMatrix, translateMatrix, srMatrix;
+	bool result;
+
+	int renderCount = 0;
+
+	ConstructFrustum();	
+
+
+	for (const auto& RenderQueue : RenderQueues)
+	{
+		for (auto& object : RenderQueue.get())
+		{
+			if (object == nullptr)
+			{
+				Logger::Get().Log("Object is null", __FILE__, __LINE__, Logger::LogLevel::Error);
+				return false;
+			}
+
+			XMVECTOR objposition = object->GetPosition();
+			float x = XMVectorGetX(objposition);
+			float y = XMVectorGetY(objposition);
+			float z = XMVectorGetZ(objposition);
+			float radius = object->GetBoundingRadius();
+
+			// V<>rifie si l'objet est dans le frustum
+			if (!m_FrustumCulling.CheckCube(x, y, z, radius, GetFrustumTolerance()))
+			{
+				
+				continue;
+			}
+
+			renderCount++;
+
+			scaleMatrix = object->GetScaleMatrix();
+			rotateMatrix = object->GetRotateMatrix();
+			translateMatrix = object->GetTranslateMatrix();
+
+			srMatrix = XMMatrixMultiply(scaleMatrix, rotateMatrix);
+			worldMatrix = XMMatrixMultiply(srMatrix, translateMatrix);
+
+			object->Render(m_Direct3D->GetDeviceContext());
+
+			// Utiliser l'enum ShaderType pour d<>terminer quel shader utiliser
+			switch (object->GetActiveShader())
+			{
+			case Object::CEL_SHADING:
+				result = m_ShaderManager->RenderCelShadingShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, view, projection, object->GetTexture(0),
+					m_Lights[0]->GetDirection(), m_Lights[0]->GetDiffuseColor(), TrueLightPosition);
+				if (!result)
+				{
+					Logger::Get().Log("Could not render the model using the cel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+					return false;
+				}
+				break;
+
+			case Object::NORMAL_MAPPING:
+				result = m_ShaderManager->RenderNormalMapShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, view, projection, object->GetTexture(0), object->GetTexture(1), m_Lights[0]->GetDirection(), m_Lights[0]->GetDiffuseColor());
+				if (!result)
+				{
+					Logger::Get().Log("Could not render the model using the normal map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+					return false;
+				}
+				break;
+
+			case Object::SPECULAR_MAPPING:
+				result = m_ShaderManager->RenderSpecMapShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, view, projection, object->GetTexture(0), object->GetTexture(1), object->GetTexture(2), m_Lights[0]->GetDirection(), m_Lights[0]->GetDiffuseColor(), m_Camera->GetPosition(), m_Lights[0]->GetSpecularColor(), m_Lights[0]->GetSpecularPower());
+				if (!result)
+				{
+					Logger::Get().Log("Could not render the model using the specular map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+					return false;
+				}
+				break;
+
+			case Object::LIGHTING:
+			default:
+				result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, view, projection,
+					object->GetTexture(0), diffuse, position, ambient);
+				if (!result)
+				{
+					Logger::Get().Log("Could not render the object model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+					return false;
+				}
+				break;
+			}
+		}
+	}
+
+	SetRenderCount(renderCount);
+
+	return true;
+}
+
+void ApplicationClass::ConstructFrustum()
+{
+	XMMATRIX projectionMatrix = m_Direct3D->GetProjectionMatrix();
+	XMMATRIX viewMatrix;
+	m_Camera->GetViewMatrix(viewMatrix);
+
+	m_FrustumCulling.ConstructFrustum(SCREEN_DEPTH, projectionMatrix, viewMatrix);
+}

enginecustom/applicationclass.h

@@ -29,13 +29,16 @@
 #include "translateshaderclass.h"
 #include "reflectionshaderclass.h"
 #include "physics.h"
+#include "frustum.h"
+
+#include <WICTextureLoader.h>
+#include <comdef.h> // Pour _com_error
 
 
 /////////////
 // GLOBALS //
 /////////////
 const bool FULL_SCREEN = false;
-const bool VSYNC_ENABLED = true;
 const float SCREEN_DEPTH = 1000.0f;
 const float SCREEN_NEAR = 0.3f;
 
@@ -56,7 +59,9 @@ public:
 	bool Frame(InputClass*);
 
 	int GetScreenWidth() const;
+	void SetScreenWidth(int screenWidth);
 	int GetScreenHeight() const;
+	void SetScreenHeight(int screenHeight);
 
 	float GetSpeed() const { return m_speed; };
 	void SetSpeed(float speed) { this->m_speed = speed; };
@@ -69,6 +74,8 @@ public:
 	std::vector<Object*> GetTerrainCubes() const { return m_terrainChunk; };
 	std::vector<Object*> GetKobjects() const { return m_object; };
 	void AddKobject(WCHAR* filepath);
+	void SetPath(WCHAR* path) { m_path = path; };
+	void SetWFolder(std::filesystem::path WFolder) { m_WFolder = WFolder; };
 
 	void GenerateTerrain();
 	void DeleteTerrain();
@@ -83,14 +90,45 @@ public:
 	bool GetShouldQuit() const { return m_ShouldQuit; };
 	void SetShouldQuit(bool shouldQuit) { m_ShouldQuit = shouldQuit; };
 
+	void SetCelShading(bool enable) { m_enableCelShading = enable; };
+
+	std::vector<ID3D11ShaderResourceView*> textures;
+
+	void SetVsync(bool vsync);
+	bool GetVsync() const { return VSYNC_ENABLED; };
+
+	HWND GetHwnd() const;
+	void SetHwnd(HWND hwnd);
+
+	bool IsWindowed() const;
+	void SetWindowed(bool windowed);
+
+	Physics* GetPhysics() const { return m_Physics; };
+
+	// ----------------------------------- //
+	// ------------- Frustum ------------- //
+	// ----------------------------------- //
+
+	Frustum GetFrustum() const { return m_FrustumCulling; };
+	void SetFrustum(Frustum frustum) { m_FrustumCulling = frustum; };
+
+	void ConstructFrustum();
+	int GetRenderCount() const { return m_renderCount; };
+	void SetRenderCount(int renderCount) { m_renderCount = renderCount; };
+	float GetFrustumTolerance() const { return m_FrustumCullingTolerance; };
+	void SetFrustumTolerance(float frustumTolerance) { m_FrustumCullingTolerance = frustumTolerance; };
+
 private:
 	bool Render(float, float, float, float, float);
+	bool RenderPhysics(float x, float y, float z);
 	bool UpdateMouseStrings(int, int, bool);
 	bool UpdateFps();
 	bool UpdateRenderCountString(int);
 	bool RenderSceneToTexture(float);
 	bool RenderRefractionToTexture();
 	bool RenderReflectionToTexture();
+	bool RenderPass(const std::vector<std::reference_wrapper<std::vector<Object*>>>& RenderQueues, XMFLOAT4* diffuse, XMFLOAT4* position, XMFLOAT4* ambient, XMMATRIX view, XMMATRIX projection);
+
 
 private :
 
@@ -102,6 +140,10 @@ private :
 	IDXGISwapChain* m_swapChain;
 	ModelClass* m_Model,* m_GroundModel, * m_WallModel, * m_BathModel, * m_WaterModel;
 	ModelListClass* m_ModelList;
+	bool VSYNC_ENABLED = true;
+
+	HWND m_hwnd;
+	bool m_windowed;
 
 	// ------------------------------------- //
 	// ------------- RENDERING ------------- //
@@ -113,7 +155,6 @@ private :
 	int m_screenWidth, m_screenHeight;
 	CameraClass* m_Camera;
 	PositionClass* m_Position;
-	FrustumClass* m_Frustum;
 
 	// ------------------------------------ //
 	// ------------- OBJECTS -------------- //
@@ -125,6 +166,7 @@ private :
 	float m_speed = 0.1f; // speed for the demo spinning object
 	std::vector<Object*> m_object;
 	int m_ObjectId = 0;
+	std::vector<std::reference_wrapper<std::vector<Object*>>> m_RenderQueues;
 
 	// ----------------------------------- //
 	// ------------- LIGHTS -------------- //
@@ -134,6 +176,9 @@ private :
 	std::vector<LightClass*> m_Lights;
 	int m_numLights;
 
+	XMFLOAT3 TrueLightPosition;
+	ModelClass* m_LightModel;
+
 	// ----------------------------------- //
 	// ------------- SHADERS ------------- //
 	// ----------------------------------- //
@@ -143,11 +188,15 @@ private :
 	BitmapClass* m_Bitmap;
 	SpriteClass* m_Sprite;
 	
+	bool m_enableCelShading;
+
 	// ----------------------------------- //
 	// ------------ VARIABLES ------------ //
 	// ----------------------------------- //
 
 	float m_waterHeight, m_waterTranslation;
+	wchar_t* m_path;
+	std::filesystem::path m_WFolder;
 
 	// ------------------------------------------------- //
 	// ------------- FPS AND INFO ON SCREEN ------------ //
@@ -169,6 +218,14 @@ private :
 	Physics* m_Physics;
 	float m_gravity;
 	XMVECTOR m_previousPosition;
+
+	// ------------------------------------------------- //
+	// ------------------- Frustum --------------------- //
+	// ------------------------------------------------- //
+
+	Frustum m_FrustumCulling;
+	int m_renderCount;
+	float m_FrustumCullingTolerance = 5.f;
 };
 
 #endif

enginecustom/assets/Model/OBJ/plane.obj

@@ -0,0 +1,16 @@
+# Simple 2D plane in OBJ format
+
+v -0.5 0.0 -0.5
+v 0.5 0.0 -0.5
+v -0.5 0.0 0.5
+v 0.5 0.0 0.5
+
+vt 0.0 0.0
+vt 1.0 0.0
+vt 0.0 1.0
+vt 1.0 1.0
+
+vn 0.0 1.0 0.0
+
+f 1/1/1 4/4/1 2/2/1
+f 1/1/1 3/3/1 4/4/1

enginecustom/assets/Model/imgui.ini

@@ -0,0 +1,24 @@
+[Window][Debug##Default]
+Pos=60,60
+Size=400,400
+
+[Window][Khaotic Engine]
+Pos=1120,51
+Size=392,273
+
+[Window][Objects]
+Pos=930,39
+Size=457,294
+
+[Window][Terrain]
+Pos=60,60
+Size=342,82
+
+[Window][Light]
+Pos=1551,17
+Size=358,535
+
+[Window][Shader Manager]
+Pos=30,255
+Size=172,284
+

enginecustom/celshading.ps

@@ -0,0 +1,87 @@
+cbuffer LightBuffer
+{
+    float4 diffuseColor;
+    float3 lightDirection;
+    float padding; // Padding to ensure the structure is a multiple of 16 bytes.
+    float3 lightPosition; // Add light position
+    float padding2; // Padding to ensure the structure is a multiple of 16 bytes.
+    float constantAttenuation;
+    float linearAttenuation;
+    float quadraticAttenuation;
+    float padding3; // Padding to ensure the structure is a multiple of 16 bytes.
+};
+
+Texture2D shaderTexture;
+SamplerState SampleType;
+
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float3 normal : NORMAL;
+    float2 tex : TEXCOORD0;
+    float3 worldPos : TEXCOORD1; // Add world position
+};
+
+float4 CelShadingPixelShader(PixelInputType input) : SV_TARGET
+{
+    float4 textureColor;
+    float lightIntensity;
+    float4 finalColor;
+
+    // Sample the pixel color from the texture.
+    textureColor = shaderTexture.Sample(SampleType, input.tex);
+
+    float3 normal = normalize(input.normal);
+
+    // Calculate the light vector from the light position to the world position
+    float3 lightVector = normalize(lightPosition - input.worldPos);
+
+    // Calculate the light intensity based on the light direction.
+    float directionalLightIntensity = saturate(dot(normal, normalize(lightDirection)));
+
+    // Calculate the light intensity based on the light position.
+    float positionalLightIntensity = saturate(dot(normal, lightVector));
+
+    // Combine the directional and positional light intensities.
+    lightIntensity = max(directionalLightIntensity, positionalLightIntensity);
+
+    // Calculate the distance from the light to the fragment.
+    float distance = length(lightPosition - input.worldPos);
+
+    // Apply an attenuation factor based on the distance.
+    float attenuation = 1.0f / (constantAttenuation + linearAttenuation * distance + quadraticAttenuation * distance * distance);
+
+    // Combine the light intensity with the attenuation factor.
+    lightIntensity *= attenuation;
+
+    // Apply a step function to create the cel shading effect.
+    if (lightIntensity > 0.75f)
+    {
+        lightIntensity = 1.0f; // Brightest level
+    }
+    else if (lightIntensity > 0.5f)
+    {
+        lightIntensity = 0.7f; // Mid-bright level
+    }
+    else if (lightIntensity > 0.25f)
+    {
+        lightIntensity = 0.4f; // Mid-dark level
+    }
+    else
+    {
+        lightIntensity = 0.1f; // Darkest level
+    }
+
+    // Simple shadow calculation: if the fragment is behind the light source, it is in shadow.
+    float3 toLight = normalize(lightPosition - input.worldPos);
+    float shadow = saturate(dot(normal, toLight));
+    if (shadow < 0.1f)
+    {
+        lightIntensity *= 0.5f; // Darken the fragment if it is in shadow
+    }
+
+    // Calculate the final color by combining the texture color with the light intensity and diffuse color.
+    finalColor = textureColor * diffuseColor * lightIntensity;
+
+    return finalColor;
+}

enginecustom/celshading.vs

@@ -0,0 +1,45 @@
+cbuffer MatrixBuffer
+{
+    matrix worldMatrix;
+    matrix viewMatrix;
+    matrix projectionMatrix;
+};
+
+struct VertexInputType
+{
+    float4 position : POSITION;
+    float3 normal : NORMAL;
+    float2 tex : TEXCOORD0;
+};
+
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float3 normal : NORMAL;
+    float2 tex : TEXCOORD0;
+    float3 worldPos : TEXCOORD1; // Add world position
+};
+
+PixelInputType CelShadingVertexShader(VertexInputType input)
+{
+    PixelInputType output;
+
+    // Change the position vector to be 4 units for proper matrix calculations.
+    input.position.w = 1.0f;
+
+    // Calculate the position of the vertex against the world, view, and projection matrices.
+    float4 worldPosition = mul(input.position, worldMatrix);
+    output.position = mul(worldPosition, viewMatrix);
+    output.position = mul(output.position, projectionMatrix);
+
+    // Pass the normal to the pixel shader
+    output.normal = mul((float3x3)worldMatrix, input.normal);
+
+    // Pass the world position to the pixel shader
+    output.worldPos = worldPosition.xyz;
+
+    // Store the texture coordinates for the pixel shader.
+    output.tex = input.tex;
+
+    return output;
+}

enginecustom/d3dclass.cpp

@@ -565,28 +565,6 @@ ID3D11DeviceContext* D3DClass::GetDeviceContext()
 	return m_deviceContext;
 }
 
-
-XMMATRIX D3DClass::GetProjectionMatrix(XMMATRIX& projectionMatrix)
-{
-	projectionMatrix = m_projectionMatrix;
-	return m_projectionMatrix;
-}
-
-
-void D3DClass::GetWorldMatrix(XMMATRIX& worldMatrix)
-{
-	worldMatrix = m_worldMatrix;
-	return;
-}
-
-
-void D3DClass::GetOrthoMatrix(XMMATRIX& orthoMatrix)
-{
-	orthoMatrix = m_orthoMatrix;
-	return;
-}
-
-
 void D3DClass::GetVideoCardInfo(char* cardName, int& memory)
 {
 	strcpy_s(cardName, 128, m_videoCardDescription);
@@ -717,7 +695,8 @@ IDXGISwapChain* D3DClass::GetSwapChain()
 void D3DClass::ResizeSwapChain(int newWidth, int newHeight)
 {
 
-	Logger::Get().Log("Resizing swap chain", __FILE__, __LINE__);
+	// log the new width and height
+	Logger::Get().Log("Resizing swap chain to " + std::to_string(newWidth) + "x" + std::to_string(newHeight), __FILE__, __LINE__);
 
 	HRESULT result;
 
@@ -788,3 +767,8 @@ void D3DClass::DisableAlphaBlending()
 
 	return;
 }
+
+void D3DClass::SetVsync(bool vsync)
+{
+	m_vsync_enabled = vsync;
+}

enginecustom/d3dclass.h

@@ -42,14 +42,16 @@ public:
 
 	ID3D11Device* GetDevice();
 	ID3D11DeviceContext* GetDeviceContext();
-	XMMATRIX GetProjectionMatrix(XMMATRIX& projectionMatrix);
+	//XMMATRIX GetProjectionMatrix(XMMATRIX& projectionMatrix);
 	IDXGISwapChain* m_swapChain;
 	IDXGISwapChain* GetSwapChain();
 	void ResizeSwapChain(int, int);
+	void SetVsync(bool vsync);
 
-	XMMATRIX GetProjectionMatrix();
-	void GetWorldMatrix(XMMATRIX&);
-	void GetOrthoMatrix(XMMATRIX&);
+
+	XMMATRIX GetProjectionMatrix() const { return m_projectionMatrix; };
+	XMMATRIX GetWorldMatrix() const { return m_worldMatrix;};
+	XMMATRIX GetOrthoMatrix() const { return m_orthoMatrix; };
 
 	void GetVideoCardInfo(char*, int&);
 

enginecustom/enginecustom.vcxproj

@@ -23,8 +23,10 @@
     <ClCompile Include="applicationclass.cpp" />
     <ClCompile Include="bitmapclass.cpp" />
     <ClCompile Include="Cameraclass.cpp" />
+    <ClCompile Include="CelShadingShader.cpp" />
     <ClCompile Include="Colorshaderclass.cpp" />
     <ClCompile Include="d3dclass.cpp" />
+    <ClCompile Include="frustum.cpp" />
     <ClCompile Include="imguiManager.cpp" />
     <ClCompile Include="include\backends\imgui_impl_dx11.cpp" />
     <ClCompile Include="include\backends\imgui_impl_win32.cpp" />
@@ -38,6 +40,11 @@
     <ClCompile Include="fontshaderclass.cpp" />
     <ClCompile Include="fpsclass.cpp" />
     <ClCompile Include="frustumclass.cpp" />
+    <ClCompile Include="include\Src\DDSTextureLoader.cpp" />
+    <ClCompile Include="include\Src\DirectXHelpers.cpp" />
+    <ClCompile Include="include\Src\pch.cpp" />
+    <ClCompile Include="include\Src\SimpleMath.cpp" />
+    <ClCompile Include="include\Src\WICTextureLoader.cpp" />
     <ClCompile Include="inputclass.cpp" />
     <ClCompile Include="Lightclass.cpp" />
     <ClCompile Include="lightmapshaderclass.cpp" />
@@ -70,8 +77,10 @@
     <ClInclude Include="applicationclass.h" />
     <ClInclude Include="bitmapclass.h" />
     <ClInclude Include="Cameraclass.h" />
+    <ClInclude Include="CelShadingShader.h" />
     <ClInclude Include="Colorshaderclass.h" />
     <ClInclude Include="d3dclass.h" />
+    <ClInclude Include="frustum.h" />
     <ClInclude Include="imguiManager.h" />
     <ClInclude Include="include\backends\imgui_impl_dx11.h" />
     <ClInclude Include="include\backends\imgui_impl_win32.h" />
@@ -86,6 +95,11 @@
     <ClInclude Include="fontshaderclass.h" />
     <ClInclude Include="fpsclass.h" />
     <ClInclude Include="frustumclass.h" />
+    <ClInclude Include="include\Src\CMO.h" />
+    <ClInclude Include="include\Src\DDS.h" />
+    <ClInclude Include="include\Src\LoaderHelpers.h" />
+    <ClInclude Include="include\Src\pch.h" />
+    <ClInclude Include="include\Src\PlatformHelpers.h" />
     <ClInclude Include="inputclass.h" />
     <ClInclude Include="lightclass.h" />
     <ClInclude Include="lightmapshaderclass.h" />
@@ -154,6 +168,12 @@
     <CopyFileToFolders Include="..\KhaoticDemo\water.ps">
       <FileType>Document</FileType>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="celshading.ps">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="celshading.vs">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
     <None Include="packages.config" />
     <CopyFileToFolders Include="reflection.ps">
       <FileType>Document</FileType>
@@ -206,34 +226,98 @@
     </CopyFileToFolders>
   </ItemGroup>
   <ItemGroup>
-    <CopyFileToFolders Include="alpha01.tga" />
-    <Image Include="dirt01.tga" />
     <CopyFileToFolders Include="font01.tga" />
+    <CopyFileToFolders Include="assets\Texture\alpha01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\Bricks2K.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\BricksGLOSS2K.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\BricksNRM2K.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\dirt01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\font01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\ground01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\light01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\marble01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\moss01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\normal01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\spec02.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite02.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite03.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite04.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\stone01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\stone01.tga">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\wall.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\wall01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\water01.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\EmptyTexture.png">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Texture\</DestinationFolders>
+    </CopyFileToFolders>
     <Image Include="KhaoticIcon.ico" />
-    <CopyFileToFolders Include="light01.tga" />
-    <CopyFileToFolders Include="moss01.tga" />
-    <CopyFileToFolders Include="normal01.tga" />
-    <CopyFileToFolders Include="marble01.tga" />
-    <Image Include="papier.tga" />
-    <CopyFileToFolders Include="spec02.tga" />
     <CopyFileToFolders Include="sprite01.tga" />
     <CopyFileToFolders Include="sprite02.tga" />
     <CopyFileToFolders Include="sprite03.tga" />
     <CopyFileToFolders Include="sprite04.tga" />
-    <CopyFileToFolders Include="stone01.tga" />
-    <CopyFileToFolders Include="wall.tga" />
-    <CopyFileToFolders Include="water01.tga" />
   </ItemGroup>
   <ItemGroup>
-    <CopyFileToFolders Include="cube.txt" />
     <CopyFileToFolders Include="font01.txt" />
-    <CopyFileToFolders Include="plane.txt" />
-    <CopyFileToFolders Include="bath.txt" />
-    <Text Include="chunk.txt" />
-    <Text Include="sphere.txt" />
-    <CopyFileToFolders Include="sprite_data_01.txt" />
-    <Text Include="square.txt" />
-    <CopyFileToFolders Include="water.txt" />
   </ItemGroup>
   <ItemGroup>
     <CopyFileToFolders Include="translate.ps">
@@ -249,22 +333,79 @@
     <ResourceCompile Include="resources.rc" />
   </ItemGroup>
   <ItemGroup>
-    <CopyFileToFolders Include="cone.obj">
+    <CopyFileToFolders Include="assets\Model\OBJ\86.obj">
       <FileType>Document</FileType>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="isosphere.obj">
+    <CopyFileToFolders Include="assets\Model\OBJ\cone.obj">
       <FileType>Document</FileType>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="monke.obj">
+    <CopyFileToFolders Include="assets\Model\OBJ\isosphere.obj">
       <FileType>Document</FileType>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="vaisseau.obj">
+    <CopyFileToFolders Include="assets\Model\OBJ\monke.obj">
       <FileType>Document</FileType>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\OBJ\vaisseau.obj">
+      <FileType>Document</FileType>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
     </CopyFileToFolders>
   </ItemGroup>
   <ItemGroup>
-    <CopyFileToFolders Include="86.obj">
+    <CopyFileToFolders Include="assets\Model\TXT\bath.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\chunk.txt">
+      <FileType>Text</FileType>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\cube.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\ground.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\plane.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\sphere.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\square.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\wall.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\water.txt">
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\TXT\</DestinationFolders>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="sprite_data_01.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="assets\Model\OBJ\plane.obj">
       <FileType>Document</FileType>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
+      <DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(OutDir)\assets\Model\OBJ\</DestinationFolders>
     </CopyFileToFolders>
   </ItemGroup>
   <PropertyGroup Label="Globals">
@@ -272,6 +413,7 @@
     <Keyword>Win32Proj</Keyword>
     <ProjectGuid>{92cf56c4-76bb-40d4-8fe5-36c15f5f127a}</ProjectGuid>
     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <ProjectName>KhaoticCore</ProjectName>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -352,7 +494,7 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(SolutionDir)enginecustom\include\backends;$(SolutionDir)enginecustom\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)enginecustom\include\backends;$(SolutionDir)enginecustom\include\Inc;$(SolutionDir)enginecustom\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
@@ -369,7 +511,7 @@
       <PreprocessorDefinitions>NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
       <LanguageStandard>stdcpp17</LanguageStandard>
-      <AdditionalIncludeDirectories>$(SolutionDir)enginecustom\include\backends;$(SolutionDir)enginecustom\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)enginecustom\include\backends;$(SolutionDir)enginecustom\include\Inc;$(SolutionDir)enginecustom\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>

enginecustom/enginecustom.vcxproj.filters

@@ -31,32 +31,41 @@
     <Filter Include="Assets">
       <UniqueIdentifier>{2978535b-193d-4876-83be-1c3c4470db62}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Fichiers sources\DirectX  Tool Kit">
+      <UniqueIdentifier>{3bfbc604-3b39-4e49-bee2-b942fc5dce8c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers d%27en-tête\DirectX Tool Kit">
+      <UniqueIdentifier>{d710c862-b37d-4ad5-aa92-2456f9745881}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets\Texture">
+      <UniqueIdentifier>{4873a73d-d11c-4d40-b847-b6d7fef4b23d}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets\Model">
+      <UniqueIdentifier>{3f3824c5-8a66-4f02-9845-1a9538336592}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets\Model\OBJ">
+      <UniqueIdentifier>{22651df1-90a4-4a19-8b97-5147b27d975a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Assets\Model\TXT">
+      <UniqueIdentifier>{f67d85e0-106e-47a1-bb9c-a5ea9111509a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers d%27en-tête\Shader">
+      <UniqueIdentifier>{e087647e-a306-4246-9320-bab0830bb634}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers d%27en-tête\System">
+      <UniqueIdentifier>{14b07251-cf6d-4391-9fca-ec94e08d4427}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers sources\Shader">
+      <UniqueIdentifier>{3c669b93-a9fd-4b74-813f-f9780413f76b}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Fichiers sources\System">
+      <UniqueIdentifier>{b2659b1e-695d-488e-9a1c-341691d312bc}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Main.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="Systemclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="inputclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="applicationclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="d3dclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="Colorshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="modelclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="Cameraclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="include\imgui_demo.cpp">
       <Filter>Fichiers sources\ImGui</Filter>
     </ClCompile>
@@ -78,122 +87,146 @@
     <ClCompile Include="include\imgui_widgets.cpp">
       <Filter>Fichiers sources\ImGui</Filter>
     </ClCompile>
-    <ClCompile Include="imguiManager.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="lightclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="lightshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="object.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="textureclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="bitmapclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
     <ClCompile Include="fontclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="fontshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="fpsclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
     <ClCompile Include="Spriteclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="Multitextureshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="textclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="textureshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="Timerclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="fpsclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="alphamapshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="specmapshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="frustumclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
     <ClCompile Include="modellistclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="positionclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
     <ClCompile Include="displayplaneclass.cpp">
       <Filter>Fichiers sources</Filter>
     </ClCompile>
-    <ClCompile Include="rendertextureclass.cpp">
-      <Filter>Fichiers sources</Filter>
+    <ClCompile Include="include\Src\DDSTextureLoader.cpp">
+      <Filter>Fichiers sources\DirectX  Tool Kit</Filter>
     </ClCompile>
-    <ClCompile Include="translateshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
+    <ClCompile Include="include\Src\DirectXHelpers.cpp">
+      <Filter>Fichiers sources\DirectX  Tool Kit</Filter>
     </ClCompile>
-    <ClCompile Include="reflectionshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
+    <ClCompile Include="include\Src\pch.cpp">
+      <Filter>Fichiers sources\DirectX  Tool Kit</Filter>
     </ClCompile>
-    <ClCompile Include="shadermanagerclass.cpp">
-      <Filter>Fichiers sources</Filter>
+    <ClCompile Include="include\Src\SimpleMath.cpp">
+      <Filter>Fichiers sources\DirectX  Tool Kit</Filter>
     </ClCompile>
-    <ClCompile Include="transparentshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
+    <ClCompile Include="include\Src\WICTextureLoader.cpp">
+      <Filter>Fichiers sources\DirectX  Tool Kit</Filter>
+    </ClCompile>
+    <ClCompile Include="alphamapshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="CelShadingShader.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="Colorshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="fontshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
     </ClCompile>
     <ClCompile Include="lightmapshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
+      <Filter>Fichiers sources\Shader</Filter>
     </ClCompile>
-    <ClCompile Include="watershaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
+    <ClCompile Include="Lightshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
     </ClCompile>
-    <ClCompile Include="refractionshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
-    </ClCompile>
-    <ClCompile Include="physics.cpp">
-      <Filter>Fichiers sources</Filter>
+    <ClCompile Include="Multitextureshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
     </ClCompile>
     <ClCompile Include="normalmapshaderclass.cpp">
-      <Filter>Fichiers sources</Filter>
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="reflectionshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="refractionshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="shadermanagerclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="specmapshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="watershaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="transparentshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="translateshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="textureshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="applicationclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="Cameraclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="d3dclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="imguiManager.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="inputclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="Lightclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="object.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="physics.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="modelclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="positionclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="rendertextureclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="Systemclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="Timerclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="textureclass.cpp">
+      <Filter>Fichiers sources\System</Filter>
+    </ClCompile>
+    <ClCompile Include="frustum.cpp">
+      <Filter>Fichiers sources\System</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="systemclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="inputclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="applicationclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="d3dclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="Colorshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="modelclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="Cameraclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="include\imconfig.h">
       <Filter>Fichiers d%27en-tête\ImGui</Filter>
     </ClInclude>
@@ -218,113 +251,146 @@
     <ClInclude Include="include\backends\imgui_impl_win32.h">
       <Filter>Fichiers d%27en-tête\ImGui</Filter>
     </ClInclude>
-    <ClInclude Include="imguiManager.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="lightshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="object.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="textureclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="bitmapclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
     <ClInclude Include="fontclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="fontshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="fpsclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="lightclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="Multitextureshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="Spriteclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
     <ClInclude Include="textclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="textureshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="Timerclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="fpsclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="lightmapshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="alphamapshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="normalmapshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="specmapshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="frustumclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
     <ClInclude Include="modellistclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="positionclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
     <ClInclude Include="displayplaneclass.h">
       <Filter>Fichiers d%27en-tête</Filter>
     </ClInclude>
-    <ClInclude Include="rendertextureclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
+    <ClInclude Include="include\Src\CMO.h">
+      <Filter>Fichiers d%27en-tête\DirectX Tool Kit</Filter>
     </ClInclude>
-    <ClInclude Include="translateshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
+    <ClInclude Include="include\Src\DDS.h">
+      <Filter>Fichiers d%27en-tête\DirectX Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="include\Src\LoaderHelpers.h">
+      <Filter>Fichiers d%27en-tête\DirectX Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="include\Src\pch.h">
+      <Filter>Fichiers d%27en-tête\DirectX Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="include\Src\PlatformHelpers.h">
+      <Filter>Fichiers d%27en-tête\DirectX Tool Kit</Filter>
+    </ClInclude>
+    <ClInclude Include="alphamapshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="CelShadingShader.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="Colorshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="fontshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="lightmapshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="lightshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="Multitextureshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="normalmapshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
     </ClInclude>
     <ClInclude Include="reflectionshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="resources.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="shadermanagerclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="transparentshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="Logger.h">
-      <Filter>Fichiers d%27en-tête</Filter>
-    </ClInclude>
-    <ClInclude Include="watershaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
     </ClInclude>
     <ClInclude Include="refractionshaderclass.h">
-      <Filter>Fichiers d%27en-tête</Filter>
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="shadermanagerclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="specmapshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="textureshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="translateshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="transparentshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="watershaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="applicationclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="d3dclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="Cameraclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="imguiManager.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="Logger.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="inputclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="lightclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="modelclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
     </ClInclude>
     <ClInclude Include="physics.h">
-      <Filter>Fichiers d%27en-tête</Filter>
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="Timerclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="textureclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="resources.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="rendertextureclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="positionclass.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="object.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
+    </ClInclude>
+    <ClInclude Include="frustum.h">
+      <Filter>Fichiers d%27en-tête\System</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <Image Include="papier.tga">
-      <Filter>assets</Filter>
-    </Image>
-    <Image Include="dirt01.tga">
-      <Filter>assets</Filter>
-    </Image>
     <Image Include="KhaoticIcon.ico">
       <Filter>Assets</Filter>
     </Image>
@@ -332,17 +398,6 @@
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
-  <ItemGroup>
-    <Text Include="sphere.txt">
-      <Filter>Assets</Filter>
-    </Text>
-    <Text Include="square.txt">
-      <Filter>assets</Filter>
-    </Text>
-    <Text Include="chunk.txt">
-      <Filter>Assets</Filter>
-    </Text>
-  </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="resources.rc">
       <Filter>Fichiers de ressources</Filter>
@@ -367,39 +422,12 @@
     <CopyFileToFolders Include="font01.tga">
       <Filter>fonts</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="stone01.tga">
-      <Filter>assets</Filter>
-    </CopyFileToFolders>
-    <CopyFileToFolders Include="cube.txt">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
-    <CopyFileToFolders Include="plane.txt">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
-    <CopyFileToFolders Include="alpha01.tga">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
-    <CopyFileToFolders Include="light01.tga">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
-    <CopyFileToFolders Include="moss01.tga">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
-    <CopyFileToFolders Include="normal01.tga">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
-    <CopyFileToFolders Include="spec02.tga">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
     <CopyFileToFolders Include="sprite01.tga">
       <Filter>Assets</Filter>
     </CopyFileToFolders>
     <CopyFileToFolders Include="sprite02.tga">
       <Filter>Assets</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="sprite_data_01.txt">
-      <Filter>Assets</Filter>
-    </CopyFileToFolders>
     <CopyFileToFolders Include="sprite03.tga">
       <Filter>Assets</Filter>
     </CopyFileToFolders>
@@ -478,35 +506,125 @@
     <CopyFileToFolders Include="water.vs">
       <Filter>shader</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="wall.tga">
-      <Filter>assets</Filter>
+    <CopyFileToFolders Include="celshading.vs">
+      <Filter>shader</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="water01.tga">
+    <CopyFileToFolders Include="celshading.ps">
+      <Filter>shader</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\bath.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\chunk.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\cube.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\ground.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\plane.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\sphere.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\square.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\wall.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\TXT\water.txt">
+      <Filter>Assets\Model\TXT</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\OBJ\vaisseau.obj">
+      <Filter>Assets\Model\OBJ</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\OBJ\monke.obj">
+      <Filter>Assets\Model\OBJ</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\OBJ\isosphere.obj">
+      <Filter>Assets\Model\OBJ</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\OBJ\cone.obj">
+      <Filter>Assets\Model\OBJ</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\OBJ\86.obj">
+      <Filter>Assets\Model\OBJ</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="sprite_data_01.txt">
       <Filter>Assets</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="bath.txt">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\stone01.tga">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="marble01.tga">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\alpha01.png">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="water.txt">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\Bricks2K.png">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="isosphere.obj">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\BricksGLOSS2K.png">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="cone.obj">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\BricksNRM2K.png">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="monke.obj">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\dirt01.png">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="vaisseau.obj">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\font01.png">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
-    <CopyFileToFolders Include="86.obj">
-      <Filter>Assets</Filter>
+    <CopyFileToFolders Include="assets\Texture\ground01.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\light01.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\marble01.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\moss01.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\normal01.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\spec02.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite01.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite02.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite03.png">
+      <Filter>Assets\Texture</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\sprite04.png">
+      <Filter>Fichiers de ressources</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\stone01.png">
+      <Filter>Fichiers de ressources</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\wall.png">
+      <Filter>Fichiers de ressources</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\wall01.png">
+      <Filter>Fichiers de ressources</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\water01.png">
+      <Filter>Fichiers de ressources</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Model\OBJ\plane.obj">
+      <Filter>Assets\Model\OBJ</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="assets\Texture\EmptyTexture.png">
+      <Filter>Assets\Texture</Filter>
     </CopyFileToFolders>
   </ItemGroup>
 </Project>

enginecustom/frustum.cpp

@@ -0,0 +1,88 @@
+#include "frustum.h"
+
+void Frustum::ConstructFrustum(float screenDepth, XMMATRIX projectionMatrix, XMMATRIX viewMatrix)
+{
+    XMMATRIX matrix;
+    XMVECTOR planes[6];
+
+    // Calculate the minimum Z distance in the frustum.
+    float zMinimum = -projectionMatrix.r[3].m128_f32[2] / projectionMatrix.r[2].m128_f32[2];
+    float r = screenDepth / (screenDepth - zMinimum);
+    projectionMatrix.r[2].m128_f32[2] = r;
+    projectionMatrix.r[3].m128_f32[2] = -r * zMinimum;
+
+    // Create the frustum matrix from the view matrix and updated projection matrix.
+    matrix = XMMatrixMultiply(viewMatrix, projectionMatrix);
+
+    // Calculate near plane of frustum.
+    planes[0] = XMPlaneNormalize(XMVectorSet(matrix.r[0].m128_f32[3] + matrix.r[0].m128_f32[2],
+        matrix.r[1].m128_f32[3] + matrix.r[1].m128_f32[2],
+        matrix.r[2].m128_f32[3] + matrix.r[2].m128_f32[2],
+        matrix.r[3].m128_f32[3] + matrix.r[3].m128_f32[2]));
+
+    // Calculate far plane of frustum.
+    planes[1] = XMPlaneNormalize(XMVectorSet(matrix.r[0].m128_f32[3] - matrix.r[0].m128_f32[2],
+        matrix.r[1].m128_f32[3] - matrix.r[1].m128_f32[2],
+        matrix.r[2].m128_f32[3] - matrix.r[2].m128_f32[2],
+        matrix.r[3].m128_f32[3] - matrix.r[3].m128_f32[2]));
+
+    // Calculate left plane of frustum.
+    planes[2] = XMPlaneNormalize(XMVectorSet(matrix.r[0].m128_f32[3] + matrix.r[0].m128_f32[0],
+        matrix.r[1].m128_f32[3] + matrix.r[1].m128_f32[0],
+        matrix.r[2].m128_f32[3] + matrix.r[2].m128_f32[0],
+        matrix.r[3].m128_f32[3] + matrix.r[3].m128_f32[0]));
+
+    // Calculate right plane of frustum.
+    planes[3] = XMPlaneNormalize(XMVectorSet(matrix.r[0].m128_f32[3] - matrix.r[0].m128_f32[0],
+        matrix.r[1].m128_f32[3] - matrix.r[1].m128_f32[0],
+        matrix.r[2].m128_f32[3] - matrix.r[2].m128_f32[0],
+        matrix.r[3].m128_f32[3] - matrix.r[3].m128_f32[0]));
+
+    // Calculate top plane of frustum.
+    planes[4] = XMPlaneNormalize(XMVectorSet(matrix.r[0].m128_f32[3] - matrix.r[0].m128_f32[1],
+        matrix.r[1].m128_f32[3] - matrix.r[1].m128_f32[1],
+        matrix.r[2].m128_f32[3] - matrix.r[2].m128_f32[1],
+        matrix.r[3].m128_f32[3] - matrix.r[3].m128_f32[1]));
+
+    // Calculate bottom plane of frustum.
+    planes[5] = XMPlaneNormalize(XMVectorSet(matrix.r[0].m128_f32[3] + matrix.r[0].m128_f32[1],
+        matrix.r[1].m128_f32[3] + matrix.r[1].m128_f32[1],
+        matrix.r[2].m128_f32[3] + matrix.r[2].m128_f32[1],
+        matrix.r[3].m128_f32[3] + matrix.r[3].m128_f32[1]));
+
+    for (int i = 0; i < 6; i++)
+    {
+        m_planes[i] = planes[i];
+    }
+}
+
+bool Frustum::CheckCube(float xCenter, float yCenter, float zCenter, float radius, float tolerance)
+{
+    // V<>rifiez chaque plan du frustum pour voir si le cube est <20> l'int<6E>rieur
+    for (int i = 0; i < 6; i++)
+    {
+        XMVECTOR plane = m_planes[i];
+        if (XMVectorGetX(plane) * (xCenter - radius) + XMVectorGetY(plane) * (yCenter - radius) + XMVectorGetZ(plane) * (zCenter - radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+        if (XMVectorGetX(plane) * (xCenter + radius) + XMVectorGetY(plane) * (yCenter - radius) + XMVectorGetZ(plane) * (zCenter - radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+        if (XMVectorGetX(plane) * (xCenter - radius) + XMVectorGetY(plane) * (yCenter + radius) + XMVectorGetZ(plane) * (zCenter - radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+        if (XMVectorGetX(plane) * (xCenter + radius) + XMVectorGetY(plane) * (yCenter + radius) + XMVectorGetZ(plane) * (zCenter - radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+        if (XMVectorGetX(plane) * (xCenter - radius) + XMVectorGetY(plane) * (yCenter - radius) + XMVectorGetZ(plane) * (zCenter + radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+        if (XMVectorGetX(plane) * (xCenter + radius) + XMVectorGetY(plane) * (yCenter - radius) + XMVectorGetZ(plane) * (zCenter + radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+        if (XMVectorGetX(plane) * (xCenter - radius) + XMVectorGetY(plane) * (yCenter + radius) + XMVectorGetZ(plane) * (zCenter + radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+        if (XMVectorGetX(plane) * (xCenter + radius) + XMVectorGetY(plane) * (yCenter + radius) + XMVectorGetZ(plane) * (zCenter + radius) + XMVectorGetW(plane) > -tolerance)
+            continue;
+
+        // Si le cube est en dehors de l'un des plans, il n'est pas dans le frustum
+        return false;
+    }
+
+    // Si le cube est <20> l'int<6E>rieur de tous les plans, il est dans le frustum
+    return true;
+}

enginecustom/frustum.h

@@ -0,0 +1,12 @@
+#include <DirectXMath.h>
+using namespace DirectX;
+
+class Frustum
+{
+public:
+    void ConstructFrustum(float screenDepth, XMMATRIX projectionMatrix, XMMATRIX viewMatrix);
+    bool CheckCube(float xCenter, float yCenter, float zCenter, float radius, float tolerance);
+
+private:
+    XMVECTOR m_planes[6];
+};

enginecustom/imgui.ini

@@ -3,18 +3,26 @@ Pos=60,60
 Size=400,400
 
 [Window][Khaotic Engine]
-Pos=429,57
-Size=392,218
+Pos=1143,44
+Size=392,273
 
 [Window][Objects]
-Pos=39,222
-Size=589,294
+Pos=934,36
+Size=457,294
 
 [Window][Terrain]
-Pos=60,60
+Pos=58,62
 Size=342,82
 
 [Window][Light]
-Pos=95,296
-Size=345,230
+Pos=1548,17
+Size=358,535
+
+[Window][Shader Manager]
+Pos=471,90
+Size=180,79
+
+[Window][Engine Settings]
+Pos=106,212
+Size=407,81
 

enginecustom/imguiManager.cpp

@@ -111,6 +111,17 @@ void imguiManager::WidgetAddObject(ApplicationClass* app)
 	}
 }
 
+void imguiManager::WidgetShaderWindow(ApplicationClass* app)
+{
+	ImGui::Begin("Shader Manager");
+
+	// Checkbox for toggling cel shading globally in the application class by calling the SetCelShading function in the application class when the checkbox state changes
+	ImGui::Checkbox("Enable Cel Shading", &m_EnableCelShading);
+	app->SetCelShading(m_EnableCelShading);
+	
+	ImGui::End();
+}
+
 void imguiManager::WidgetObjectWindow(ApplicationClass* app)
 {
 	ImGui::Begin("Objects", &showObjectWindow);
@@ -150,10 +161,16 @@ void imguiManager::WidgetObjectWindow(ApplicationClass* app)
 
 			// Texture
 			// add all texture category names to a vector
-			std::vector<std::string> textureCategories = { "Diffuse", "Normal", "Specular", "Alpha", "Light", "Change Me" };
+			std::vector<std::string> textureCategories = { 
+				"Diffuse",
+				"Normal",
+				"Specular",
+				"Reflection",
+				"Refraction"
+			};
 
 
-			for (int count = 0; count < 6; count++)
+			for (int count = 0; count < 1; count++)
 			{
 				std::string textureLabel = "Texture##" + std::to_string(index);
 				ID3D11ShaderResourceView* texture = object->GetTexture(count);
@@ -174,7 +191,7 @@ void imguiManager::WidgetObjectWindow(ApplicationClass* app)
 			}
 
 			// Display all images
-			for (int count = 0; count < 6; count++)
+			for (int count = 0; count < 1; count++)
 			{
 				std::string textureLabel = "Texture##" + std::to_string(index);
 				ID3D11ShaderResourceView* texture = object->GetTexture(count);
@@ -194,7 +211,7 @@ void imguiManager::WidgetObjectWindow(ApplicationClass* app)
 						ofn.lpstrFile = szFile;
 						ofn.lpstrFile[0] = '\0';
 						ofn.nMaxFile = sizeof(szFile);
-						ofn.lpstrFilter = L"Texture\0*.tga\0";
+						ofn.lpstrFilter = L"Texture\0*.png\0";
 						ofn.nFilterIndex = 1;
 						ofn.lpstrFileTitle = NULL;
 						ofn.nMaxFileTitle = 0;
@@ -233,6 +250,34 @@ void imguiManager::WidgetObjectWindow(ApplicationClass* app)
 				app->DeleteKobject(index);
 			}
 
+			// Shader selection
+			std::string shaderLabel = "Shader##" + std::to_string(index);
+
+			// Radio buttons for shader options
+			Object::ShaderType activeShader = object->GetActiveShader();
+			
+			if (ImGui::RadioButton("Enable Lighting", activeShader == Object::LIGHTING))
+			{
+				object->SetActiveShader(Object::LIGHTING);
+			}
+			
+			if (ImGui::RadioButton("Enable Cel Shading", activeShader == Object::CEL_SHADING))
+			{
+				object->SetActiveShader(Object::CEL_SHADING);
+			}
+			
+			if (ImGui::RadioButton("Enable Normal Mapping", activeShader == Object::NORMAL_MAPPING))
+			{
+				object->SetActiveShader(Object::NORMAL_MAPPING);
+			}
+
+			if (ImGui::RadioButton("Enable Specular Mapping", activeShader == Object::SPECULAR_MAPPING))
+			{
+				object->SetActiveShader(Object::SPECULAR_MAPPING);
+			}
+			
+
+
 			ImGui::Separator();
 
 			// Demo spinning
@@ -300,6 +345,16 @@ bool imguiManager::ImGuiWidgetRenderer(ApplicationClass* app)
 		showLightWindow = true;
 	}
 
+	if (ImGui::Button("Open Shader Window"))
+	{
+		showShaderWindow = true;
+	}
+
+	if (ImGui::Button("Open Engine Settings Window"))
+	{
+		showEngineSettingsWindow = true;
+	}
+
 	ImGui::End();
 
 	// Show windows if their corresponding variables are true
@@ -318,6 +373,16 @@ bool imguiManager::ImGuiWidgetRenderer(ApplicationClass* app)
 		WidgetLightWindow(app);
 	}
 
+	if (showShaderWindow)
+	{
+		WidgetShaderWindow(app);
+	}
+
+	if (showEngineSettingsWindow)
+	{
+		WidgetEngineSettingsWindow(app);
+	}
+
 	//render imgui
 	Render();
 
@@ -352,10 +417,30 @@ void imguiManager::WidgetLightWindow(ApplicationClass* app)
 				app->SetLightColor(index, XMVectorSet(col[0], col[1], col[2], 0.0f));
 			}
 
-			ImGui::Separator();
 		}
 		index++;
 	};
 
 	ImGui::End();
 }
+
+void imguiManager::WidgetEngineSettingsWindow(ApplicationClass* app)
+{
+	ImGui::Begin("Engine Settings", &showEngineSettingsWindow);
+
+	// Checkbox for toggling vsync globally in the application class by calling the SetVsync function in the application class when the checkbox state changes
+	bool vsync = app->GetVsync();
+	if (ImGui::Checkbox("Vsync", &vsync))
+	{
+		app->SetVsync(vsync);
+	}
+
+	// float input for frustum tolerance
+	float frustumTolerance = app->GetFrustumTolerance();
+	if (ImGui::DragFloat("Frustum Tolerance", &frustumTolerance, 0.1f, 0.0f, 100.0f))
+	{
+		app->SetFrustumTolerance(frustumTolerance);
+	}
+
+	ImGui::End();
+}

enginecustom/imguiManager.h

@@ -31,13 +31,21 @@ public:
 	void WidgetObjectWindow(ApplicationClass* app);
 	void WidgetTerrainWindow(ApplicationClass* app);
 	void WidgetLightWindow(ApplicationClass* app);
+	void WidgetShaderWindow(ApplicationClass* app);
+	void WidgetEngineSettingsWindow(ApplicationClass* app);
 
 	bool ImGuiWidgetRenderer(ApplicationClass* app);
 
+	// Shader toggles
+
+	bool m_EnableCelShading;
+
 private :
 	bool showObjectWindow = false;
 	bool showTerrainWindow = false;
 	bool showLightWindow = false;
+	bool showShaderWindow = false;
+	bool showEngineSettingsWindow = false;
 
 private:
 	ImGuiIO* io;

enginecustom/include/Inc/Audio.h

@@ -0,0 +1,832 @@
+//--------------------------------------------------------------------------------------
+// File: Audio.h
+//
+// DirectXTK for Audio header
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <objbase.h>
+#include <mmreg.h>
+#include <Audioclient.h>
+
+#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
+#include <xma2defs.h>
+#ifdef _MSC_VER
+#pragma comment(lib,"acphal.lib")
+#endif
+#endif
+
+#ifndef XAUDIO2_HELPER_FUNCTIONS
+#define XAUDIO2_HELPER_FUNCTIONS
+#endif
+
+#if defined(USING_XAUDIO2_REDIST) || (_WIN32_WINNT >= 0x0A00 /*_WIN32_WINNT_WIN10*/) || defined(_XBOX_ONE)
+#define USING_XAUDIO2_9
+#elif (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/)
+#define USING_XAUDIO2_8
+#elif (_WIN32_WINNT >= 0x0601 /*_WIN32_WINNT_WIN7*/)
+#error Windows 7 SP1 requires the XAudio2Redist NuGet package https://aka.ms/xaudio2redist
+#else
+#error DirectX Tool Kit for Audio not supported on this platform
+#endif
+
+#include <xaudio2.h>
+#include <xaudio2fx.h>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4619 4616 5246)
+#endif
+#include <x3daudio.h>
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#include <xapofx.h>
+
+#if !defined(USING_XAUDIO2_REDIST) && defined(_MSC_VER)
+#if defined(USING_XAUDIO2_8) && defined(NTDDI_WIN10) && !defined(_M_IX86)
+// The xaudio2_8.lib in the Windows 10 SDK for x86 is incorrectly annotated as __cdecl instead of __stdcall, so avoid using it in this case.
+#pragma comment(lib,"xaudio2_8.lib")
+#else
+#pragma comment(lib,"xaudio2.lib")
+#endif
+#endif
+
+#include <DirectXMath.h>
+
+
+namespace DirectX
+{
+    class SoundEffectInstance;
+    class SoundStreamInstance;
+
+    //----------------------------------------------------------------------------------
+    struct AudioStatistics
+    {
+        size_t  playingOneShots;        // Number of one-shot sounds currently playing
+        size_t  playingInstances;       // Number of sound effect instances currently playing
+        size_t  allocatedInstances;     // Number of SoundEffectInstance allocated
+        size_t  allocatedVoices;        // Number of XAudio2 voices allocated (standard, 3D, one-shots, and idle one-shots)
+        size_t  allocatedVoices3d;      // Number of XAudio2 voices allocated for 3D
+        size_t  allocatedVoicesOneShot; // Number of XAudio2 voices allocated for one-shot sounds
+        size_t  allocatedVoicesIdle;    // Number of XAudio2 voices allocated for one-shot sounds but not currently in use
+        size_t  audioBytes;             // Total wave data (in bytes) in SoundEffects and in-memory WaveBanks
+    #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
+        size_t  xmaAudioBytes;          // Total wave data (in bytes) in SoundEffects and in-memory WaveBanks allocated with ApuAlloc
+    #endif
+        size_t  streamingBytes;         // Total size of streaming buffers (in bytes) in streaming WaveBanks
+    };
+
+
+    //----------------------------------------------------------------------------------
+    class IVoiceNotify
+    {
+    public:
+        virtual ~IVoiceNotify() = default;
+
+        IVoiceNotify(const IVoiceNotify&) = delete;
+        IVoiceNotify& operator=(const IVoiceNotify&) = delete;
+
+        IVoiceNotify(IVoiceNotify&&) = default;
+        IVoiceNotify& operator=(IVoiceNotify&&) = default;
+
+        virtual void __cdecl OnBufferEnd() = 0;
+            // Notfication that a voice buffer has finished
+            // Note this is called from XAudio2's worker thread, so it should perform very minimal and thread-safe operations
+
+        virtual void __cdecl OnCriticalError() = 0;
+            // Notification that the audio engine encountered a critical error
+
+        virtual void __cdecl OnReset() = 0;
+            // Notification of an audio engine reset
+
+        virtual void __cdecl OnUpdate() = 0;
+            // Notification of an audio engine per-frame update (opt-in)
+
+        virtual void __cdecl OnDestroyEngine() noexcept = 0;
+            // Notification that the audio engine is being destroyed
+
+        virtual void __cdecl OnTrim() = 0;
+            // Notification of a request to trim the voice pool
+
+        virtual void __cdecl GatherStatistics(AudioStatistics& stats) const = 0;
+            // Contribute to statistics request
+
+        virtual void __cdecl OnDestroyParent() noexcept = 0;
+            // Optional notification used by some objects
+
+    protected:
+        IVoiceNotify() = default;
+    };
+
+    //----------------------------------------------------------------------------------
+    enum AUDIO_ENGINE_FLAGS : uint32_t
+    {
+        AudioEngine_Default = 0x0,
+
+        AudioEngine_EnvironmentalReverb = 0x1,
+        AudioEngine_ReverbUseFilters = 0x2,
+        AudioEngine_UseMasteringLimiter = 0x4,
+
+        AudioEngine_Debug = 0x10000,
+        AudioEngine_ThrowOnNoAudioHW = 0x20000,
+        AudioEngine_DisableVoiceReuse = 0x40000,
+    };
+
+    enum SOUND_EFFECT_INSTANCE_FLAGS : uint32_t
+    {
+        SoundEffectInstance_Default = 0x0,
+
+        SoundEffectInstance_Use3D = 0x1,
+        SoundEffectInstance_ReverbUseFilters = 0x2,
+        SoundEffectInstance_NoSetPitch = 0x4,
+
+        SoundEffectInstance_UseRedirectLFE = 0x10000,
+    };
+
+    enum AUDIO_ENGINE_REVERB : unsigned int
+    {
+        Reverb_Off,
+        Reverb_Default,
+        Reverb_Generic,
+        Reverb_Forest,
+        Reverb_PaddedCell,
+        Reverb_Room,
+        Reverb_Bathroom,
+        Reverb_LivingRoom,
+        Reverb_StoneRoom,
+        Reverb_Auditorium,
+        Reverb_ConcertHall,
+        Reverb_Cave,
+        Reverb_Arena,
+        Reverb_Hangar,
+        Reverb_CarpetedHallway,
+        Reverb_Hallway,
+        Reverb_StoneCorridor,
+        Reverb_Alley,
+        Reverb_City,
+        Reverb_Mountains,
+        Reverb_Quarry,
+        Reverb_Plain,
+        Reverb_ParkingLot,
+        Reverb_SewerPipe,
+        Reverb_Underwater,
+        Reverb_SmallRoom,
+        Reverb_MediumRoom,
+        Reverb_LargeRoom,
+        Reverb_MediumHall,
+        Reverb_LargeHall,
+        Reverb_Plate,
+        Reverb_MAX
+    };
+
+    enum SoundState
+    {
+        STOPPED = 0,
+        PLAYING,
+        PAUSED
+    };
+
+
+    //----------------------------------------------------------------------------------
+    class AudioEngine
+    {
+    public:
+        explicit AudioEngine(
+            AUDIO_ENGINE_FLAGS flags = AudioEngine_Default,
+            _In_opt_ const WAVEFORMATEX* wfx = nullptr,
+            _In_opt_z_ const wchar_t* deviceId = nullptr,
+            AUDIO_STREAM_CATEGORY category = AudioCategory_GameEffects) noexcept(false);
+
+        AudioEngine(AudioEngine&&) noexcept;
+        AudioEngine& operator= (AudioEngine&&) noexcept;
+
+        AudioEngine(AudioEngine const&) = delete;
+        AudioEngine& operator= (AudioEngine const&) = delete;
+
+        virtual ~AudioEngine();
+
+        bool __cdecl Update();
+            // Performs per-frame processing for the audio engine, returns false if in 'silent mode'
+
+        bool __cdecl Reset(_In_opt_ const WAVEFORMATEX* wfx = nullptr, _In_opt_z_ const wchar_t* deviceId = nullptr);
+            // Reset audio engine from critical error/silent mode using a new device; can also 'migrate' the graph
+            // Returns true if succesfully reset, false if in 'silent mode' due to no default device
+            // Note: One shots are lost, all SoundEffectInstances are in the STOPPED state after successful reset
+
+        void __cdecl Suspend() noexcept;
+        void __cdecl Resume();
+            // Suspend/resumes audio processing (i.e. global pause/resume)
+
+        float __cdecl GetMasterVolume() const noexcept;
+        void __cdecl SetMasterVolume(float volume);
+            // Master volume property for all sounds
+
+        void __cdecl SetReverb(AUDIO_ENGINE_REVERB reverb);
+        void __cdecl SetReverb(_In_opt_ const XAUDIO2FX_REVERB_PARAMETERS* native);
+            // Sets environmental reverb for 3D positional audio (if active)
+
+        void __cdecl SetMasteringLimit(int release, int loudness);
+            // Sets the mastering volume limiter properties (if active)
+
+        AudioStatistics __cdecl GetStatistics() const;
+            // Gathers audio engine statistics
+
+        WAVEFORMATEXTENSIBLE __cdecl GetOutputFormat() const noexcept;
+            // Returns the format of the audio output device associated with the mastering voice.
+
+        uint32_t __cdecl GetChannelMask() const noexcept;
+            // Returns the output channel mask
+
+        int __cdecl GetOutputSampleRate() const noexcept;
+            // Returns the sample rate going into the mastering voice
+
+        unsigned int __cdecl GetOutputChannels() const noexcept;
+            // Returns the number of channels going into the mastering voice
+
+        bool __cdecl IsAudioDevicePresent() const noexcept;
+            // Returns true if the audio graph is operating normally, false if in 'silent mode'
+
+        bool __cdecl IsCriticalError() const noexcept;
+            // Returns true if the audio graph is halted due to a critical error (which also places the engine into 'silent mode')
+
+        // Voice pool management.
+        void __cdecl SetDefaultSampleRate(int sampleRate);
+            // Sample rate for voices in the reuse pool (defaults to 44100)
+
+        void __cdecl SetMaxVoicePool(size_t maxOneShots, size_t maxInstances);
+            // Maximum number of voices to allocate for one-shots and instances
+            // Note: one-shots over this limit are ignored; too many instance voices throws an exception
+
+        void __cdecl TrimVoicePool();
+            // Releases any currently unused voices
+
+        // Internal-use functions
+        void __cdecl AllocateVoice(_In_ const WAVEFORMATEX* wfx,
+            SOUND_EFFECT_INSTANCE_FLAGS flags, bool oneshot, _Outptr_result_maybenull_ IXAudio2SourceVoice** voice);
+
+        void __cdecl DestroyVoice(_In_ IXAudio2SourceVoice* voice) noexcept;
+            // Should only be called for instance voices, not one-shots
+
+        void __cdecl RegisterNotify(_In_ IVoiceNotify* notify, bool usesUpdate);
+        void __cdecl UnregisterNotify(_In_ IVoiceNotify* notify, bool usesOneShots, bool usesUpdate);
+
+        // XAudio2 interface access
+        IXAudio2* __cdecl GetInterface() const noexcept;
+        IXAudio2MasteringVoice* __cdecl GetMasterVoice() const noexcept;
+        IXAudio2SubmixVoice* __cdecl GetReverbVoice() const noexcept;
+        X3DAUDIO_HANDLE& __cdecl Get3DHandle() const noexcept;
+
+        // Static functions
+        struct RendererDetail
+        {
+            std::wstring deviceId;
+            std::wstring description;
+        };
+
+        static std::vector<RendererDetail> __cdecl GetRendererDetails();
+            // Returns a list of valid audio endpoint devices
+
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+        explicit AudioEngine(
+            AUDIO_ENGINE_FLAGS flags = AudioEngine_Default,
+            _In_opt_ const WAVEFORMATEX* wfx = nullptr,
+            _In_opt_z_ const __wchar_t* deviceId = nullptr,
+            AUDIO_STREAM_CATEGORY category = AudioCategory_GameEffects) noexcept(false);
+
+        bool __cdecl Reset(_In_opt_ const WAVEFORMATEX* wfx = nullptr, _In_opt_z_ const __wchar_t* deviceId = nullptr);
+#endif
+
+    private:
+        // Private implementation.
+        class Impl;
+        std::unique_ptr<Impl> pImpl;
+    };
+
+
+    //----------------------------------------------------------------------------------
+    class WaveBank
+    {
+    public:
+        WaveBank(_In_ AudioEngine* engine, _In_z_ const wchar_t* wbFileName);
+
+        WaveBank(WaveBank&&) noexcept;
+        WaveBank& operator= (WaveBank&&) noexcept;
+
+        WaveBank(WaveBank const&) = delete;
+        WaveBank& operator= (WaveBank const&) = delete;
+
+        virtual ~WaveBank();
+
+        void __cdecl Play(unsigned int index);
+        void __cdecl Play(unsigned int index, float volume, float pitch, float pan);
+
+        void __cdecl Play(_In_z_ const char* name);
+        void __cdecl Play(_In_z_ const char* name, float volume, float pitch, float pan);
+
+        std::unique_ptr<SoundEffectInstance> __cdecl CreateInstance(unsigned int index,
+            SOUND_EFFECT_INSTANCE_FLAGS flags = SoundEffectInstance_Default);
+        std::unique_ptr<SoundEffectInstance> __cdecl CreateInstance(_In_z_ const char* name,
+            SOUND_EFFECT_INSTANCE_FLAGS flags = SoundEffectInstance_Default);
+
+        std::unique_ptr<SoundStreamInstance> __cdecl CreateStreamInstance(unsigned int index,
+            SOUND_EFFECT_INSTANCE_FLAGS flags = SoundEffectInstance_Default);
+        std::unique_ptr<SoundStreamInstance> __cdecl CreateStreamInstance(_In_z_ const char* name,
+            SOUND_EFFECT_INSTANCE_FLAGS flags = SoundEffectInstance_Default);
+
+        bool __cdecl IsPrepared() const noexcept;
+        bool __cdecl IsInUse() const noexcept;
+        bool __cdecl IsStreamingBank() const noexcept;
+        bool __cdecl IsAdvancedFormat() const noexcept;
+
+        size_t __cdecl GetSampleSizeInBytes(unsigned int index) const noexcept;
+        // Returns size of wave audio data
+
+        size_t __cdecl GetSampleDuration(unsigned int index) const noexcept;
+        // Returns the duration in samples
+
+        size_t __cdecl GetSampleDurationMS(unsigned int index) const noexcept;
+        // Returns the duration in milliseconds
+
+        const WAVEFORMATEX* __cdecl GetFormat(unsigned int index, _Out_writes_bytes_(maxsize) WAVEFORMATEX* wfx, size_t maxsize) const noexcept;
+
+        int __cdecl Find(_In_z_ const char* name) const;
+
+    #ifdef USING_XAUDIO2_9
+        bool __cdecl FillSubmitBuffer(unsigned int index, _Out_ XAUDIO2_BUFFER& buffer, _Out_ XAUDIO2_BUFFER_WMA& wmaBuffer) const;
+    #else
+        void __cdecl FillSubmitBuffer(unsigned int index, _Out_ XAUDIO2_BUFFER& buffer) const;
+    #endif
+
+        void __cdecl UnregisterInstance(_In_ IVoiceNotify* instance);
+
+        HANDLE __cdecl GetAsyncHandle() const noexcept;
+
+        bool __cdecl GetPrivateData(unsigned int index, _Out_writes_bytes_(datasize) void* data, size_t datasize);
+
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+        WaveBank(_In_ AudioEngine* engine, _In_z_ const __wchar_t* wbFileName);
+#endif
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+    };
+
+
+    //----------------------------------------------------------------------------------
+    class SoundEffect
+    {
+    public:
+        SoundEffect(_In_ AudioEngine* engine, _In_z_ const wchar_t* waveFileName);
+
+        SoundEffect(_In_ AudioEngine* engine, _Inout_ std::unique_ptr<uint8_t[]>& wavData,
+            _In_ const WAVEFORMATEX* wfx, _In_reads_bytes_(audioBytes) const uint8_t* startAudio, size_t audioBytes);
+
+        SoundEffect(_In_ AudioEngine* engine, _Inout_ std::unique_ptr<uint8_t[]>& wavData,
+            _In_ const WAVEFORMATEX* wfx, _In_reads_bytes_(audioBytes) const uint8_t* startAudio, size_t audioBytes,
+            uint32_t loopStart, uint32_t loopLength);
+
+    #ifdef USING_XAUDIO2_9
+
+        SoundEffect(_In_ AudioEngine* engine, _Inout_ std::unique_ptr<uint8_t[]>& wavData,
+            _In_ const WAVEFORMATEX* wfx, _In_reads_bytes_(audioBytes) const uint8_t* startAudio, size_t audioBytes,
+            _In_reads_(seekCount) const uint32_t* seekTable, size_t seekCount);
+
+    #endif
+
+        SoundEffect(SoundEffect&&) noexcept;
+        SoundEffect& operator= (SoundEffect&&) noexcept;
+
+        SoundEffect(SoundEffect const&) = delete;
+        SoundEffect& operator= (SoundEffect const&) = delete;
+
+        virtual ~SoundEffect();
+
+        void __cdecl Play();
+        void __cdecl Play(float volume, float pitch, float pan);
+
+        std::unique_ptr<SoundEffectInstance> __cdecl CreateInstance(SOUND_EFFECT_INSTANCE_FLAGS flags = SoundEffectInstance_Default);
+
+        bool __cdecl IsInUse() const noexcept;
+
+        size_t __cdecl GetSampleSizeInBytes() const noexcept;
+        // Returns size of wave audio data
+
+        size_t __cdecl GetSampleDuration() const noexcept;
+        // Returns the duration in samples
+
+        size_t __cdecl GetSampleDurationMS() const noexcept;
+        // Returns the duration in milliseconds
+
+        const WAVEFORMATEX* __cdecl GetFormat() const noexcept;
+
+    #ifdef USING_XAUDIO2_9
+        bool __cdecl FillSubmitBuffer(_Out_ XAUDIO2_BUFFER& buffer, _Out_ XAUDIO2_BUFFER_WMA& wmaBuffer) const;
+    #else
+        void __cdecl FillSubmitBuffer(_Out_ XAUDIO2_BUFFER& buffer) const;
+    #endif
+
+        void __cdecl UnregisterInstance(_In_ IVoiceNotify* instance);
+
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+        SoundEffect(_In_ AudioEngine* engine, _In_z_ const __wchar_t* waveFileName);
+#endif
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+    };
+
+
+    //----------------------------------------------------------------------------------
+    struct AudioListener : public X3DAUDIO_LISTENER
+    {
+        X3DAUDIO_CONE   ListenerCone;
+
+        AudioListener() noexcept :
+            X3DAUDIO_LISTENER{},
+            ListenerCone{}
+        {
+            OrientFront.z = -1.f;
+
+            OrientTop.y = 1.f;
+        }
+
+        void XM_CALLCONV SetPosition(FXMVECTOR v) noexcept
+        {
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Position), v);
+        }
+        void __cdecl SetPosition(const XMFLOAT3& pos) noexcept
+        {
+            Position.x = pos.x;
+            Position.y = pos.y;
+            Position.z = pos.z;
+        }
+
+        void XM_CALLCONV SetVelocity(FXMVECTOR v) noexcept
+        {
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Velocity), v);
+        }
+        void __cdecl SetVelocity(const XMFLOAT3& vel) noexcept
+        {
+            Velocity.x = vel.x;
+            Velocity.y = vel.y;
+            Velocity.z = vel.z;
+        }
+
+        void XM_CALLCONV SetOrientation(FXMVECTOR forward, FXMVECTOR up) noexcept
+        {
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientFront), forward);
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientTop), up);
+        }
+        void __cdecl SetOrientation(const XMFLOAT3& forward, const XMFLOAT3& up) noexcept
+        {
+            OrientFront.x = forward.x;  OrientTop.x = up.x;
+            OrientFront.y = forward.y;  OrientTop.y = up.y;
+            OrientFront.z = forward.z;  OrientTop.z = up.z;
+        }
+
+        void XM_CALLCONV SetOrientationFromQuaternion(FXMVECTOR quat) noexcept
+        {
+            const XMVECTOR forward = XMVector3Rotate(g_XMIdentityR2, quat);
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientFront), forward);
+
+            const XMVECTOR up = XMVector3Rotate(g_XMIdentityR1, quat);
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientTop), up);
+        }
+
+        // Updates velocity and orientation by tracking changes in position over time.
+        void XM_CALLCONV Update(FXMVECTOR newPos, XMVECTOR upDir, float dt) noexcept
+        {
+            if (dt > 0.f)
+            {
+                const XMVECTOR lastPos = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(&Position));
+
+                XMVECTOR vDelta = XMVectorSubtract(newPos, lastPos);
+                const XMVECTOR vt = XMVectorReplicate(dt);
+                XMVECTOR v = XMVectorDivide(vDelta, vt);
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Velocity), v);
+
+                vDelta = XMVector3Normalize(vDelta);
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientFront), vDelta);
+
+                v = XMVector3Cross(upDir, vDelta);
+                v = XMVector3Normalize(v);
+
+                v = XMVector3Cross(vDelta, v);
+                v = XMVector3Normalize(v);
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientTop), v);
+
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Position), newPos);
+            }
+        }
+
+        void __cdecl SetOmnidirectional() noexcept
+        {
+            pCone = nullptr;
+        }
+
+        void __cdecl SetCone(const X3DAUDIO_CONE& listenerCone);
+
+        bool __cdecl IsValid() const;
+    };
+
+
+    //----------------------------------------------------------------------------------
+    struct AudioEmitter : public X3DAUDIO_EMITTER
+    {
+        X3DAUDIO_CONE   EmitterCone;
+        float           EmitterAzimuths[XAUDIO2_MAX_AUDIO_CHANNELS];
+
+        AudioEmitter() noexcept :
+            X3DAUDIO_EMITTER{},
+            EmitterCone{},
+            EmitterAzimuths{}
+        {
+            OrientFront.z = -1.f;
+
+            OrientTop.y =
+                ChannelRadius =
+                CurveDistanceScaler =
+                DopplerScaler = 1.f;
+
+            ChannelCount = 1;
+            pChannelAzimuths = EmitterAzimuths;
+
+            InnerRadiusAngle = X3DAUDIO_PI / 4.0f;
+        }
+
+        void XM_CALLCONV SetPosition(FXMVECTOR v) noexcept
+        {
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Position), v);
+        }
+        void __cdecl SetPosition(const XMFLOAT3& pos) noexcept
+        {
+            Position.x = pos.x;
+            Position.y = pos.y;
+            Position.z = pos.z;
+        }
+
+        void XM_CALLCONV SetVelocity(FXMVECTOR v) noexcept
+        {
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Velocity), v);
+        }
+        void __cdecl SetVelocity(const XMFLOAT3& vel) noexcept
+        {
+            Velocity.x = vel.x;
+            Velocity.y = vel.y;
+            Velocity.z = vel.z;
+        }
+
+        void XM_CALLCONV SetOrientation(FXMVECTOR forward, FXMVECTOR up) noexcept
+        {
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientFront), forward);
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientTop), up);
+        }
+        void __cdecl SetOrientation(const XMFLOAT3& forward, const XMFLOAT3& up) noexcept
+        {
+            OrientFront.x = forward.x;  OrientTop.x = up.x;
+            OrientFront.y = forward.y;  OrientTop.y = up.y;
+            OrientFront.z = forward.z;  OrientTop.z = up.z;
+        }
+
+        void XM_CALLCONV SetOrientationFromQuaternion(FXMVECTOR quat) noexcept
+        {
+            const XMVECTOR forward = XMVector3Rotate(g_XMIdentityR2, quat);
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientFront), forward);
+
+            const XMVECTOR up = XMVector3Rotate(g_XMIdentityR1, quat);
+            XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientTop), up);
+        }
+
+        // Updates velocity and orientation by tracking changes in position over time.
+        void XM_CALLCONV Update(FXMVECTOR newPos, XMVECTOR upDir, float dt) noexcept
+        {
+            if (dt > 0.f)
+            {
+                const XMVECTOR lastPos = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(&Position));
+
+                XMVECTOR vDelta = XMVectorSubtract(newPos, lastPos);
+                const XMVECTOR vt = XMVectorReplicate(dt);
+                XMVECTOR v = XMVectorDivide(vDelta, vt);
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Velocity), v);
+
+                vDelta = XMVector3Normalize(vDelta);
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientFront), vDelta);
+
+                v = XMVector3Cross(upDir, vDelta);
+                v = XMVector3Normalize(v);
+
+                v = XMVector3Cross(vDelta, v);
+                v = XMVector3Normalize(v);
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&OrientTop), v);
+
+                XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(&Position), newPos);
+            }
+        }
+
+        void __cdecl SetOmnidirectional() noexcept
+        {
+            pCone = nullptr;
+        }
+
+        // Only used for single-channel emitters.
+        void __cdecl SetCone(const X3DAUDIO_CONE& emitterCone);
+
+        // Set multi-channel emitter azimuths based on speaker configuration geometry.
+        void __cdecl EnableDefaultMultiChannel(unsigned int channels, float radius = 1.f);
+
+        // Set default volume, LFE, LPF, and reverb curves.
+        void __cdecl EnableDefaultCurves() noexcept;
+        void __cdecl EnableLinearCurves() noexcept;
+
+        void __cdecl EnableInverseSquareCurves() noexcept
+        {
+            pVolumeCurve = nullptr;
+            pLFECurve = nullptr;
+            pLPFDirectCurve = nullptr;
+            pLPFReverbCurve = nullptr;
+            pReverbCurve = nullptr;
+        }
+
+        bool __cdecl IsValid() const;
+    };
+
+
+    //----------------------------------------------------------------------------------
+    class SoundEffectInstance
+    {
+    public:
+        SoundEffectInstance(SoundEffectInstance&&) noexcept;
+        SoundEffectInstance& operator= (SoundEffectInstance&&) noexcept;
+
+        SoundEffectInstance(SoundEffectInstance const&) = delete;
+        SoundEffectInstance& operator= (SoundEffectInstance const&) = delete;
+
+        virtual ~SoundEffectInstance();
+
+        void __cdecl Play(bool loop = false);
+        void __cdecl Stop(bool immediate = true) noexcept;
+        void __cdecl Pause() noexcept;
+        void __cdecl Resume();
+
+        void __cdecl SetVolume(float volume);
+        void __cdecl SetPitch(float pitch);
+        void __cdecl SetPan(float pan);
+
+        void __cdecl Apply3D(const X3DAUDIO_LISTENER& listener, const X3DAUDIO_EMITTER& emitter, bool rhcoords = true);
+
+        bool __cdecl IsLooped() const noexcept;
+
+        SoundState __cdecl GetState() noexcept;
+
+        unsigned int __cdecl GetChannelCount() const noexcept;
+
+        IVoiceNotify* __cdecl GetVoiceNotify() const noexcept;
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+
+        // Private constructors
+        SoundEffectInstance(_In_ AudioEngine* engine, _In_ SoundEffect* effect, SOUND_EFFECT_INSTANCE_FLAGS flags);
+        SoundEffectInstance(_In_ AudioEngine* engine, _In_ WaveBank* effect, unsigned int index, SOUND_EFFECT_INSTANCE_FLAGS flags);
+
+        friend std::unique_ptr<SoundEffectInstance> __cdecl SoundEffect::CreateInstance(SOUND_EFFECT_INSTANCE_FLAGS);
+        friend std::unique_ptr<SoundEffectInstance> __cdecl WaveBank::CreateInstance(unsigned int, SOUND_EFFECT_INSTANCE_FLAGS);
+    };
+
+
+    //----------------------------------------------------------------------------------
+    class SoundStreamInstance
+    {
+    public:
+        SoundStreamInstance(SoundStreamInstance&&) noexcept;
+        SoundStreamInstance& operator= (SoundStreamInstance&&) noexcept;
+
+        SoundStreamInstance(SoundStreamInstance const&) = delete;
+        SoundStreamInstance& operator= (SoundStreamInstance const&) = delete;
+
+        virtual ~SoundStreamInstance();
+
+        void __cdecl Play(bool loop = false);
+        void __cdecl Stop(bool immediate = true) noexcept;
+        void __cdecl Pause() noexcept;
+        void __cdecl Resume();
+
+        void __cdecl SetVolume(float volume);
+        void __cdecl SetPitch(float pitch);
+        void __cdecl SetPan(float pan);
+
+        void __cdecl Apply3D(const X3DAUDIO_LISTENER& listener, const X3DAUDIO_EMITTER& emitter, bool rhcoords = true);
+
+        bool __cdecl IsLooped() const noexcept;
+
+        SoundState __cdecl GetState() noexcept;
+
+        unsigned int __cdecl GetChannelCount() const noexcept;
+
+        IVoiceNotify* __cdecl GetVoiceNotify() const noexcept;
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+
+        // Private constructors
+        SoundStreamInstance(_In_ AudioEngine* engine, _In_ WaveBank* effect, unsigned int index, SOUND_EFFECT_INSTANCE_FLAGS flags);
+
+        friend std::unique_ptr<SoundStreamInstance> __cdecl WaveBank::CreateStreamInstance(unsigned int, SOUND_EFFECT_INSTANCE_FLAGS);
+    };
+
+
+    //----------------------------------------------------------------------------------
+    class DynamicSoundEffectInstance
+    {
+    public:
+        DynamicSoundEffectInstance(_In_ AudioEngine* engine,
+            _In_ std::function<void __cdecl(DynamicSoundEffectInstance*)> bufferNeeded,
+            int sampleRate, int channels, int sampleBits = 16,
+            SOUND_EFFECT_INSTANCE_FLAGS flags = SoundEffectInstance_Default);
+
+        DynamicSoundEffectInstance(DynamicSoundEffectInstance&&) noexcept;
+        DynamicSoundEffectInstance& operator= (DynamicSoundEffectInstance&&) noexcept;
+
+        DynamicSoundEffectInstance(DynamicSoundEffectInstance const&) = delete;
+        DynamicSoundEffectInstance& operator= (DynamicSoundEffectInstance const&) = delete;
+
+        virtual ~DynamicSoundEffectInstance();
+
+        void __cdecl Play();
+        void __cdecl Stop(bool immediate = true) noexcept;
+        void __cdecl Pause() noexcept;
+        void __cdecl Resume();
+
+        void __cdecl SetVolume(float volume);
+        void __cdecl SetPitch(float pitch);
+        void __cdecl SetPan(float pan);
+
+        void __cdecl Apply3D(const X3DAUDIO_LISTENER& listener, const X3DAUDIO_EMITTER& emitter, bool rhcoords = true);
+
+        void __cdecl SubmitBuffer(_In_reads_bytes_(audioBytes) const uint8_t* pAudioData, size_t audioBytes);
+        void __cdecl SubmitBuffer(_In_reads_bytes_(audioBytes) const uint8_t* pAudioData, uint32_t offset, size_t audioBytes);
+
+        SoundState __cdecl GetState() noexcept;
+
+        size_t __cdecl GetSampleDuration(size_t bytes) const noexcept;
+        // Returns duration in samples of a buffer of a given size
+
+        size_t __cdecl GetSampleDurationMS(size_t bytes) const noexcept;
+        // Returns duration in milliseconds of a buffer of a given size
+
+        size_t __cdecl GetSampleSizeInBytes(uint64_t duration) const noexcept;
+        // Returns size of a buffer for a duration given in milliseconds
+
+        int __cdecl GetPendingBufferCount() const noexcept;
+
+        const WAVEFORMATEX* __cdecl GetFormat() const noexcept;
+
+        unsigned int __cdecl GetChannelCount() const noexcept;
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+    };
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#endif
+
+    DEFINE_ENUM_FLAG_OPERATORS(AUDIO_ENGINE_FLAGS);
+    DEFINE_ENUM_FLAG_OPERATORS(SOUND_EFFECT_INSTANCE_FLAGS);
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}

enginecustom/include/Inc/BufferHelpers.h

@@ -0,0 +1,164 @@
+//--------------------------------------------------------------------------------------
+// File: BufferHelpers.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#include "GraphicsMemory.h"
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <wrl\client.h>
+
+
+namespace DirectX
+{
+    // Helpers for creating initialized Direct3D buffer resources.
+    HRESULT __cdecl CreateStaticBuffer(_In_ ID3D11Device* device,
+        _In_reads_bytes_(count* stride) const void* ptr,
+        size_t count,
+        size_t stride,
+        unsigned int bindFlags,
+        _COM_Outptr_ ID3D11Buffer** pBuffer) noexcept;
+
+    template<typename T>
+    HRESULT CreateStaticBuffer(_In_ ID3D11Device* device,
+        _In_reads_(count) T const* data,
+        size_t count,
+        unsigned int bindFlags,
+        _COM_Outptr_ ID3D11Buffer** pBuffer) noexcept
+    {
+        return CreateStaticBuffer(device, data, count, sizeof(T), bindFlags, pBuffer);
+    }
+
+    template<typename T>
+    HRESULT CreateStaticBuffer(_In_ ID3D11Device* device,
+        T const& data,
+        unsigned int bindFlags,
+        _COM_Outptr_ ID3D11Buffer** pBuffer) noexcept
+    {
+        return CreateStaticBuffer(device, data.data(), data.size(), sizeof(typename T::value_type), bindFlags, pBuffer);
+    }
+
+    // Helpers for creating texture from memory arrays.
+    HRESULT __cdecl CreateTextureFromMemory(_In_ ID3D11Device* device,
+        size_t width,
+        DXGI_FORMAT format,
+        const D3D11_SUBRESOURCE_DATA& initData,
+        _COM_Outptr_opt_ ID3D11Texture1D** texture,
+        _COM_Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        unsigned int bindFlags = D3D11_BIND_SHADER_RESOURCE) noexcept;
+
+    HRESULT __cdecl CreateTextureFromMemory(_In_ ID3D11Device* device,
+        size_t width, size_t height,
+        DXGI_FORMAT format,
+        const D3D11_SUBRESOURCE_DATA& initData,
+        _COM_Outptr_opt_ ID3D11Texture2D** texture,
+        _COM_Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        unsigned int bindFlags = D3D11_BIND_SHADER_RESOURCE) noexcept;
+
+    HRESULT __cdecl CreateTextureFromMemory(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDeviceX,
+        _In_ ID3D11DeviceContextX* d3dContextX,
+    #else
+        _In_ ID3D11Device* device,
+        _In_ ID3D11DeviceContext* d3dContext,
+    #endif
+        size_t width, size_t height,
+        DXGI_FORMAT format,
+        const D3D11_SUBRESOURCE_DATA& initData,
+        _COM_Outptr_opt_ ID3D11Texture2D** texture,
+        _COM_Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept;
+
+    HRESULT __cdecl CreateTextureFromMemory(_In_ ID3D11Device* device,
+        size_t width, size_t height, size_t depth,
+        DXGI_FORMAT format,
+        const D3D11_SUBRESOURCE_DATA& initData,
+        _COM_Outptr_opt_ ID3D11Texture3D** texture,
+        _COM_Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        unsigned int bindFlags = D3D11_BIND_SHADER_RESOURCE) noexcept;
+
+    // Strongly typed wrapper around a Direct3D constant buffer.
+    inline namespace DX11
+    {
+        namespace Private
+        {
+            // Base class, not to be used directly: clients should access this via the derived PrimitiveBatch<T>.
+            class ConstantBufferBase
+            {
+            protected:
+                void __cdecl CreateBuffer(_In_ ID3D11Device* device, size_t bytes, _Outptr_ ID3D11Buffer** pBuffer);
+            };
+        }
+    }
+
+    template<typename T>
+    class ConstantBuffer : public DX11::Private::ConstantBufferBase
+    {
+    public:
+        // Constructor.
+        ConstantBuffer() = default;
+        explicit ConstantBuffer(_In_ ID3D11Device* device) noexcept(false)
+        {
+            CreateBuffer(device, sizeof(T), mConstantBuffer.GetAddressOf());
+        }
+
+        ConstantBuffer(ConstantBuffer&&) = default;
+        ConstantBuffer& operator= (ConstantBuffer&&) = default;
+
+        ConstantBuffer(ConstantBuffer const&) = delete;
+        ConstantBuffer& operator= (ConstantBuffer const&) = delete;
+
+        void Create(_In_ ID3D11Device* device)
+        {
+            CreateBuffer(device, sizeof(T), mConstantBuffer.ReleaseAndGetAddressOf());
+        }
+
+        // Writes new data into the constant buffer.
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        void __cdecl SetData(_In_ ID3D11DeviceContext* deviceContext, T const& value, void** grfxMemory)
+        {
+            assert(grfxMemory != nullptr);
+
+            void* ptr = GraphicsMemory::Get().Allocate(deviceContext, sizeof(T), 64);
+            assert(ptr != nullptr);
+
+            *(T*)ptr = value;
+
+            *grfxMemory = ptr;
+        }
+    #else
+
+        void __cdecl SetData(_In_ ID3D11DeviceContext* deviceContext, T const& value) noexcept
+        {
+            assert(mConstantBuffer);
+
+            D3D11_MAPPED_SUBRESOURCE mappedResource;
+            if (SUCCEEDED(deviceContext->Map(mConstantBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource)))
+            {
+                *static_cast<T*>(mappedResource.pData) = value;
+
+                deviceContext->Unmap(mConstantBuffer.Get(), 0);
+            }
+        }
+    #endif // _XBOX_ONE && _TITLE
+
+        // Looks up the underlying D3D constant buffer.
+        ID3D11Buffer* GetBuffer() const noexcept { return mConstantBuffer.Get(); }
+
+    private:
+        Microsoft::WRL::ComPtr<ID3D11Buffer> mConstantBuffer;
+    };
+}

enginecustom/include/Inc/CommonStates.h

@@ -0,0 +1,72 @@
+//--------------------------------------------------------------------------------------
+// File: CommonStates.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <memory>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        class CommonStates
+        {
+        public:
+            explicit CommonStates(_In_ ID3D11Device* device);
+
+            CommonStates(CommonStates&&) noexcept;
+            CommonStates& operator= (CommonStates&&) noexcept;
+
+            CommonStates(CommonStates const&) = delete;
+            CommonStates& operator= (CommonStates const&) = delete;
+
+            virtual ~CommonStates();
+
+            // Blend states.
+            ID3D11BlendState* __cdecl Opaque() const;
+            ID3D11BlendState* __cdecl AlphaBlend() const;
+            ID3D11BlendState* __cdecl Additive() const;
+            ID3D11BlendState* __cdecl NonPremultiplied() const;
+
+            // Depth stencil states.
+            ID3D11DepthStencilState* __cdecl DepthNone() const;
+            ID3D11DepthStencilState* __cdecl DepthDefault() const;
+            ID3D11DepthStencilState* __cdecl DepthRead() const;
+            ID3D11DepthStencilState* __cdecl DepthReverseZ() const;
+            ID3D11DepthStencilState* __cdecl DepthReadReverseZ() const;
+
+            // Rasterizer states.
+            ID3D11RasterizerState* __cdecl CullNone() const;
+            ID3D11RasterizerState* __cdecl CullClockwise() const;
+            ID3D11RasterizerState* __cdecl CullCounterClockwise() const;
+            ID3D11RasterizerState* __cdecl Wireframe() const;
+
+            // Sampler states.
+            ID3D11SamplerState* __cdecl PointWrap() const;
+            ID3D11SamplerState* __cdecl PointClamp() const;
+            ID3D11SamplerState* __cdecl LinearWrap() const;
+            ID3D11SamplerState* __cdecl LinearClamp() const;
+            ID3D11SamplerState* __cdecl AnisotropicWrap() const;
+            ID3D11SamplerState* __cdecl AnisotropicClamp() const;
+
+        private:
+            // Private implementation.
+            class Impl;
+
+            std::shared_ptr<Impl> pImpl;
+        };
+    }
+}

enginecustom/include/Inc/DDSTextureLoader.h

@@ -0,0 +1,182 @@
+//--------------------------------------------------------------------------------------
+// File: DDSTextureLoader.h
+//
+// Functions for loading a DDS texture and creating a Direct3D runtime resource for it
+//
+// Note these functions are useful as a light-weight runtime loader for DDS files. For
+// a full-featured DDS file reader, writer, and texture processing pipeline see
+// the 'Texconv' sample and the 'DirectXTex' library.
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248926
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <cstddef>
+#include <cstdint>
+
+
+namespace DirectX
+{
+#ifndef DDS_ALPHA_MODE_DEFINED
+#define DDS_ALPHA_MODE_DEFINED
+    enum DDS_ALPHA_MODE : uint32_t
+    {
+        DDS_ALPHA_MODE_UNKNOWN = 0,
+        DDS_ALPHA_MODE_STRAIGHT = 1,
+        DDS_ALPHA_MODE_PREMULTIPLIED = 2,
+        DDS_ALPHA_MODE_OPAQUE = 3,
+        DDS_ALPHA_MODE_CUSTOM = 4,
+    };
+#endif
+
+    inline namespace DX11
+    {
+        enum DDS_LOADER_FLAGS : uint32_t
+        {
+            DDS_LOADER_DEFAULT = 0,
+            DDS_LOADER_FORCE_SRGB = 0x1,
+            DDS_LOADER_IGNORE_SRGB = 0x2,
+        };
+    }
+
+    // Standard version
+    HRESULT __cdecl CreateDDSTextureFromMemory(
+        _In_ ID3D11Device* d3dDevice,
+        _In_reads_bytes_(ddsDataSize) const uint8_t* ddsData,
+        _In_ size_t ddsDataSize,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+    HRESULT __cdecl CreateDDSTextureFromFile(
+        _In_ ID3D11Device* d3dDevice,
+        _In_z_ const wchar_t* szFileName,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+    // Standard version with optional auto-gen mipmap support
+    HRESULT __cdecl CreateDDSTextureFromMemory(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_reads_bytes_(ddsDataSize) const uint8_t* ddsData,
+        _In_ size_t ddsDataSize,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+    HRESULT __cdecl CreateDDSTextureFromFile(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_z_ const wchar_t* szFileName,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+    // Extended version
+    HRESULT __cdecl CreateDDSTextureFromMemoryEx(
+        _In_ ID3D11Device* d3dDevice,
+        _In_reads_bytes_(ddsDataSize) const uint8_t* ddsData,
+        _In_ size_t ddsDataSize,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ DDS_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+    HRESULT __cdecl CreateDDSTextureFromFileEx(
+        _In_ ID3D11Device* d3dDevice,
+        _In_z_ const wchar_t* szFileName,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ DDS_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+    // Extended version with optional auto-gen mipmap support
+    HRESULT __cdecl CreateDDSTextureFromMemoryEx(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_reads_bytes_(ddsDataSize) const uint8_t* ddsData,
+        _In_ size_t ddsDataSize,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ DDS_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+    HRESULT __cdecl CreateDDSTextureFromFileEx(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_z_ const wchar_t* szFileName,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ DDS_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr) noexcept;
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#endif
+
+    inline namespace DX11
+    {
+        DEFINE_ENUM_FLAG_OPERATORS(DDS_LOADER_FLAGS);
+    }
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}

enginecustom/include/Inc/DirectXHelpers.h

@@ -0,0 +1,232 @@
+//--------------------------------------------------------------------------------------
+// File: DirectXHelpers.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#ifdef _MSC_VER
+#if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
+#if !defined(_XBOX_ONE) || !defined(_TITLE)
+#pragma comment(lib,"dxguid.lib")
+#endif
+#endif
+#endif
+
+#ifndef IID_GRAPHICS_PPV_ARGS
+#define IID_GRAPHICS_PPV_ARGS(x) IID_PPV_ARGS(x)
+#endif
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <exception>
+
+//
+// The core Direct3D headers provide the following helper C++ classes
+//  CD3D11_RECT
+//  CD3D11_BOX
+//  CD3D11_DEPTH_STENCIL_DESC
+//  CD3D11_BLEND_DESC, CD3D11_BLEND_DESC1
+//  CD3D11_RASTERIZER_DESC, CD3D11_RASTERIZER_DESC1
+//  CD3D11_BUFFER_DESC
+//  CD3D11_TEXTURE1D_DESC
+//  CD3D11_TEXTURE2D_DESC
+//  CD3D11_TEXTURE3D_DESC
+//  CD3D11_SHADER_RESOURCE_VIEW_DESC
+//  CD3D11_RENDER_TARGET_VIEW_DESC
+//  CD3D11_VIEWPORT
+//  CD3D11_DEPTH_STENCIL_VIEW_DESC
+//  CD3D11_UNORDERED_ACCESS_VIEW_DESC
+//  CD3D11_SAMPLER_DESC
+//  CD3D11_QUERY_DESC
+//  CD3D11_COUNTER_DESC
+//
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        class IEffect;
+    }
+
+    // simliar to std::lock_guard for exception-safe Direct3D resource locking
+    class MapGuard : public D3D11_MAPPED_SUBRESOURCE
+    {
+    public:
+        MapGuard(_In_ ID3D11DeviceContext* context,
+            _In_ ID3D11Resource *resource,
+            _In_ unsigned int subresource,
+            _In_ D3D11_MAP mapType,
+            _In_ unsigned int mapFlags) noexcept(false)
+            : mContext(context), mResource(resource), mSubresource(subresource)
+        {
+            HRESULT hr = mContext->Map(resource, subresource, mapType, mapFlags, this);
+            if (FAILED(hr))
+            {
+                throw std::exception();
+            }
+        }
+
+        MapGuard(MapGuard&&) = delete;
+        MapGuard& operator= (MapGuard&&) = delete;
+
+        MapGuard(MapGuard const&) = delete;
+        MapGuard& operator= (MapGuard const&) = delete;
+
+        ~MapGuard()
+        {
+            mContext->Unmap(mResource, mSubresource);
+        }
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
+#endif
+
+        uint8_t* get() const noexcept
+        {
+            return static_cast<uint8_t*>(pData);
+        }
+        uint8_t* get(size_t slice) const noexcept
+        {
+            return static_cast<uint8_t*>(pData) + (slice * DepthPitch);
+        }
+
+        uint8_t* scanline(size_t row) const noexcept
+        {
+            return static_cast<uint8_t*>(pData) + (row * RowPitch);
+        }
+        uint8_t* scanline(size_t slice, size_t row) const noexcept
+        {
+            return static_cast<uint8_t*>(pData) + (slice * DepthPitch) + (row * RowPitch);
+        }
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+        template<typename T>
+        void copy(_In_reads_(count) T const* data, size_t count) noexcept
+        {
+            memcpy(pData, data, count * sizeof(T));
+        }
+
+        template<typename T>
+        void copy(T const& data) noexcept
+        {
+            memcpy(pData, data.data(), data.size() * sizeof(typename T::value_type));
+        }
+
+    private:
+        ID3D11DeviceContext*    mContext;
+        ID3D11Resource*         mResource;
+        unsigned int            mSubresource;
+    };
+
+
+    // Helper sets a D3D resource name string (used by PIX and debug layer leak reporting).
+    #if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
+    template<UINT TNameLength>
+    inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_z_ const char(&name)[TNameLength]) noexcept
+    {
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        wchar_t wname[MAX_PATH];
+        int result = MultiByteToWideChar(CP_UTF8, 0, name, TNameLength, wname, MAX_PATH);
+        if (result > 0)
+        {
+            resource->SetName(wname);
+        }
+    #else
+        resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, name);
+    #endif
+    }
+    #else
+    template<UINT TNameLength>
+    inline void SetDebugObjectName(_In_ ID3D11DeviceChild*, _In_z_ const char(&)[TNameLength]) noexcept
+    {
+    }
+    #endif
+
+#if !defined(NO_D3D11_DEBUG_NAME) && ( defined(_DEBUG) || defined(PROFILE) )
+    template<UINT TNameLength>
+    inline void SetDebugObjectName(_In_ ID3D11DeviceChild* resource, _In_z_ const wchar_t(&name)[TNameLength])
+    {
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        resource->SetName(name);
+    #else
+        char aname[MAX_PATH];
+        int result = WideCharToMultiByte(CP_UTF8, 0, name, TNameLength, aname, MAX_PATH, nullptr, nullptr);
+        if (result > 0)
+        {
+            resource->SetPrivateData(WKPDID_D3DDebugObjectName, TNameLength - 1, aname);
+        }
+    #endif
+    }
+#else
+    template<UINT TNameLength>
+    inline void SetDebugObjectName(_In_ ID3D11DeviceChild*, _In_z_ const wchar_t(&)[TNameLength])
+    {
+    }
+#endif
+
+    inline namespace DX11
+    {
+        // Helper to check for power-of-2
+        template<typename T>
+        constexpr bool IsPowerOf2(T x) noexcept { return ((x != 0) && !(x & (x - 1))); }
+
+        // Helpers for aligning values by a power of 2
+        template<typename T>
+        inline T AlignDown(T size, size_t alignment) noexcept
+        {
+            if (alignment > 0)
+            {
+                assert(((alignment - 1) & alignment) == 0);
+                auto mask = static_cast<T>(alignment - 1);
+                return size & ~mask;
+            }
+            return size;
+        }
+
+        template<typename T>
+        inline T AlignUp(T size, size_t alignment) noexcept
+        {
+            if (alignment > 0)
+            {
+                assert(((alignment - 1) & alignment) == 0);
+                auto mask = static_cast<T>(alignment - 1);
+                return (size + mask) & ~mask;
+            }
+            return size;
+        }
+    }
+
+    // Helper for creating a Direct3D input layout to match a shader from an IEffect
+    HRESULT __cdecl CreateInputLayoutFromEffect(_In_ ID3D11Device* device,
+        _In_ IEffect* effect,
+        _In_reads_(count) const D3D11_INPUT_ELEMENT_DESC* desc,
+        size_t count,
+        _COM_Outptr_ ID3D11InputLayout** pInputLayout) noexcept;
+
+    template<typename T>
+    HRESULT CreateInputLayoutFromEffect(_In_ ID3D11Device* device,
+        _In_ IEffect* effect,
+        _COM_Outptr_ ID3D11InputLayout** pInputLayout) noexcept
+    {
+        return CreateInputLayoutFromEffect(device, effect, T::InputElements, T::InputElementCount, pInputLayout);
+    }
+}

enginecustom/include/Inc/GamePad.h

@@ -0,0 +1,329 @@
+//--------------------------------------------------------------------------------------
+// File: GamePad.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if !defined(USING_XINPUT) && !defined(USING_GAMEINPUT) && !defined(USING_WINDOWS_GAMING_INPUT)
+
+#ifdef _GAMING_DESKTOP
+#include <grdk.h>
+#endif
+
+#if (defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_GAMES)) || (defined(_GAMING_DESKTOP) && (_GRDK_EDITION >= 220600))
+#define USING_GAMEINPUT
+#elif (_WIN32_WINNT >= 0x0A00 /*_WIN32_WINNT_WIN10*/) && !defined(_GAMING_DESKTOP) && !defined(__MINGW32__)
+#define USING_WINDOWS_GAMING_INPUT
+#elif !defined(_XBOX_ONE)
+#define USING_XINPUT
+#endif
+
+#endif // !USING_XINPUT && !USING_GAMEINPUT && !USING_WINDOWS_GAMING_INPUT
+
+#ifdef USING_GAMEINPUT
+#include <GameInput.h>
+#if !defined(_GAMING_XBOX) && defined(_MSC_VER)
+#pragma comment(lib,"gameinput.lib")
+#endif
+
+#elif defined(USING_WINDOWS_GAMING_INPUT)
+#ifdef _MSC_VER
+#pragma comment(lib,"runtimeobject.lib")
+#endif
+#include <string>
+
+#elif defined(_XBOX_ONE)
+// Legacy Xbox One XDK uses Windows::Xbox::Input
+
+#elif defined(USING_XINPUT)
+#ifdef _MSC_VER
+#if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/ )
+#pragma comment(lib,"xinput.lib")
+#else
+#pragma comment(lib,"xinput9_1_0.lib")
+#endif
+#endif
+#endif
+
+#include <cstdint>
+#include <memory>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#endif
+
+
+namespace DirectX
+{
+    class GamePad
+    {
+    public:
+        GamePad() noexcept(false);
+
+        GamePad(GamePad&&) noexcept;
+        GamePad& operator= (GamePad&&) noexcept;
+
+        GamePad(GamePad const&) = delete;
+        GamePad& operator=(GamePad const&) = delete;
+
+        virtual ~GamePad();
+
+    #if defined(USING_GAMEINPUT) || defined(USING_WINDOWS_GAMING_INPUT) || defined(_XBOX_ONE)
+        static constexpr int MAX_PLAYER_COUNT = 8;
+    #else
+        static constexpr int MAX_PLAYER_COUNT = 4;
+    #endif
+
+        static constexpr int c_MostRecent = -1;
+
+    #ifdef USING_GAMEINPUT
+        static constexpr int c_MergedInput = -2;
+    #endif
+
+        enum DeadZone
+        {
+            DEAD_ZONE_INDEPENDENT_AXES = 0,
+            DEAD_ZONE_CIRCULAR,
+            DEAD_ZONE_NONE,
+        };
+
+        struct Buttons
+        {
+            bool a;
+            bool b;
+            bool x;
+            bool y;
+            bool leftStick;
+            bool rightStick;
+            bool leftShoulder;
+            bool rightShoulder;
+            union
+            {
+                bool back;
+                bool view;
+            };
+            union
+            {
+                bool start;
+                bool menu;
+            };
+        };
+
+        struct DPad
+        {
+            bool up;
+            bool down;
+            bool right;
+            bool left;
+        };
+
+        struct ThumbSticks
+        {
+            float leftX;
+            float leftY;
+            float rightX;
+            float rightY;
+        };
+
+        struct Triggers
+        {
+            float left;
+            float right;
+        };
+
+        struct State
+        {
+            bool        connected;
+            uint64_t    packet;
+            Buttons     buttons;
+            DPad        dpad;
+            ThumbSticks thumbSticks;
+            Triggers    triggers;
+
+            bool __cdecl IsConnected() const noexcept { return connected; }
+
+            // Is the button pressed currently?
+            bool __cdecl IsAPressed() const noexcept { return buttons.a; }
+            bool __cdecl IsBPressed() const noexcept { return buttons.b; }
+            bool __cdecl IsXPressed() const noexcept { return buttons.x; }
+            bool __cdecl IsYPressed() const noexcept { return buttons.y; }
+
+            bool __cdecl IsLeftStickPressed() const noexcept { return buttons.leftStick; }
+            bool __cdecl IsRightStickPressed() const noexcept { return buttons.rightStick; }
+
+            bool __cdecl IsLeftShoulderPressed() const noexcept { return buttons.leftShoulder; }
+            bool __cdecl IsRightShoulderPressed() const noexcept { return buttons.rightShoulder; }
+
+            bool __cdecl IsBackPressed() const noexcept { return buttons.back; }
+            bool __cdecl IsViewPressed() const noexcept { return buttons.view; }
+            bool __cdecl IsStartPressed() const noexcept { return buttons.start; }
+            bool __cdecl IsMenuPressed() const noexcept { return buttons.menu; }
+
+            bool __cdecl IsDPadDownPressed() const noexcept { return dpad.down; }
+            bool __cdecl IsDPadUpPressed() const noexcept { return dpad.up; }
+            bool __cdecl IsDPadLeftPressed() const noexcept { return dpad.left; }
+            bool __cdecl IsDPadRightPressed() const noexcept { return dpad.right; }
+
+            bool __cdecl IsLeftThumbStickUp() const noexcept { return (thumbSticks.leftY > 0.5f) != 0; }
+            bool __cdecl IsLeftThumbStickDown() const noexcept { return (thumbSticks.leftY < -0.5f) != 0; }
+            bool __cdecl IsLeftThumbStickLeft() const noexcept { return (thumbSticks.leftX < -0.5f) != 0; }
+            bool __cdecl IsLeftThumbStickRight() const noexcept { return (thumbSticks.leftX > 0.5f) != 0; }
+
+            bool __cdecl IsRightThumbStickUp() const noexcept { return (thumbSticks.rightY > 0.5f) != 0; }
+            bool __cdecl IsRightThumbStickDown() const noexcept { return (thumbSticks.rightY < -0.5f) != 0; }
+            bool __cdecl IsRightThumbStickLeft() const noexcept { return (thumbSticks.rightX < -0.5f) != 0; }
+            bool __cdecl IsRightThumbStickRight() const noexcept { return (thumbSticks.rightX > 0.5f) != 0; }
+
+            bool __cdecl IsLeftTriggerPressed() const noexcept { return (triggers.left > 0.5f) != 0; }
+            bool __cdecl IsRightTriggerPressed() const noexcept { return (triggers.right > 0.5f) != 0; }
+        };
+
+        struct Capabilities
+        {
+            enum Type
+            {
+                UNKNOWN = 0,
+                GAMEPAD,
+                WHEEL,
+                ARCADE_STICK,
+                FLIGHT_STICK,
+                DANCE_PAD,
+                GUITAR,
+                GUITAR_ALTERNATE,
+                DRUM_KIT,
+                GUITAR_BASS = 11,
+                ARCADE_PAD = 19,
+            };
+
+            bool                connected;
+            Type                gamepadType;
+        #ifdef USING_GAMEINPUT
+            APP_LOCAL_DEVICE_ID id;
+        #elif defined(USING_WINDOWS_GAMING_INPUT)
+            std::wstring        id;
+        #else
+            uint64_t            id;
+        #endif
+            uint16_t            vid;
+            uint16_t            pid;
+
+            Capabilities() noexcept : connected(false), gamepadType(UNKNOWN), id{}, vid(0), pid(0) {}
+
+            bool __cdecl IsConnected() const noexcept { return connected; }
+        };
+
+        class ButtonStateTracker
+        {
+        public:
+            enum ButtonState
+            {
+                UP = 0,         // Button is up
+                HELD = 1,       // Button is held down
+                RELEASED = 2,   // Button was just released
+                PRESSED = 3,    // Buton was just pressed
+            };
+
+            ButtonState a;
+            ButtonState b;
+            ButtonState x;
+            ButtonState y;
+
+            ButtonState leftStick;
+            ButtonState rightStick;
+
+            ButtonState leftShoulder;
+            ButtonState rightShoulder;
+
+            union
+            {
+                ButtonState back;
+                ButtonState view;
+            };
+
+            union
+            {
+                ButtonState start;
+                ButtonState menu;
+            };
+
+            ButtonState dpadUp;
+            ButtonState dpadDown;
+            ButtonState dpadLeft;
+            ButtonState dpadRight;
+
+            ButtonState leftStickUp;
+            ButtonState leftStickDown;
+            ButtonState leftStickLeft;
+            ButtonState leftStickRight;
+
+            ButtonState rightStickUp;
+            ButtonState rightStickDown;
+            ButtonState rightStickLeft;
+            ButtonState rightStickRight;
+
+            ButtonState leftTrigger;
+            ButtonState rightTrigger;
+
+        #ifdef _PREFAST_
+        #pragma prefast(push)
+        #pragma prefast(disable : 26495, "Reset() performs the initialization")
+        #endif
+            ButtonStateTracker() noexcept { Reset(); }
+        #ifdef _PREFAST_
+        #pragma prefast(pop)
+        #endif
+
+            void __cdecl Update(const State& state) noexcept;
+
+            void __cdecl Reset() noexcept;
+
+            State __cdecl GetLastState() const noexcept { return lastState; }
+
+        private:
+            State lastState;
+        };
+
+        // Retrieve the current state of the gamepad of the associated player index
+        State __cdecl GetState(int player, DeadZone deadZoneMode = DEAD_ZONE_INDEPENDENT_AXES);
+
+        // Retrieve the current capabilities of the gamepad of the associated player index
+        Capabilities __cdecl GetCapabilities(int player);
+
+        // Set the vibration motor speeds of the gamepad
+        bool __cdecl SetVibration(int player, float leftMotor, float rightMotor, float leftTrigger = 0.f, float rightTrigger = 0.f) noexcept;
+
+        // Handle suspending/resuming
+        void __cdecl Suspend() noexcept;
+        void __cdecl Resume() noexcept;
+
+    #ifdef USING_GAMEINPUT
+        void __cdecl RegisterEvents(void* ctrlChanged) noexcept;
+
+        // Underlying device access
+        _Success_(return)
+            bool __cdecl GetDevice(int player, _Outptr_ IGameInputDevice * *device) noexcept;
+    #elif defined(USING_WINDOWS_GAMING_INPUT) || defined(_XBOX_ONE)
+        void __cdecl RegisterEvents(void* ctrlChanged, void* userChanged) noexcept;
+    #endif
+
+        // Singleton
+        static GamePad& __cdecl Get();
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

enginecustom/include/Inc/GeometricPrimitive.h

@@ -0,0 +1,111 @@
+//--------------------------------------------------------------------------------------
+// File: GeometricPrimitive.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "VertexTypes.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include <DirectXColors.h>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        class IEffect;
+
+        class GeometricPrimitive
+        {
+        public:
+            GeometricPrimitive(GeometricPrimitive&&) = default;
+            GeometricPrimitive& operator= (GeometricPrimitive&&) = default;
+
+            GeometricPrimitive(GeometricPrimitive const&) = delete;
+            GeometricPrimitive& operator= (GeometricPrimitive const&) = delete;
+
+            using VertexType = VertexPositionNormalTexture;
+            using VertexCollection = std::vector<VertexType>;
+            using IndexCollection = std::vector<uint16_t>;
+
+            virtual ~GeometricPrimitive();
+
+            // Factory methods.
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateCube(_In_ ID3D11DeviceContext* deviceContext, float size = 1, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateBox(_In_ ID3D11DeviceContext* deviceContext, const XMFLOAT3& size, bool rhcoords = true, bool invertn = false);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateSphere(_In_ ID3D11DeviceContext* deviceContext, float diameter = 1, size_t tessellation = 16, bool rhcoords = true, bool invertn = false);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateGeoSphere(_In_ ID3D11DeviceContext* deviceContext, float diameter = 1, size_t tessellation = 3, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateCylinder(_In_ ID3D11DeviceContext* deviceContext, float height = 1, float diameter = 1, size_t tessellation = 32, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateCone(_In_ ID3D11DeviceContext* deviceContext, float diameter = 1, float height = 1, size_t tessellation = 32, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateTorus(_In_ ID3D11DeviceContext* deviceContext, float diameter = 1, float thickness = 0.333f, size_t tessellation = 32, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateTetrahedron(_In_ ID3D11DeviceContext* deviceContext, float size = 1, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateOctahedron(_In_ ID3D11DeviceContext* deviceContext, float size = 1, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateDodecahedron(_In_ ID3D11DeviceContext* deviceContext, float size = 1, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateIcosahedron(_In_ ID3D11DeviceContext* deviceContext, float size = 1, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateTeapot(_In_ ID3D11DeviceContext* deviceContext, float size = 1, size_t tessellation = 8, bool rhcoords = true);
+            static std::unique_ptr<GeometricPrimitive> __cdecl CreateCustom(_In_ ID3D11DeviceContext* deviceContext, const VertexCollection& vertices, const IndexCollection& indices);
+
+            static void __cdecl CreateCube(VertexCollection& vertices, IndexCollection& indices, float size = 1, bool rhcoords = true);
+            static void __cdecl CreateBox(VertexCollection& vertices, IndexCollection& indices, const XMFLOAT3& size, bool rhcoords = true, bool invertn = false);
+            static void __cdecl CreateSphere(VertexCollection& vertices, IndexCollection& indices, float diameter = 1, size_t tessellation = 16, bool rhcoords = true, bool invertn = false);
+            static void __cdecl CreateGeoSphere(VertexCollection& vertices, IndexCollection& indices, float diameter = 1, size_t tessellation = 3, bool rhcoords = true);
+            static void __cdecl CreateCylinder(VertexCollection& vertices, IndexCollection& indices, float height = 1, float diameter = 1, size_t tessellation = 32, bool rhcoords = true);
+            static void __cdecl CreateCone(VertexCollection& vertices, IndexCollection& indices, float diameter = 1, float height = 1, size_t tessellation = 32, bool rhcoords = true);
+            static void __cdecl CreateTorus(VertexCollection& vertices, IndexCollection& indices, float diameter = 1, float thickness = 0.333f, size_t tessellation = 32, bool rhcoords = true);
+            static void __cdecl CreateTetrahedron(VertexCollection& vertices, IndexCollection& indices, float size = 1, bool rhcoords = true);
+            static void __cdecl CreateOctahedron(VertexCollection& vertices, IndexCollection& indices, float size = 1, bool rhcoords = true);
+            static void __cdecl CreateDodecahedron(VertexCollection& vertices, IndexCollection& indices, float size = 1, bool rhcoords = true);
+            static void __cdecl CreateIcosahedron(VertexCollection& vertices, IndexCollection& indices, float size = 1, bool rhcoords = true);
+            static void __cdecl CreateTeapot(VertexCollection& vertices, IndexCollection& indices, float size = 1, size_t tessellation = 8, bool rhcoords = true);
+
+            // Draw the primitive.
+            void XM_CALLCONV Draw(FXMMATRIX world, CXMMATRIX view, CXMMATRIX projection,
+                FXMVECTOR color = Colors::White,
+                _In_opt_ ID3D11ShaderResourceView* texture = nullptr,
+                bool wireframe = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            // Draw the primitive using a custom effect.
+            void __cdecl Draw(_In_ IEffect* effect,
+                _In_ ID3D11InputLayout* inputLayout,
+                bool alpha = false, bool wireframe = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            void __cdecl DrawInstanced(_In_ IEffect* effect,
+                _In_ ID3D11InputLayout* inputLayout,
+                uint32_t instanceCount,
+                bool alpha = false, bool wireframe = false,
+                uint32_t startInstanceLocation = 0,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+           // Create input layout for drawing with a custom effect.
+            void __cdecl CreateInputLayout(_In_ IEffect* effect, _Outptr_ ID3D11InputLayout** inputLayout) const;
+
+            static void SetDepthBufferMode(bool reverseZ)
+            {
+                s_reversez = reverseZ;
+            }
+
+        private:
+            static bool s_reversez;
+
+            GeometricPrimitive() noexcept(false);
+
+            // Private implementation.
+            class Impl;
+
+            std::unique_ptr<Impl> pImpl;
+        };
+    }
+}

enginecustom/include/Inc/GraphicsMemory.h

@@ -0,0 +1,57 @@
+//--------------------------------------------------------------------------------------
+// File: GraphicsMemory.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <cstddef>
+#include <memory>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        class GraphicsMemory
+        {
+        public:
+        #if defined(_XBOX_ONE) && defined(_TITLE)
+            GraphicsMemory(_In_ ID3D11DeviceX* device, unsigned int backBufferCount = 2);
+        #else
+            GraphicsMemory(_In_ ID3D11Device* device, unsigned int backBufferCount = 2);
+        #endif
+
+            GraphicsMemory(GraphicsMemory&&) noexcept;
+            GraphicsMemory& operator= (GraphicsMemory&&) noexcept;
+
+            GraphicsMemory(GraphicsMemory const&) = delete;
+            GraphicsMemory& operator=(GraphicsMemory const&) = delete;
+
+            virtual ~GraphicsMemory();
+
+            void* __cdecl Allocate(_In_opt_ ID3D11DeviceContext* context, size_t size, int alignment);
+
+            void __cdecl Commit();
+
+            // Singleton
+            static GraphicsMemory& __cdecl Get();
+
+        private:
+            // Private implementation.
+            class Impl;
+
+            std::unique_ptr<Impl> pImpl;
+        };
+    }
+}

enginecustom/include/Inc/Keyboard.h

@@ -0,0 +1,532 @@
+//--------------------------------------------------------------------------------------
+// File: Keyboard.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if !defined(USING_XINPUT) && !defined(USING_GAMEINPUT) && !defined(USING_COREWINDOW)
+
+#ifdef _GAMING_DESKTOP
+#include <grdk.h>
+#endif
+
+#if (defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_GAMES)) || (defined(_GAMING_DESKTOP) && (_GRDK_EDITION >= 220600))
+#define USING_GAMEINPUT
+#elif (defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)) || (defined(_XBOX_ONE) && defined(_TITLE))
+#define USING_COREWINDOW
+#endif
+
+#endif // !USING_XINPUT && !USING_GAMEINPUT && !USING_WINDOWS_GAMING_INPUT
+
+#if defined(USING_GAMEINPUT) && !defined(_GAMING_XBOX) && defined(_MSC_VER)
+#pragma comment(lib,"gameinput.lib")
+#endif
+
+#include <cstdint>
+#include <memory>
+
+#ifdef USING_COREWINDOW
+namespace ABI { namespace Windows { namespace UI { namespace Core { struct ICoreWindow; } } } }
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#endif
+
+
+namespace DirectX
+{
+    class Keyboard
+    {
+    public:
+        Keyboard() noexcept(false);
+
+        Keyboard(Keyboard&&) noexcept;
+        Keyboard& operator= (Keyboard&&) noexcept;
+
+        Keyboard(Keyboard const&) = delete;
+        Keyboard& operator=(Keyboard const&) = delete;
+
+        virtual ~Keyboard();
+
+        enum Keys : unsigned char
+        {
+            None = 0,
+
+            Back = 0x8,
+            Tab = 0x9,
+
+            Enter = 0xd,
+
+            Pause = 0x13,
+            CapsLock = 0x14,
+            Kana = 0x15,
+            ImeOn = 0x16,
+
+            Kanji = 0x19,
+
+            ImeOff = 0x1a,
+            Escape = 0x1b,
+            ImeConvert = 0x1c,
+            ImeNoConvert = 0x1d,
+
+            Space = 0x20,
+            PageUp = 0x21,
+            PageDown = 0x22,
+            End = 0x23,
+            Home = 0x24,
+            Left = 0x25,
+            Up = 0x26,
+            Right = 0x27,
+            Down = 0x28,
+            Select = 0x29,
+            Print = 0x2a,
+            Execute = 0x2b,
+            PrintScreen = 0x2c,
+            Insert = 0x2d,
+            Delete = 0x2e,
+            Help = 0x2f,
+            D0 = 0x30,
+            D1 = 0x31,
+            D2 = 0x32,
+            D3 = 0x33,
+            D4 = 0x34,
+            D5 = 0x35,
+            D6 = 0x36,
+            D7 = 0x37,
+            D8 = 0x38,
+            D9 = 0x39,
+
+            A = 0x41,
+            B = 0x42,
+            C = 0x43,
+            D = 0x44,
+            E = 0x45,
+            F = 0x46,
+            G = 0x47,
+            H = 0x48,
+            I = 0x49,
+            J = 0x4a,
+            K = 0x4b,
+            L = 0x4c,
+            M = 0x4d,
+            N = 0x4e,
+            O = 0x4f,
+            P = 0x50,
+            Q = 0x51,
+            R = 0x52,
+            S = 0x53,
+            T = 0x54,
+            U = 0x55,
+            V = 0x56,
+            W = 0x57,
+            X = 0x58,
+            Y = 0x59,
+            Z = 0x5a,
+            LeftWindows = 0x5b,
+            RightWindows = 0x5c,
+            Apps = 0x5d,
+
+            Sleep = 0x5f,
+            NumPad0 = 0x60,
+            NumPad1 = 0x61,
+            NumPad2 = 0x62,
+            NumPad3 = 0x63,
+            NumPad4 = 0x64,
+            NumPad5 = 0x65,
+            NumPad6 = 0x66,
+            NumPad7 = 0x67,
+            NumPad8 = 0x68,
+            NumPad9 = 0x69,
+            Multiply = 0x6a,
+            Add = 0x6b,
+            Separator = 0x6c,
+            Subtract = 0x6d,
+
+            Decimal = 0x6e,
+            Divide = 0x6f,
+            F1 = 0x70,
+            F2 = 0x71,
+            F3 = 0x72,
+            F4 = 0x73,
+            F5 = 0x74,
+            F6 = 0x75,
+            F7 = 0x76,
+            F8 = 0x77,
+            F9 = 0x78,
+            F10 = 0x79,
+            F11 = 0x7a,
+            F12 = 0x7b,
+            F13 = 0x7c,
+            F14 = 0x7d,
+            F15 = 0x7e,
+            F16 = 0x7f,
+            F17 = 0x80,
+            F18 = 0x81,
+            F19 = 0x82,
+            F20 = 0x83,
+            F21 = 0x84,
+            F22 = 0x85,
+            F23 = 0x86,
+            F24 = 0x87,
+
+            NumLock = 0x90,
+            Scroll = 0x91,
+
+            LeftShift = 0xa0,
+            RightShift = 0xa1,
+            LeftControl = 0xa2,
+            RightControl = 0xa3,
+            LeftAlt = 0xa4,
+            RightAlt = 0xa5,
+            BrowserBack = 0xa6,
+            BrowserForward = 0xa7,
+            BrowserRefresh = 0xa8,
+            BrowserStop = 0xa9,
+            BrowserSearch = 0xaa,
+            BrowserFavorites = 0xab,
+            BrowserHome = 0xac,
+            VolumeMute = 0xad,
+            VolumeDown = 0xae,
+            VolumeUp = 0xaf,
+            MediaNextTrack = 0xb0,
+            MediaPreviousTrack = 0xb1,
+            MediaStop = 0xb2,
+            MediaPlayPause = 0xb3,
+            LaunchMail = 0xb4,
+            SelectMedia = 0xb5,
+            LaunchApplication1 = 0xb6,
+            LaunchApplication2 = 0xb7,
+
+            OemSemicolon = 0xba,
+            OemPlus = 0xbb,
+            OemComma = 0xbc,
+            OemMinus = 0xbd,
+            OemPeriod = 0xbe,
+            OemQuestion = 0xbf,
+            OemTilde = 0xc0,
+
+            OemOpenBrackets = 0xdb,
+            OemPipe = 0xdc,
+            OemCloseBrackets = 0xdd,
+            OemQuotes = 0xde,
+            Oem8 = 0xdf,
+
+            OemBackslash = 0xe2,
+
+            ProcessKey = 0xe5,
+
+            OemCopy = 0xf2,
+            OemAuto = 0xf3,
+            OemEnlW = 0xf4,
+
+            Attn = 0xf6,
+            Crsel = 0xf7,
+            Exsel = 0xf8,
+            EraseEof = 0xf9,
+            Play = 0xfa,
+            Zoom = 0xfb,
+
+            Pa1 = 0xfd,
+            OemClear = 0xfe,
+        };
+
+        struct State
+        {
+            bool Reserved0 : 8;
+            bool Back : 1;              // VK_BACK, 0x8
+            bool Tab : 1;               // VK_TAB, 0x9
+            bool Reserved1 : 3;
+            bool Enter : 1;             // VK_RETURN, 0xD
+            bool Reserved2 : 2;
+            bool Reserved3 : 3;
+            bool Pause : 1;             // VK_PAUSE, 0x13
+            bool CapsLock : 1;          // VK_CAPITAL, 0x14
+            bool Kana : 1;              // VK_KANA, 0x15
+            bool ImeOn : 1;             // VK_IME_ON, 0x16
+            bool Reserved4 : 1;
+            bool Reserved5 : 1;
+            bool Kanji : 1;             // VK_KANJI, 0x19
+            bool ImeOff : 1;            // VK_IME_OFF, 0X1A
+            bool Escape : 1;            // VK_ESCAPE, 0x1B
+            bool ImeConvert : 1;        // VK_CONVERT, 0x1C
+            bool ImeNoConvert : 1;      // VK_NONCONVERT, 0x1D
+            bool Reserved7 : 2;
+            bool Space : 1;             // VK_SPACE, 0x20
+            bool PageUp : 1;            // VK_PRIOR, 0x21
+            bool PageDown : 1;          // VK_NEXT, 0x22
+            bool End : 1;               // VK_END, 0x23
+            bool Home : 1;              // VK_HOME, 0x24
+            bool Left : 1;              // VK_LEFT, 0x25
+            bool Up : 1;                // VK_UP, 0x26
+            bool Right : 1;             // VK_RIGHT, 0x27
+            bool Down : 1;              // VK_DOWN, 0x28
+            bool Select : 1;            // VK_SELECT, 0x29
+            bool Print : 1;             // VK_PRINT, 0x2A
+            bool Execute : 1;           // VK_EXECUTE, 0x2B
+            bool PrintScreen : 1;       // VK_SNAPSHOT, 0x2C
+            bool Insert : 1;            // VK_INSERT, 0x2D
+            bool Delete : 1;            // VK_DELETE, 0x2E
+            bool Help : 1;              // VK_HELP, 0x2F
+            bool D0 : 1;                // 0x30
+            bool D1 : 1;                // 0x31
+            bool D2 : 1;                // 0x32
+            bool D3 : 1;                // 0x33
+            bool D4 : 1;                // 0x34
+            bool D5 : 1;                // 0x35
+            bool D6 : 1;                // 0x36
+            bool D7 : 1;                // 0x37
+            bool D8 : 1;                // 0x38
+            bool D9 : 1;                // 0x39
+            bool Reserved8 : 6;
+            bool Reserved9 : 1;
+            bool A : 1;                 // 0x41
+            bool B : 1;                 // 0x42
+            bool C : 1;                 // 0x43
+            bool D : 1;                 // 0x44
+            bool E : 1;                 // 0x45
+            bool F : 1;                 // 0x46
+            bool G : 1;                 // 0x47
+            bool H : 1;                 // 0x48
+            bool I : 1;                 // 0x49
+            bool J : 1;                 // 0x4A
+            bool K : 1;                 // 0x4B
+            bool L : 1;                 // 0x4C
+            bool M : 1;                 // 0x4D
+            bool N : 1;                 // 0x4E
+            bool O : 1;                 // 0x4F
+            bool P : 1;                 // 0x50
+            bool Q : 1;                 // 0x51
+            bool R : 1;                 // 0x52
+            bool S : 1;                 // 0x53
+            bool T : 1;                 // 0x54
+            bool U : 1;                 // 0x55
+            bool V : 1;                 // 0x56
+            bool W : 1;                 // 0x57
+            bool X : 1;                 // 0x58
+            bool Y : 1;                 // 0x59
+            bool Z : 1;                 // 0x5A
+            bool LeftWindows : 1;       // VK_LWIN, 0x5B
+            bool RightWindows : 1;      // VK_RWIN, 0x5C
+            bool Apps : 1;              // VK_APPS, 0x5D
+            bool Reserved10 : 1;
+            bool Sleep : 1;             // VK_SLEEP, 0x5F
+            bool NumPad0 : 1;           // VK_NUMPAD0, 0x60
+            bool NumPad1 : 1;           // VK_NUMPAD1, 0x61
+            bool NumPad2 : 1;           // VK_NUMPAD2, 0x62
+            bool NumPad3 : 1;           // VK_NUMPAD3, 0x63
+            bool NumPad4 : 1;           // VK_NUMPAD4, 0x64
+            bool NumPad5 : 1;           // VK_NUMPAD5, 0x65
+            bool NumPad6 : 1;           // VK_NUMPAD6, 0x66
+            bool NumPad7 : 1;           // VK_NUMPAD7, 0x67
+            bool NumPad8 : 1;           // VK_NUMPAD8, 0x68
+            bool NumPad9 : 1;           // VK_NUMPAD9, 0x69
+            bool Multiply : 1;          // VK_MULTIPLY, 0x6A
+            bool Add : 1;               // VK_ADD, 0x6B
+            bool Separator : 1;         // VK_SEPARATOR, 0x6C
+            bool Subtract : 1;          // VK_SUBTRACT, 0x6D
+            bool Decimal : 1;           // VK_DECIMANL, 0x6E
+            bool Divide : 1;            // VK_DIVIDE, 0x6F
+            bool F1 : 1;                // VK_F1, 0x70
+            bool F2 : 1;                // VK_F2, 0x71
+            bool F3 : 1;                // VK_F3, 0x72
+            bool F4 : 1;                // VK_F4, 0x73
+            bool F5 : 1;                // VK_F5, 0x74
+            bool F6 : 1;                // VK_F6, 0x75
+            bool F7 : 1;                // VK_F7, 0x76
+            bool F8 : 1;                // VK_F8, 0x77
+            bool F9 : 1;                // VK_F9, 0x78
+            bool F10 : 1;               // VK_F10, 0x79
+            bool F11 : 1;               // VK_F11, 0x7A
+            bool F12 : 1;               // VK_F12, 0x7B
+            bool F13 : 1;               // VK_F13, 0x7C
+            bool F14 : 1;               // VK_F14, 0x7D
+            bool F15 : 1;               // VK_F15, 0x7E
+            bool F16 : 1;               // VK_F16, 0x7F
+            bool F17 : 1;               // VK_F17, 0x80
+            bool F18 : 1;               // VK_F18, 0x81
+            bool F19 : 1;               // VK_F19, 0x82
+            bool F20 : 1;               // VK_F20, 0x83
+            bool F21 : 1;               // VK_F21, 0x84
+            bool F22 : 1;               // VK_F22, 0x85
+            bool F23 : 1;               // VK_F23, 0x86
+            bool F24 : 1;               // VK_F24, 0x87
+            bool Reserved11 : 8;
+            bool NumLock : 1;           // VK_NUMLOCK, 0x90
+            bool Scroll : 1;            // VK_SCROLL, 0x91
+            bool Reserved12 : 6;
+            bool Reserved13 : 8;
+            bool LeftShift : 1;         // VK_LSHIFT, 0xA0
+            bool RightShift : 1;        // VK_RSHIFT, 0xA1
+            bool LeftControl : 1;       // VK_LCONTROL, 0xA2
+            bool RightControl : 1;      // VK_RCONTROL, 0xA3
+            bool LeftAlt : 1;           // VK_LMENU, 0xA4
+            bool RightAlt : 1;          // VK_RMENU, 0xA5
+            bool BrowserBack : 1;       // VK_BROWSER_BACK, 0xA6
+            bool BrowserForward : 1;    // VK_BROWSER_FORWARD, 0xA7
+            bool BrowserRefresh : 1;    // VK_BROWSER_REFRESH, 0xA8
+            bool BrowserStop : 1;       // VK_BROWSER_STOP, 0xA9
+            bool BrowserSearch : 1;     // VK_BROWSER_SEARCH, 0xAA
+            bool BrowserFavorites : 1;  // VK_BROWSER_FAVORITES, 0xAB
+            bool BrowserHome : 1;       // VK_BROWSER_HOME, 0xAC
+            bool VolumeMute : 1;        // VK_VOLUME_MUTE, 0xAD
+            bool VolumeDown : 1;        // VK_VOLUME_DOWN, 0xAE
+            bool VolumeUp : 1;          // VK_VOLUME_UP, 0xAF
+            bool MediaNextTrack : 1;    // VK_MEDIA_NEXT_TRACK, 0xB0
+            bool MediaPreviousTrack : 1;// VK_MEDIA_PREV_TRACK, 0xB1
+            bool MediaStop : 1;         // VK_MEDIA_STOP, 0xB2
+            bool MediaPlayPause : 1;    // VK_MEDIA_PLAY_PAUSE, 0xB3
+            bool LaunchMail : 1;        // VK_LAUNCH_MAIL, 0xB4
+            bool SelectMedia : 1;       // VK_LAUNCH_MEDIA_SELECT, 0xB5
+            bool LaunchApplication1 : 1;// VK_LAUNCH_APP1, 0xB6
+            bool LaunchApplication2 : 1;// VK_LAUNCH_APP2, 0xB7
+            bool Reserved14 : 2;
+            bool OemSemicolon : 1;      // VK_OEM_1, 0xBA
+            bool OemPlus : 1;           // VK_OEM_PLUS, 0xBB
+            bool OemComma : 1;          // VK_OEM_COMMA, 0xBC
+            bool OemMinus : 1;          // VK_OEM_MINUS, 0xBD
+            bool OemPeriod : 1;         // VK_OEM_PERIOD, 0xBE
+            bool OemQuestion : 1;       // VK_OEM_2, 0xBF
+            bool OemTilde : 1;          // VK_OEM_3, 0xC0
+            bool Reserved15 : 7;
+            bool Reserved16 : 8;
+            bool Reserved17 : 8;
+            bool Reserved18 : 3;
+            bool OemOpenBrackets : 1;   // VK_OEM_4, 0xDB
+            bool OemPipe : 1;           // VK_OEM_5, 0xDC
+            bool OemCloseBrackets : 1;  // VK_OEM_6, 0xDD
+            bool OemQuotes : 1;         // VK_OEM_7, 0xDE
+            bool Oem8 : 1;              // VK_OEM_8, 0xDF
+            bool Reserved19 : 2;
+            bool OemBackslash : 1;      // VK_OEM_102, 0xE2
+            bool Reserved20 : 2;
+            bool ProcessKey : 1;        // VK_PROCESSKEY, 0xE5
+            bool Reserved21 : 2;
+            bool Reserved22 : 8;
+            bool Reserved23 : 2;
+            bool OemCopy : 1;           // 0XF2
+            bool OemAuto : 1;           // 0xF3
+            bool OemEnlW : 1;           // 0xF4
+            bool Reserved24 : 1;
+            bool Attn : 1;              // VK_ATTN, 0xF6
+            bool Crsel : 1;             // VK_CRSEL, 0xF7
+            bool Exsel : 1;             // VK_EXSEL, 0xF8
+            bool EraseEof : 1;          // VK_EREOF, 0xF9
+            bool Play : 1;              // VK_PLAY, 0xFA
+            bool Zoom : 1;              // VK_ZOOM, 0xFB
+            bool Reserved25 : 1;
+            bool Pa1 : 1;               // VK_PA1, 0xFD
+            bool OemClear : 1;          // VK_OEM_CLEAR, 0xFE
+            bool Reserved26 : 1;
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
+#endif
+
+            bool __cdecl IsKeyDown(Keys key) const noexcept
+            {
+                if (key <= 0xfe)
+                {
+                    auto ptr = reinterpret_cast<const uint32_t*>(this);
+                    const unsigned int bf = 1u << (key & 0x1f);
+                    return (ptr[(key >> 5)] & bf) != 0;
+                }
+                return false;
+            }
+
+            bool __cdecl IsKeyUp(Keys key) const noexcept
+            {
+                if (key <= 0xfe)
+                {
+                    auto ptr = reinterpret_cast<const uint32_t*>(this);
+                    const unsigned int bf = 1u << (key & 0x1f);
+                    return (ptr[(key >> 5)] & bf) == 0;
+                }
+                return false;
+            }
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+        };
+
+        class KeyboardStateTracker
+        {
+        public:
+            State released;
+            State pressed;
+
+        #ifdef _PREFAST_
+        #pragma prefast(push)
+        #pragma prefast(disable : 26495, "Reset() performs the initialization")
+        #endif
+            KeyboardStateTracker() noexcept { Reset(); }
+        #ifdef _PREFAST_
+        #pragma prefast(pop)
+        #endif
+
+            void __cdecl Update(const State& state) noexcept;
+
+            void __cdecl Reset() noexcept;
+
+            bool __cdecl IsKeyPressed(Keys key) const noexcept { return pressed.IsKeyDown(key); }
+            bool __cdecl IsKeyReleased(Keys key) const noexcept { return released.IsKeyDown(key); }
+
+            State __cdecl GetLastState() const noexcept { return lastState; }
+
+        public:
+            State lastState;
+        };
+
+        // Retrieve the current state of the keyboard
+        State __cdecl GetState() const;
+
+        // Reset the keyboard state
+        void __cdecl Reset() noexcept;
+
+        // Feature detection
+        bool __cdecl IsConnected() const;
+
+    #ifdef USING_COREWINDOW
+        void __cdecl SetWindow(ABI::Windows::UI::Core::ICoreWindow* window);
+    #ifdef __cplusplus_winrt
+        void __cdecl SetWindow(Windows::UI::Core::CoreWindow^ window)
+        {
+            // See https://msdn.microsoft.com/en-us/library/hh755802.aspx
+            SetWindow(reinterpret_cast<ABI::Windows::UI::Core::ICoreWindow*>(window));
+        }
+    #endif
+    #ifdef CPPWINRT_VERSION
+        void __cdecl SetWindow(winrt::Windows::UI::Core::CoreWindow window)
+        {
+            // See https://docs.microsoft.com/en-us/windows/uwp/cpp-and-winrt-apis/interop-winrt-abi
+            SetWindow(reinterpret_cast<ABI::Windows::UI::Core::ICoreWindow*>(winrt::get_abi(window)));
+        }
+    #endif
+    #elif defined(WM_USER)
+        static void __cdecl ProcessMessage(UINT message, WPARAM wParam, LPARAM lParam);
+    #endif
+
+        // Singleton
+        static Keyboard& __cdecl Get();
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

enginecustom/include/Inc/Model.h

@@ -0,0 +1,372 @@
+//--------------------------------------------------------------------------------------
+// File: Model.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#include <dxgiformat.h>
+#endif
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <new>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <malloc.h>
+
+#include <wrl\client.h>
+
+#include <DirectXMath.h>
+#include <DirectXCollision.h>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        class IEffect;
+        class IEffectFactory;
+        class CommonStates;
+        class ModelMesh;
+
+        //------------------------------------------------------------------------------
+        // Model loading options
+        enum ModelLoaderFlags : uint32_t
+        {
+            ModelLoader_Clockwise = 0x0,
+            ModelLoader_CounterClockwise = 0x1,
+            ModelLoader_PremultipledAlpha = 0x2,
+            ModelLoader_MaterialColorsSRGB = 0x4,
+            ModelLoader_AllowLargeModels = 0x8,
+            ModelLoader_IncludeBones = 0x10,
+            ModelLoader_DisableSkinning = 0x20,
+        };
+
+        //------------------------------------------------------------------------------
+        // Frame hierarchy for rigid body and skeletal animation
+        struct ModelBone
+        {
+            ModelBone() noexcept :
+                parentIndex(c_Invalid),
+                childIndex(c_Invalid),
+                siblingIndex(c_Invalid)
+            {
+            }
+
+            ModelBone(uint32_t parent, uint32_t child, uint32_t sibling) noexcept :
+                parentIndex(parent),
+                childIndex(child),
+                siblingIndex(sibling)
+            {
+            }
+
+            uint32_t            parentIndex;
+            uint32_t            childIndex;
+            uint32_t            siblingIndex;
+            std::wstring        name;
+
+            using Collection = std::vector<ModelBone>;
+
+            static constexpr uint32_t c_Invalid = uint32_t(-1);
+
+            struct aligned_deleter { void operator()(void* p) noexcept { _aligned_free(p); } };
+
+            using TransformArray = std::unique_ptr<XMMATRIX[], aligned_deleter>;
+
+            static TransformArray MakeArray(size_t count)
+            {
+                void* temp = _aligned_malloc(sizeof(XMMATRIX) * count, 16);
+                if (!temp)
+                    throw std::bad_alloc();
+                return TransformArray(static_cast<XMMATRIX*>(temp));
+            }
+        };
+
+
+        //------------------------------------------------------------------------------
+        // Each mesh part is a submesh with a single effect
+        class ModelMeshPart
+        {
+        public:
+            ModelMeshPart() noexcept;
+
+            ModelMeshPart(ModelMeshPart&&) = default;
+            ModelMeshPart& operator= (ModelMeshPart&&) = default;
+
+            ModelMeshPart(ModelMeshPart const&) = default;
+            ModelMeshPart& operator= (ModelMeshPart const&) = default;
+
+            virtual ~ModelMeshPart();
+
+            using Collection = std::vector<std::unique_ptr<ModelMeshPart>>;
+            using InputLayoutCollection = std::vector<D3D11_INPUT_ELEMENT_DESC>;
+
+            uint32_t                                                indexCount;
+            uint32_t                                                startIndex;
+            int32_t                                                 vertexOffset;
+            uint32_t                                                vertexStride;
+            D3D_PRIMITIVE_TOPOLOGY                                  primitiveType;
+            DXGI_FORMAT                                             indexFormat;
+            Microsoft::WRL::ComPtr<ID3D11InputLayout>               inputLayout;
+            Microsoft::WRL::ComPtr<ID3D11Buffer>                    indexBuffer;
+            Microsoft::WRL::ComPtr<ID3D11Buffer>                    vertexBuffer;
+            std::shared_ptr<IEffect>                                effect;
+            std::shared_ptr<InputLayoutCollection>                  vbDecl;
+            bool                                                    isAlpha;
+
+            // Draw mesh part with custom effect
+            void __cdecl Draw(
+                _In_ ID3D11DeviceContext* deviceContext,
+                _In_ IEffect* ieffect,
+                _In_ ID3D11InputLayout* iinputLayout,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            void __cdecl DrawInstanced(
+                _In_ ID3D11DeviceContext* deviceContext,
+                _In_ IEffect* ieffect,
+                _In_ ID3D11InputLayout* iinputLayout,
+                uint32_t instanceCount,
+                uint32_t startInstanceLocation = 0,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+           // Create input layout for drawing with a custom effect.
+            void __cdecl CreateInputLayout(_In_ ID3D11Device* device, _In_ IEffect* ieffect, _Outptr_ ID3D11InputLayout** iinputLayout) const;
+
+            // Change effect used by part and regenerate input layout (be sure to call Model::Modified as well)
+            void __cdecl ModifyEffect(_In_ ID3D11Device* device, _In_ const std::shared_ptr<IEffect>& ieffect, bool isalpha = false);
+        };
+
+
+        //------------------------------------------------------------------------------
+        // A mesh consists of one or more model mesh parts
+        class ModelMesh
+        {
+        public:
+            ModelMesh() noexcept;
+
+            ModelMesh(ModelMesh&&) = default;
+            ModelMesh& operator= (ModelMesh&&) = default;
+
+            ModelMesh(ModelMesh const&) = default;
+            ModelMesh& operator= (ModelMesh const&) = default;
+
+            virtual ~ModelMesh();
+
+            BoundingSphere              boundingSphere;
+            BoundingBox                 boundingBox;
+            ModelMeshPart::Collection   meshParts;
+            uint32_t                    boneIndex;
+            std::vector<uint32_t>       boneInfluences;
+            std::wstring                name;
+            bool                        ccw;
+            bool                        pmalpha;
+
+            using Collection = std::vector<std::shared_ptr<ModelMesh>>;
+
+            // Setup states for drawing mesh
+            void __cdecl PrepareForRendering(
+                _In_ ID3D11DeviceContext* deviceContext,
+                const CommonStates& states,
+                bool alpha = false,
+                bool wireframe = false) const;
+
+            // Draw the mesh
+            void XM_CALLCONV Draw(
+                _In_ ID3D11DeviceContext* deviceContext,
+                FXMMATRIX world, CXMMATRIX view, CXMMATRIX projection,
+                bool alpha = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            // Draw the mesh using model bones
+            void XM_CALLCONV Draw(
+                _In_ ID3D11DeviceContext* deviceContext,
+                size_t nbones, _In_reads_(nbones) const XMMATRIX* boneTransforms,
+                FXMMATRIX world, CXMMATRIX view, CXMMATRIX projection,
+                bool alpha = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            // Draw the mesh using skinning
+            void XM_CALLCONV DrawSkinned(
+                _In_ ID3D11DeviceContext* deviceContext,
+                size_t nbones, _In_reads_(nbones) const XMMATRIX* boneTransforms,
+                FXMMATRIX world, CXMMATRIX view, CXMMATRIX projection,
+                bool alpha = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            static void SetDepthBufferMode(bool reverseZ)
+            {
+                s_reversez = reverseZ;
+            }
+
+        private:
+            static bool s_reversez;
+        };
+
+
+        //------------------------------------------------------------------------------
+        // A model consists of one or more meshes
+        class Model
+        {
+        public:
+            Model() = default;
+
+            Model(Model&&) = default;
+            Model& operator= (Model&&) = default;
+
+            Model(Model const& other);
+            Model& operator= (Model const& rhs);
+
+            virtual ~Model();
+
+            ModelMesh::Collection       meshes;
+            ModelBone::Collection       bones;
+            ModelBone::TransformArray   boneMatrices;
+            ModelBone::TransformArray   invBindPoseMatrices;
+            std::wstring                name;
+
+            // Draw all the meshes in the model
+            void XM_CALLCONV Draw(
+                _In_ ID3D11DeviceContext* deviceContext,
+                const CommonStates& states,
+                FXMMATRIX world, CXMMATRIX view, CXMMATRIX projection,
+                bool wireframe = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            // Draw all the meshes using model bones
+            void XM_CALLCONV Draw(
+                _In_ ID3D11DeviceContext* deviceContext,
+                const CommonStates& states,
+                size_t nbones, _In_reads_(nbones) const XMMATRIX* boneTransforms,
+                FXMMATRIX world, CXMMATRIX view, CXMMATRIX projection,
+                bool wireframe = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            // Draw all the meshes using skinning
+            void XM_CALLCONV DrawSkinned(
+                _In_ ID3D11DeviceContext* deviceContext,
+                const CommonStates& states,
+                size_t nbones, _In_reads_(nbones) const XMMATRIX* boneTransforms,
+                FXMMATRIX world, CXMMATRIX view, CXMMATRIX projection,
+                bool wireframe = false,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) const;
+
+            // Compute bone positions based on heirarchy and transform matrices
+            void __cdecl CopyAbsoluteBoneTransformsTo(
+                size_t nbones,
+                _Out_writes_(nbones) XMMATRIX* boneTransforms) const;
+
+            void __cdecl CopyAbsoluteBoneTransforms(
+                size_t nbones,
+                _In_reads_(nbones) const XMMATRIX* inBoneTransforms,
+                _Out_writes_(nbones) XMMATRIX* outBoneTransforms) const;
+
+            // Set bone matrices to a set of relative tansforms
+            void __cdecl CopyBoneTransformsFrom(
+                size_t nbones,
+                _In_reads_(nbones) const XMMATRIX* boneTransforms);
+
+            // Copies the relative bone matrices to a transform array
+            void __cdecl CopyBoneTransformsTo(
+                size_t nbones,
+                _Out_writes_(nbones) XMMATRIX* boneTransforms) const;
+
+            // Notify model that effects, parts list, or mesh list has changed
+            void __cdecl Modified() noexcept { mEffectCache.clear(); }
+
+            // Update all effects used by the model
+            void __cdecl UpdateEffects(_In_ std::function<void __cdecl(IEffect*)> setEffect);
+
+            // Loads a model from a Visual Studio Starter Kit .CMO file
+            static std::unique_ptr<Model> __cdecl CreateFromCMO(
+                _In_ ID3D11Device* device,
+                _In_reads_bytes_(dataSize) const uint8_t* meshData, size_t dataSize,
+                _In_ IEffectFactory& fxFactory,
+                ModelLoaderFlags flags = ModelLoader_CounterClockwise,
+                _Out_opt_ size_t* animsOffset = nullptr);
+            static std::unique_ptr<Model> __cdecl CreateFromCMO(
+                _In_ ID3D11Device* device,
+                _In_z_ const wchar_t* szFileName,
+                _In_ IEffectFactory& fxFactory,
+                ModelLoaderFlags flags = ModelLoader_CounterClockwise,
+                _Out_opt_ size_t* animsOffset = nullptr);
+
+            // Loads a model from a DirectX SDK .SDKMESH file
+            static std::unique_ptr<Model> __cdecl CreateFromSDKMESH(
+                _In_ ID3D11Device* device,
+                _In_reads_bytes_(dataSize) const uint8_t* meshData, _In_ size_t dataSize,
+                _In_ IEffectFactory& fxFactory,
+                ModelLoaderFlags flags = ModelLoader_Clockwise);
+            static std::unique_ptr<Model> __cdecl CreateFromSDKMESH(
+                _In_ ID3D11Device* device,
+                _In_z_ const wchar_t* szFileName,
+                _In_ IEffectFactory& fxFactory,
+                ModelLoaderFlags flags = ModelLoader_Clockwise);
+
+            // Loads a model from a .VBO file
+            static std::unique_ptr<Model> __cdecl CreateFromVBO(
+                _In_ ID3D11Device* device,
+                _In_reads_bytes_(dataSize) const uint8_t* meshData, _In_ size_t dataSize,
+                _In_ std::shared_ptr<IEffect> ieffect = nullptr,
+                ModelLoaderFlags flags = ModelLoader_Clockwise);
+            static std::unique_ptr<Model> __cdecl CreateFromVBO(
+                _In_ ID3D11Device* device,
+                _In_z_ const wchar_t* szFileName,
+                _In_ std::shared_ptr<IEffect> ieffect = nullptr,
+                ModelLoaderFlags flags = ModelLoader_Clockwise);
+
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+            static std::unique_ptr<Model> __cdecl CreateFromCMO(
+                _In_ ID3D11Device* device,
+                _In_z_ const __wchar_t* szFileName,
+                _In_ IEffectFactory& fxFactory,
+                ModelLoaderFlags flags = ModelLoader_CounterClockwise,
+                _Out_opt_ size_t* animsOffset = nullptr);
+
+            static std::unique_ptr<Model> __cdecl CreateFromSDKMESH(
+                _In_ ID3D11Device* device,
+                _In_z_ const __wchar_t* szFileName,
+                _In_ IEffectFactory& fxFactory,
+                ModelLoaderFlags flags = ModelLoader_Clockwise);
+
+            static std::unique_ptr<Model> __cdecl CreateFromVBO(
+                _In_ ID3D11Device* device,
+                _In_z_ const __wchar_t* szFileName,
+                _In_ std::shared_ptr<IEffect> ieffect = nullptr,
+                ModelLoaderFlags flags = ModelLoader_Clockwise);
+#endif // !_NATIVE_WCHAR_T_DEFINED
+
+        private:
+            std::set<IEffect*>  mEffectCache;
+
+            void __cdecl ComputeAbsolute(uint32_t index,
+                CXMMATRIX local, size_t nbones,
+                _In_reads_(nbones) const XMMATRIX* inBoneTransforms,
+                _Inout_updates_(nbones) XMMATRIX* outBoneTransforms,
+                size_t& visited) const;
+        };
+
+    #ifdef __clang__
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+    #endif
+
+        DEFINE_ENUM_FLAG_OPERATORS(ModelLoaderFlags);
+
+    #ifdef __clang__
+    #pragma clang diagnostic pop
+    #endif
+    }
+}

enginecustom/include/Inc/Mouse.h

@@ -0,0 +1,172 @@
+//--------------------------------------------------------------------------------------
+// File: Mouse.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if !defined(USING_XINPUT) && !defined(USING_GAMEINPUT) && !defined(USING_COREWINDOW)
+
+#ifdef _GAMING_DESKTOP
+#include <grdk.h>
+#endif
+
+#if (defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_GAMES)) || (defined(_GAMING_DESKTOP) && (_GRDK_EDITION >= 220600))
+#define USING_GAMEINPUT
+#elif (defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)) || (defined(_XBOX_ONE) && defined(_TITLE))
+#define USING_COREWINDOW
+#endif
+
+#endif // !USING_XINPUT && !USING_GAMEINPUT && !USING_WINDOWS_GAMING_INPUT
+
+#if defined(USING_GAMEINPUT) && !defined(_GAMING_XBOX) && defined(_MSC_VER)
+#pragma comment(lib,"gameinput.lib")
+#endif
+
+#include <memory>
+
+#ifdef USING_COREWINDOW
+namespace ABI { namespace Windows { namespace UI { namespace Core { struct ICoreWindow; } } } }
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#endif
+
+
+namespace DirectX
+{
+    class Mouse
+    {
+    public:
+        Mouse() noexcept(false);
+
+        Mouse(Mouse&&) noexcept;
+        Mouse& operator= (Mouse&&) noexcept;
+
+        Mouse(Mouse const&) = delete;
+        Mouse& operator=(Mouse const&) = delete;
+
+        virtual ~Mouse();
+
+        enum Mode
+        {
+            MODE_ABSOLUTE = 0,
+            MODE_RELATIVE,
+        };
+
+        struct State
+        {
+            bool    leftButton;
+            bool    middleButton;
+            bool    rightButton;
+            bool    xButton1;
+            bool    xButton2;
+            int     x;
+            int     y;
+            int     scrollWheelValue;
+            Mode    positionMode;
+        };
+
+        class ButtonStateTracker
+        {
+        public:
+            enum ButtonState
+            {
+                UP = 0,         // Button is up
+                HELD = 1,       // Button is held down
+                RELEASED = 2,   // Button was just released
+                PRESSED = 3,    // Buton was just pressed
+            };
+
+            ButtonState leftButton;
+            ButtonState middleButton;
+            ButtonState rightButton;
+            ButtonState xButton1;
+            ButtonState xButton2;
+
+        #ifdef _PREFAST_
+        #pragma prefast(push)
+        #pragma prefast(disable : 26495, "Reset() performs the initialization")
+        #endif
+            ButtonStateTracker() noexcept { Reset(); }
+        #ifdef _PREFAST_
+        #pragma prefast(pop)
+        #endif
+
+            void __cdecl Update(const State& state) noexcept;
+
+            void __cdecl Reset() noexcept;
+
+            State __cdecl GetLastState() const noexcept { return lastState; }
+
+        private:
+            State lastState;
+        };
+
+        // Retrieve the current state of the mouse
+        State __cdecl GetState() const;
+
+        // Resets the accumulated scroll wheel value
+        void __cdecl ResetScrollWheelValue() noexcept;
+
+        // Sets mouse mode (defaults to absolute)
+        void __cdecl SetMode(Mode mode);
+
+        // Signals the end of frame (recommended, but optional)
+        void __cdecl EndOfInputFrame() noexcept;
+
+        // Feature detection
+        bool __cdecl IsConnected() const;
+
+        // Cursor visibility
+        bool __cdecl IsVisible() const noexcept;
+        void __cdecl SetVisible(bool visible);
+
+    #ifdef USING_COREWINDOW
+        void __cdecl SetWindow(ABI::Windows::UI::Core::ICoreWindow* window);
+    #ifdef __cplusplus_winrt
+        void __cdecl SetWindow(Windows::UI::Core::CoreWindow^ window)
+        {
+            // See https://msdn.microsoft.com/en-us/library/hh755802.aspx
+            SetWindow(reinterpret_cast<ABI::Windows::UI::Core::ICoreWindow*>(window));
+        }
+    #endif
+    #ifdef CPPWINRT_VERSION
+        void __cdecl SetWindow(winrt::Windows::UI::Core::CoreWindow window)
+        {
+            // See https://docs.microsoft.com/en-us/windows/uwp/cpp-and-winrt-apis/interop-winrt-abi
+            SetWindow(reinterpret_cast<ABI::Windows::UI::Core::ICoreWindow*>(winrt::get_abi(window)));
+        }
+    #endif
+
+        static void __cdecl SetDpi(float dpi);
+    #elif defined(WM_USER)
+        void __cdecl SetWindow(HWND window);
+        static void __cdecl ProcessMessage(UINT message, WPARAM wParam, LPARAM lParam);
+
+    #ifdef _GAMING_XBOX
+        static void __cdecl SetResolution(float scale);
+    #endif
+    #endif
+
+        // Singleton
+        static Mouse& __cdecl Get();
+
+    private:
+        // Private implementation.
+        class Impl;
+
+        std::unique_ptr<Impl> pImpl;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif

enginecustom/include/Inc/PostProcess.h

@@ -0,0 +1,227 @@
+//--------------------------------------------------------------------------------------
+// File: PostProcess.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <memory>
+#include <functional>
+
+#include <DirectXMath.h>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        //------------------------------------------------------------------------------
+        // Abstract interface representing a post-process pass
+        class IPostProcess
+        {
+        public:
+            virtual ~IPostProcess() = default;
+
+            IPostProcess(const IPostProcess&) = delete;
+            IPostProcess& operator=(const IPostProcess&) = delete;
+
+            virtual void __cdecl Process(_In_ ID3D11DeviceContext* deviceContext,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) = 0;
+
+        protected:
+            IPostProcess() = default;
+            IPostProcess(IPostProcess&&) = default;
+            IPostProcess& operator=(IPostProcess&&) = default;
+        };
+
+
+        //------------------------------------------------------------------------------
+        // Basic post-process
+        class BasicPostProcess : public IPostProcess
+        {
+        public:
+            enum Effect : unsigned int
+            {
+                Copy,
+                Monochrome,
+                Sepia,
+                DownScale_2x2,
+                DownScale_4x4,
+                GaussianBlur_5x5,
+                BloomExtract,
+                BloomBlur,
+                Effect_Max
+            };
+
+            explicit BasicPostProcess(_In_ ID3D11Device* device);
+
+            BasicPostProcess(BasicPostProcess&&) noexcept;
+            BasicPostProcess& operator= (BasicPostProcess&&) noexcept;
+
+            BasicPostProcess(BasicPostProcess const&) = delete;
+            BasicPostProcess& operator= (BasicPostProcess const&) = delete;
+
+            ~BasicPostProcess() override;
+
+            // IPostProcess methods.
+            void __cdecl Process(
+                _In_ ID3D11DeviceContext* deviceContext,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) override;
+
+            // Shader control
+            void __cdecl SetEffect(Effect fx);
+
+            // Properties
+            void __cdecl SetSourceTexture(_In_opt_ ID3D11ShaderResourceView* value);
+
+            // Sets multiplier for GaussianBlur_5x5
+            void __cdecl SetGaussianParameter(float multiplier);
+
+            // Sets parameters for BloomExtract
+            void __cdecl SetBloomExtractParameter(float threshold);
+
+            // Sets parameters for BloomBlur
+            void __cdecl SetBloomBlurParameters(bool horizontal, float size, float brightness);
+
+        private:
+            // Private implementation.
+            class Impl;
+
+            std::unique_ptr<Impl> pImpl;
+        };
+
+
+        //------------------------------------------------------------------------------
+        // Dual-texure post-process
+        class DualPostProcess : public IPostProcess
+        {
+        public:
+            enum Effect : unsigned int
+            {
+                Merge,
+                BloomCombine,
+                Effect_Max
+            };
+
+            explicit DualPostProcess(_In_ ID3D11Device* device);
+
+            DualPostProcess(DualPostProcess&&) noexcept;
+            DualPostProcess& operator= (DualPostProcess&&) noexcept;
+
+            DualPostProcess(DualPostProcess const&) = delete;
+            DualPostProcess& operator= (DualPostProcess const&) = delete;
+
+            ~DualPostProcess() override;
+
+            // IPostProcess methods.
+            void __cdecl Process(_In_ ID3D11DeviceContext* deviceContext,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) override;
+
+            // Shader control
+            void __cdecl SetEffect(Effect fx);
+
+            // Properties
+            void __cdecl SetSourceTexture(_In_opt_ ID3D11ShaderResourceView* value);
+            void __cdecl SetSourceTexture2(_In_opt_ ID3D11ShaderResourceView* value);
+
+            // Sets parameters for Merge
+            void __cdecl SetMergeParameters(float weight1, float weight2);
+
+            // Sets parameters for BloomCombine
+            void __cdecl SetBloomCombineParameters(float bloom, float base, float bloomSaturation, float baseSaturation);
+
+        private:
+            // Private implementation.
+            class Impl;
+
+            std::unique_ptr<Impl> pImpl;
+        };
+
+
+        //------------------------------------------------------------------------------
+        // Tone-map post-process
+        class ToneMapPostProcess : public IPostProcess
+        {
+        public:
+            // Tone-mapping operator
+            enum Operator : unsigned int
+            {
+                None,               // Pass-through
+                Saturate,           // Clamp [0,1]
+                Reinhard,           // x/(1+x)
+                ACESFilmic,
+                Operator_Max
+            };
+
+            // Electro-Optical Transfer Function (EOTF)
+            enum TransferFunction : unsigned int
+            {
+                Linear,             // Pass-through
+                SRGB,               // sRGB (Rec.709 and approximate sRGB display curve)
+                ST2084,             // HDR10 (Rec.2020 color primaries and ST.2084 display curve)
+                TransferFunction_Max
+            };
+
+            // Color Rotation Transform for HDR10
+            enum ColorPrimaryRotation : unsigned int
+            {
+                HDTV_to_UHDTV,       // Rec.709 to Rec.2020
+                DCI_P3_D65_to_UHDTV, // DCI-P3-D65 (a.k.a Display P3 or P3D65) to Rec.2020
+                HDTV_to_DCI_P3_D65,  // Rec.709 to DCI-P3-D65 (a.k.a Display P3 or P3D65)
+            };
+
+            explicit ToneMapPostProcess(_In_ ID3D11Device* device);
+
+            ToneMapPostProcess(ToneMapPostProcess&&) noexcept;
+            ToneMapPostProcess& operator= (ToneMapPostProcess&&) noexcept;
+
+            ToneMapPostProcess(ToneMapPostProcess const&) = delete;
+            ToneMapPostProcess& operator= (ToneMapPostProcess const&) = delete;
+
+            ~ToneMapPostProcess() override;
+
+            // IPostProcess methods.
+            void __cdecl Process(_In_ ID3D11DeviceContext* deviceContext,
+                _In_ std::function<void __cdecl()> setCustomState = nullptr) override;
+
+            // Shader control
+            void __cdecl SetOperator(Operator op);
+
+            void __cdecl SetTransferFunction(TransferFunction func);
+
+        #if defined(_XBOX_ONE) && defined(_TITLE)
+            // Uses Multiple Render Targets to generate both HDR10 and GameDVR SDR signals
+            void __cdecl SetMRTOutput(bool value = true);
+        #endif
+
+            // Properties
+            void __cdecl SetHDRSourceTexture(_In_opt_ ID3D11ShaderResourceView* value);
+
+            // Sets the Color Rotation Transform for HDR10 signal output
+            void __cdecl SetColorRotation(ColorPrimaryRotation value);
+            void __cdecl SetColorRotation(CXMMATRIX value);
+
+            // Sets exposure value for LDR tonemap operators
+            void __cdecl SetExposure(float exposureValue);
+
+            // Sets ST.2084 parameter for how bright white should be in nits
+            void __cdecl SetST2084Parameter(float paperWhiteNits);
+
+        private:
+            // Private implementation.
+            class Impl;
+
+            std::unique_ptr<Impl> pImpl;
+        };
+    }
+}

enginecustom/include/Inc/PrimitiveBatch.h

@@ -0,0 +1,140 @@
+//--------------------------------------------------------------------------------------
+// File: PrimitiveBatch.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <utility>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        namespace Private
+        {
+        // Base class, not to be used directly: clients should access this via the derived PrimitiveBatch<T>.
+            class PrimitiveBatchBase
+            {
+            protected:
+                PrimitiveBatchBase(_In_ ID3D11DeviceContext* deviceContext, size_t maxIndices, size_t maxVertices, size_t vertexSize);
+
+                PrimitiveBatchBase(PrimitiveBatchBase&&) noexcept;
+                PrimitiveBatchBase& operator= (PrimitiveBatchBase&&) noexcept;
+
+                PrimitiveBatchBase(PrimitiveBatchBase const&) = delete;
+                PrimitiveBatchBase& operator= (PrimitiveBatchBase const&) = delete;
+
+                virtual ~PrimitiveBatchBase();
+
+            public:
+                // Begin/End a batch of primitive drawing operations.
+                void __cdecl Begin();
+                void __cdecl End();
+
+            protected:
+                // Internal, untyped drawing method.
+                void __cdecl Draw(D3D11_PRIMITIVE_TOPOLOGY topology, bool isIndexed, _In_opt_count_(indexCount) uint16_t const* indices, size_t indexCount, size_t vertexCount, _Out_ void** pMappedVertices);
+
+            private:
+                // Private implementation.
+                class Impl;
+
+                std::unique_ptr<Impl> pImpl;
+            };
+        }
+
+        // Template makes the API typesafe, eg. PrimitiveBatch<VertexPositionColor>.
+        template<typename TVertex>
+        class PrimitiveBatch : public Private::PrimitiveBatchBase
+        {
+            static constexpr size_t DefaultBatchSize = 2048;
+
+        public:
+            explicit PrimitiveBatch(_In_ ID3D11DeviceContext* deviceContext, size_t maxIndices = DefaultBatchSize * 3, size_t maxVertices = DefaultBatchSize)
+                : PrimitiveBatchBase(deviceContext, maxIndices, maxVertices, sizeof(TVertex))
+            {
+            }
+
+            PrimitiveBatch(PrimitiveBatch&&) = default;
+            PrimitiveBatch& operator= (PrimitiveBatch&&) = default;
+
+            PrimitiveBatch(PrimitiveBatch const&) = delete;
+            PrimitiveBatch& operator= (PrimitiveBatch const&) = delete;
+
+            // Similar to the D3D9 API DrawPrimitiveUP.
+            void Draw(D3D11_PRIMITIVE_TOPOLOGY topology, _In_reads_(vertexCount) TVertex const* vertices, size_t vertexCount)
+            {
+                void* mappedVertices;
+
+                PrimitiveBatchBase::Draw(topology, false, nullptr, 0, vertexCount, &mappedVertices);
+
+                memcpy(mappedVertices, vertices, vertexCount * sizeof(TVertex));
+            }
+
+
+            // Similar to the D3D9 API DrawIndexedPrimitiveUP.
+            void DrawIndexed(D3D11_PRIMITIVE_TOPOLOGY topology, _In_reads_(indexCount) uint16_t const* indices, size_t indexCount, _In_reads_(vertexCount) TVertex const* vertices, size_t vertexCount)
+            {
+                void* mappedVertices;
+
+                PrimitiveBatchBase::Draw(topology, true, indices, indexCount, vertexCount, &mappedVertices);
+
+                memcpy(mappedVertices, vertices, vertexCount * sizeof(TVertex));
+            }
+
+
+            void DrawLine(TVertex const& v1, TVertex const& v2)
+            {
+                TVertex* mappedVertices;
+
+                PrimitiveBatchBase::Draw(D3D11_PRIMITIVE_TOPOLOGY_LINELIST, false, nullptr, 0, 2, reinterpret_cast<void**>(&mappedVertices));
+
+                mappedVertices[0] = v1;
+                mappedVertices[1] = v2;
+            }
+
+
+            void DrawTriangle(TVertex const& v1, TVertex const& v2, TVertex const& v3)
+            {
+                TVertex* mappedVertices;
+
+                PrimitiveBatchBase::Draw(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, false, nullptr, 0, 3, reinterpret_cast<void**>(&mappedVertices));
+
+                mappedVertices[0] = v1;
+                mappedVertices[1] = v2;
+                mappedVertices[2] = v3;
+            }
+
+
+            void DrawQuad(TVertex const& v1, TVertex const& v2, TVertex const& v3, TVertex const& v4)
+            {
+                static const uint16_t quadIndices[] = { 0, 1, 2, 0, 2, 3 };
+
+                TVertex* mappedVertices;
+
+                PrimitiveBatchBase::Draw(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST, true, quadIndices, 6, 4, reinterpret_cast<void**>(&mappedVertices));
+
+                mappedVertices[0] = v1;
+                mappedVertices[1] = v2;
+                mappedVertices[2] = v3;
+                mappedVertices[3] = v4;
+            }
+        };
+    }
+}

enginecustom/include/Inc/ScreenGrab.h

@@ -0,0 +1,54 @@
+//--------------------------------------------------------------------------------------
+// File: ScreenGrab.h
+//
+// Function for capturing a 2D texture and saving it to a file (aka a 'screenshot'
+// when used on a Direct3D Render Target).
+//
+// Note these functions are useful as a light-weight runtime screen grabber. For
+// full-featured texture capture, DDS writer, and texture processing pipeline,
+// see the 'Texconv' sample and the 'DirectXTex' library.
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248926
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <functional>
+
+#if defined(NTDDI_WIN10_FE) || defined(__MINGW32__)
+#include <ocidl.h>
+#else
+#include <OCIdl.h>
+#endif
+
+#ifdef _MSC_VER
+#pragma comment(lib,"uuid.lib")
+#endif
+
+
+namespace DirectX
+{
+    HRESULT __cdecl SaveDDSTextureToFile(
+        _In_ ID3D11DeviceContext* pContext,
+        _In_ ID3D11Resource* pSource,
+        _In_z_ const wchar_t* fileName) noexcept;
+
+    HRESULT __cdecl SaveWICTextureToFile(
+        _In_ ID3D11DeviceContext* pContext,
+        _In_ ID3D11Resource* pSource,
+        _In_ REFGUID guidContainerFormat,
+        _In_z_ const wchar_t* fileName,
+        _In_opt_ const GUID* targetFormat = nullptr,
+        _In_ std::function<void __cdecl(IPropertyBag2*)> setCustomProps = nullptr,
+        _In_ bool forceSRGB = false);
+}

enginecustom/include/Inc/SpriteBatch.h

@@ -0,0 +1,102 @@
+//--------------------------------------------------------------------------------------
+// File: SpriteBatch.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#include <dxgi1_2.h>
+#endif
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+
+#include <DirectXMath.h>
+#include <DirectXColors.h>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        enum SpriteSortMode
+        {
+            SpriteSortMode_Deferred,
+            SpriteSortMode_Immediate,
+            SpriteSortMode_Texture,
+            SpriteSortMode_BackToFront,
+            SpriteSortMode_FrontToBack,
+        };
+
+        enum SpriteEffects : uint32_t
+        {
+            SpriteEffects_None = 0,
+            SpriteEffects_FlipHorizontally = 1,
+            SpriteEffects_FlipVertically = 2,
+            SpriteEffects_FlipBoth = SpriteEffects_FlipHorizontally | SpriteEffects_FlipVertically,
+        };
+
+        class SpriteBatch
+        {
+        public:
+            explicit SpriteBatch(_In_ ID3D11DeviceContext* deviceContext);
+
+            SpriteBatch(SpriteBatch&&) noexcept;
+            SpriteBatch& operator= (SpriteBatch&&) noexcept;
+
+            SpriteBatch(SpriteBatch const&) = delete;
+            SpriteBatch& operator= (SpriteBatch const&) = delete;
+
+            virtual ~SpriteBatch();
+
+            // Begin/End a batch of sprite drawing operations.
+            void XM_CALLCONV Begin(SpriteSortMode sortMode = SpriteSortMode_Deferred,
+                _In_opt_ ID3D11BlendState* blendState = nullptr,
+                _In_opt_ ID3D11SamplerState* samplerState = nullptr,
+                _In_opt_ ID3D11DepthStencilState* depthStencilState = nullptr,
+                _In_opt_ ID3D11RasterizerState* rasterizerState = nullptr,
+                _In_ std::function<void __cdecl()> setCustomShaders = nullptr,
+                FXMMATRIX transformMatrix = MatrixIdentity);
+            void __cdecl End();
+
+            // Draw overloads specifying position, origin and scale as XMFLOAT2.
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, XMFLOAT2 const& position, FXMVECTOR color = Colors::White);
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, XMFLOAT2 const& position, _In_opt_ RECT const* sourceRectangle, FXMVECTOR color = Colors::White, float rotation = 0, XMFLOAT2 const& origin = Float2Zero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0);
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, XMFLOAT2 const& position, _In_opt_ RECT const* sourceRectangle, FXMVECTOR color, float rotation, XMFLOAT2 const& origin, XMFLOAT2 const& scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0);
+
+            // Draw overloads specifying position, origin and scale via the first two components of an XMVECTOR.
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, FXMVECTOR position, FXMVECTOR color = Colors::White);
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, FXMVECTOR position, _In_opt_ RECT const* sourceRectangle, FXMVECTOR color = Colors::White, float rotation = 0, FXMVECTOR origin = g_XMZero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0);
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, FXMVECTOR position, _In_opt_ RECT const* sourceRectangle, FXMVECTOR color, float rotation, FXMVECTOR origin, GXMVECTOR scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0);
+
+            // Draw overloads specifying position as a RECT.
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, RECT const& destinationRectangle, FXMVECTOR color = Colors::White);
+            void XM_CALLCONV Draw(_In_ ID3D11ShaderResourceView* texture, RECT const& destinationRectangle, _In_opt_ RECT const* sourceRectangle, FXMVECTOR color = Colors::White, float rotation = 0, XMFLOAT2 const& origin = Float2Zero, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0);
+
+            // Rotation mode to be applied to the sprite transformation
+            void __cdecl SetRotation(DXGI_MODE_ROTATION mode);
+            DXGI_MODE_ROTATION __cdecl GetRotation() const noexcept;
+
+            // Set viewport for sprite transformation
+            void __cdecl SetViewport(const D3D11_VIEWPORT& viewPort);
+
+        private:
+            // Private implementation.
+            struct Impl;
+
+            std::unique_ptr<Impl> pImpl;
+
+            static const XMMATRIX MatrixIdentity;
+            static const XMFLOAT2 Float2Zero;
+        };
+    }
+}

enginecustom/include/Inc/SpriteFont.h

@@ -0,0 +1,116 @@
+//--------------------------------------------------------------------------------------
+// File: SpriteFont.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include "SpriteBatch.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        class SpriteFont
+        {
+        public:
+            struct Glyph;
+
+            SpriteFont(_In_ ID3D11Device* device, _In_z_ wchar_t const* fileName, bool forceSRGB = false);
+            SpriteFont(_In_ ID3D11Device* device, _In_reads_bytes_(dataSize) uint8_t const* dataBlob, _In_ size_t dataSize, bool forceSRGB = false);
+            SpriteFont(_In_ ID3D11ShaderResourceView* texture, _In_reads_(glyphCount) Glyph const* glyphs, _In_ size_t glyphCount, _In_ float lineSpacing);
+
+            SpriteFont(SpriteFont&&) noexcept;
+            SpriteFont& operator= (SpriteFont&&) noexcept;
+
+            SpriteFont(SpriteFont const&) = delete;
+            SpriteFont& operator= (SpriteFont const&) = delete;
+
+            virtual ~SpriteFont();
+
+            // Wide-character / UTF-16LE
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ wchar_t const* text, XMFLOAT2 const& position, FXMVECTOR color = Colors::White, float rotation = 0, XMFLOAT2 const& origin = Float2Zero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ wchar_t const* text, XMFLOAT2 const& position, FXMVECTOR color, float rotation, XMFLOAT2 const& origin, XMFLOAT2 const& scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ wchar_t const* text, FXMVECTOR position, FXMVECTOR color = Colors::White, float rotation = 0, FXMVECTOR origin = g_XMZero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ wchar_t const* text, FXMVECTOR position, FXMVECTOR color, float rotation, FXMVECTOR origin, GXMVECTOR scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+
+            XMVECTOR XM_CALLCONV MeasureString(_In_z_ wchar_t const* text, bool ignoreWhitespace = true) const;
+
+            RECT __cdecl MeasureDrawBounds(_In_z_ wchar_t const* text, XMFLOAT2 const& position, bool ignoreWhitespace = true) const;
+            RECT XM_CALLCONV MeasureDrawBounds(_In_z_ wchar_t const* text, FXMVECTOR position, bool ignoreWhitespace = true) const;
+
+            // UTF-8
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ char const* text, XMFLOAT2 const& position, FXMVECTOR color = Colors::White, float rotation = 0, XMFLOAT2 const& origin = Float2Zero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ char const* text, XMFLOAT2 const& position, FXMVECTOR color, float rotation, XMFLOAT2 const& origin, XMFLOAT2 const& scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ char const* text, FXMVECTOR position, FXMVECTOR color = Colors::White, float rotation = 0, FXMVECTOR origin = g_XMZero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ char const* text, FXMVECTOR position, FXMVECTOR color, float rotation, FXMVECTOR origin, GXMVECTOR scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+
+            XMVECTOR XM_CALLCONV MeasureString(_In_z_ char const* text, bool ignoreWhitespace = true) const;
+
+            RECT __cdecl MeasureDrawBounds(_In_z_ char const* text, XMFLOAT2 const& position, bool ignoreWhitespace = true) const;
+            RECT XM_CALLCONV MeasureDrawBounds(_In_z_ char const* text, FXMVECTOR position, bool ignoreWhitespace = true) const;
+
+            // Spacing properties
+            float __cdecl GetLineSpacing() const noexcept;
+            void __cdecl SetLineSpacing(float spacing);
+
+            // Font properties
+            wchar_t __cdecl GetDefaultCharacter() const noexcept;
+            void __cdecl SetDefaultCharacter(wchar_t character);
+
+            bool __cdecl ContainsCharacter(wchar_t character) const;
+
+            // Custom layout/rendering
+            Glyph const* __cdecl FindGlyph(wchar_t character) const;
+            void __cdecl GetSpriteSheet(ID3D11ShaderResourceView** texture) const;
+
+            // Describes a single character glyph.
+            struct Glyph
+            {
+                uint32_t Character;
+                RECT Subrect;
+                float XOffset;
+                float YOffset;
+                float XAdvance;
+            };
+
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+            SpriteFont(_In_ ID3D11Device* device, _In_z_ __wchar_t const* fileName, bool forceSRGB = false);
+
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ __wchar_t const* text, XMFLOAT2 const& position, FXMVECTOR color = Colors::White, float rotation = 0, XMFLOAT2 const& origin = Float2Zero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ __wchar_t const* text, XMFLOAT2 const& position, FXMVECTOR color, float rotation, XMFLOAT2 const& origin, XMFLOAT2 const& scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ __wchar_t const* text, FXMVECTOR position, FXMVECTOR color = Colors::White, float rotation = 0, FXMVECTOR origin = g_XMZero, float scale = 1, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+            void XM_CALLCONV DrawString(_In_ SpriteBatch* spriteBatch, _In_z_ __wchar_t const* text, FXMVECTOR position, FXMVECTOR color, float rotation, FXMVECTOR origin, GXMVECTOR scale, SpriteEffects effects = SpriteEffects_None, float layerDepth = 0) const;
+
+            XMVECTOR XM_CALLCONV MeasureString(_In_z_ __wchar_t const* text, bool ignoreWhitespace = true) const;
+
+            RECT __cdecl MeasureDrawBounds(_In_z_ __wchar_t const* text, XMFLOAT2 const& position, bool ignoreWhitespace = true) const;
+            RECT XM_CALLCONV MeasureDrawBounds(_In_z_ __wchar_t const* text, FXMVECTOR position, bool ignoreWhitespace = true) const;
+
+            void __cdecl SetDefaultCharacter(__wchar_t character);
+
+            bool __cdecl ContainsCharacter(__wchar_t character) const;
+
+            Glyph const* __cdecl FindGlyph(__wchar_t character) const;
+#endif // !_NATIVE_WCHAR_T_DEFINED
+
+        private:
+            // Private implementation.
+            class Impl;
+
+            std::unique_ptr<Impl> pImpl;
+
+            static const XMFLOAT2 Float2Zero;
+        };
+    }
+}

enginecustom/include/Inc/VertexTypes.h

@@ -0,0 +1,504 @@
+//--------------------------------------------------------------------------------------
+// File: VertexTypes.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <cstdint>
+
+#include <DirectXMath.h>
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+    // Vertex struct holding position information.
+        struct VertexPosition
+        {
+            VertexPosition() = default;
+
+            VertexPosition(const VertexPosition&) = default;
+            VertexPosition& operator=(const VertexPosition&) = default;
+
+            VertexPosition(VertexPosition&&) = default;
+            VertexPosition& operator=(VertexPosition&&) = default;
+
+            VertexPosition(XMFLOAT3 const& iposition) noexcept
+                : position(iposition)
+            {
+            }
+
+            VertexPosition(FXMVECTOR iposition) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+            }
+
+            XMFLOAT3 position;
+
+            static constexpr unsigned int InputElementCount = 1;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position and color information.
+        struct VertexPositionColor
+        {
+            VertexPositionColor() = default;
+
+            VertexPositionColor(const VertexPositionColor&) = default;
+            VertexPositionColor& operator=(const VertexPositionColor&) = default;
+
+            VertexPositionColor(VertexPositionColor&&) = default;
+            VertexPositionColor& operator=(VertexPositionColor&&) = default;
+
+            VertexPositionColor(XMFLOAT3 const& iposition, XMFLOAT4 const& icolor) noexcept
+                : position(iposition),
+                color(icolor)
+            {
+            }
+
+            VertexPositionColor(FXMVECTOR iposition, FXMVECTOR icolor) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat4(&this->color, icolor);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT4 color;
+
+            static constexpr unsigned int InputElementCount = 2;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position and texture mapping information.
+        struct VertexPositionTexture
+        {
+            VertexPositionTexture() = default;
+
+            VertexPositionTexture(const VertexPositionTexture&) = default;
+            VertexPositionTexture& operator=(const VertexPositionTexture&) = default;
+
+            VertexPositionTexture(VertexPositionTexture&&) = default;
+            VertexPositionTexture& operator=(VertexPositionTexture&&) = default;
+
+            VertexPositionTexture(XMFLOAT3 const& iposition, XMFLOAT2 const& itextureCoordinate) noexcept
+                : position(iposition),
+                textureCoordinate(itextureCoordinate)
+            {
+            }
+
+            VertexPositionTexture(FXMVECTOR iposition, FXMVECTOR itextureCoordinate) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat2(&this->textureCoordinate, itextureCoordinate);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT2 textureCoordinate;
+
+            static constexpr unsigned int InputElementCount = 2;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position and dual texture mapping information.
+        struct VertexPositionDualTexture
+        {
+            VertexPositionDualTexture() = default;
+
+            VertexPositionDualTexture(const VertexPositionDualTexture&) = default;
+            VertexPositionDualTexture& operator=(const VertexPositionDualTexture&) = default;
+
+            VertexPositionDualTexture(VertexPositionDualTexture&&) = default;
+            VertexPositionDualTexture& operator=(VertexPositionDualTexture&&) = default;
+
+            VertexPositionDualTexture(
+                XMFLOAT3 const& iposition,
+                XMFLOAT2 const& itextureCoordinate0,
+                XMFLOAT2 const& itextureCoordinate1) noexcept
+                : position(iposition),
+                textureCoordinate0(itextureCoordinate0),
+                textureCoordinate1(itextureCoordinate1)
+            {
+            }
+
+            VertexPositionDualTexture(
+                FXMVECTOR iposition,
+                FXMVECTOR itextureCoordinate0,
+                FXMVECTOR itextureCoordinate1) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat2(&this->textureCoordinate0, itextureCoordinate0);
+                XMStoreFloat2(&this->textureCoordinate1, itextureCoordinate1);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT2 textureCoordinate0;
+            XMFLOAT2 textureCoordinate1;
+
+            static constexpr unsigned int InputElementCount = 3;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position and normal vector.
+        struct VertexPositionNormal
+        {
+            VertexPositionNormal() = default;
+
+            VertexPositionNormal(const VertexPositionNormal&) = default;
+            VertexPositionNormal& operator=(const VertexPositionNormal&) = default;
+
+            VertexPositionNormal(VertexPositionNormal&&) = default;
+            VertexPositionNormal& operator=(VertexPositionNormal&&) = default;
+
+            VertexPositionNormal(XMFLOAT3 const& iposition, XMFLOAT3 const& inormal) noexcept
+                : position(iposition),
+                normal(inormal)
+            {
+            }
+
+            VertexPositionNormal(FXMVECTOR iposition, FXMVECTOR inormal) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat3(&this->normal, inormal);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT3 normal;
+
+            static constexpr unsigned int InputElementCount = 2;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position, color, and texture mapping information.
+        struct VertexPositionColorTexture
+        {
+            VertexPositionColorTexture() = default;
+
+            VertexPositionColorTexture(const VertexPositionColorTexture&) = default;
+            VertexPositionColorTexture& operator=(const VertexPositionColorTexture&) = default;
+
+            VertexPositionColorTexture(VertexPositionColorTexture&&) = default;
+            VertexPositionColorTexture& operator=(VertexPositionColorTexture&&) = default;
+
+            VertexPositionColorTexture(XMFLOAT3 const& iposition, XMFLOAT4 const& icolor, XMFLOAT2 const& itextureCoordinate) noexcept
+                : position(iposition),
+                color(icolor),
+                textureCoordinate(itextureCoordinate)
+            {
+            }
+
+            VertexPositionColorTexture(FXMVECTOR iposition, FXMVECTOR icolor, FXMVECTOR itextureCoordinate) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat4(&this->color, icolor);
+                XMStoreFloat2(&this->textureCoordinate, itextureCoordinate);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT4 color;
+            XMFLOAT2 textureCoordinate;
+
+            static constexpr unsigned int InputElementCount = 3;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position, normal vector, and color information.
+        struct VertexPositionNormalColor
+        {
+            VertexPositionNormalColor() = default;
+
+            VertexPositionNormalColor(const VertexPositionNormalColor&) = default;
+            VertexPositionNormalColor& operator=(const VertexPositionNormalColor&) = default;
+
+            VertexPositionNormalColor(VertexPositionNormalColor&&) = default;
+            VertexPositionNormalColor& operator=(VertexPositionNormalColor&&) = default;
+
+            VertexPositionNormalColor(XMFLOAT3 const& iposition, XMFLOAT3 const& inormal, XMFLOAT4 const& icolor) noexcept
+                : position(iposition),
+                normal(inormal),
+                color(icolor)
+            {
+            }
+
+            VertexPositionNormalColor(FXMVECTOR iposition, FXMVECTOR inormal, FXMVECTOR icolor) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat3(&this->normal, inormal);
+                XMStoreFloat4(&this->color, icolor);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT3 normal;
+            XMFLOAT4 color;
+
+            static constexpr unsigned int InputElementCount = 3;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position, normal vector, and texture mapping information.
+        struct VertexPositionNormalTexture
+        {
+            VertexPositionNormalTexture() = default;
+
+            VertexPositionNormalTexture(const VertexPositionNormalTexture&) = default;
+            VertexPositionNormalTexture& operator=(const VertexPositionNormalTexture&) = default;
+
+            VertexPositionNormalTexture(VertexPositionNormalTexture&&) = default;
+            VertexPositionNormalTexture& operator=(VertexPositionNormalTexture&&) = default;
+
+            VertexPositionNormalTexture(XMFLOAT3 const& iposition, XMFLOAT3 const& inormal, XMFLOAT2 const& itextureCoordinate) noexcept
+                : position(iposition),
+                normal(inormal),
+                textureCoordinate(itextureCoordinate)
+            {
+            }
+
+            VertexPositionNormalTexture(FXMVECTOR iposition, FXMVECTOR inormal, FXMVECTOR itextureCoordinate) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat3(&this->normal, inormal);
+                XMStoreFloat2(&this->textureCoordinate, itextureCoordinate);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT3 normal;
+            XMFLOAT2 textureCoordinate;
+
+            static constexpr unsigned int InputElementCount = 3;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct holding position, normal vector, color, and texture mapping information.
+        struct VertexPositionNormalColorTexture
+        {
+            VertexPositionNormalColorTexture() = default;
+
+            VertexPositionNormalColorTexture(const VertexPositionNormalColorTexture&) = default;
+            VertexPositionNormalColorTexture& operator=(const VertexPositionNormalColorTexture&) = default;
+
+            VertexPositionNormalColorTexture(VertexPositionNormalColorTexture&&) = default;
+            VertexPositionNormalColorTexture& operator=(VertexPositionNormalColorTexture&&) = default;
+
+            VertexPositionNormalColorTexture(
+                XMFLOAT3 const& iposition,
+                XMFLOAT3 const& inormal,
+                XMFLOAT4 const& icolor,
+                XMFLOAT2 const& itextureCoordinate) noexcept
+                : position(iposition),
+                normal(inormal),
+                color(icolor),
+                textureCoordinate(itextureCoordinate)
+            {
+            }
+
+            VertexPositionNormalColorTexture(FXMVECTOR iposition, FXMVECTOR inormal, FXMVECTOR icolor, CXMVECTOR itextureCoordinate) noexcept
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat3(&this->normal, inormal);
+                XMStoreFloat4(&this->color, icolor);
+                XMStoreFloat2(&this->textureCoordinate, itextureCoordinate);
+            }
+
+            XMFLOAT3 position;
+            XMFLOAT3 normal;
+            XMFLOAT4 color;
+            XMFLOAT2 textureCoordinate;
+
+            static constexpr unsigned int InputElementCount = 4;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct for Visual Studio Shader Designer (DGSL) holding position, normal,
+        // tangent, color (RGBA), and texture mapping information
+        struct VertexPositionNormalTangentColorTexture
+        {
+            VertexPositionNormalTangentColorTexture() = default;
+
+            VertexPositionNormalTangentColorTexture(const VertexPositionNormalTangentColorTexture&) = default;
+            VertexPositionNormalTangentColorTexture& operator=(const VertexPositionNormalTangentColorTexture&) = default;
+
+            VertexPositionNormalTangentColorTexture(VertexPositionNormalTangentColorTexture&&) = default;
+            VertexPositionNormalTangentColorTexture& operator=(VertexPositionNormalTangentColorTexture&&) = default;
+
+            XMFLOAT3 position;
+            XMFLOAT3 normal;
+            XMFLOAT4 tangent;
+            uint32_t color;
+            XMFLOAT2 textureCoordinate;
+
+            VertexPositionNormalTangentColorTexture(
+                XMFLOAT3 const& iposition,
+                XMFLOAT3 const& inormal,
+                XMFLOAT4 const& itangent,
+                uint32_t irgba,
+                XMFLOAT2 const& itextureCoordinate) noexcept
+                : position(iposition),
+                normal(inormal),
+                tangent(itangent),
+                color(irgba),
+                textureCoordinate(itextureCoordinate)
+            {
+            }
+
+            VertexPositionNormalTangentColorTexture(
+                FXMVECTOR iposition,
+                FXMVECTOR inormal,
+                FXMVECTOR itangent,
+                uint32_t irgba,
+                CXMVECTOR itextureCoordinate) noexcept
+                : color(irgba)
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat3(&this->normal, inormal);
+                XMStoreFloat4(&this->tangent, itangent);
+                XMStoreFloat2(&this->textureCoordinate, itextureCoordinate);
+            }
+
+            VertexPositionNormalTangentColorTexture(
+                XMFLOAT3 const& iposition,
+                XMFLOAT3 const& inormal,
+                XMFLOAT4 const& itangent,
+                XMFLOAT4 const& icolor,
+                XMFLOAT2 const& itextureCoordinate) noexcept
+                : position(iposition),
+                normal(inormal),
+                tangent(itangent),
+                color{},
+                textureCoordinate(itextureCoordinate)
+            {
+                SetColor(icolor);
+            }
+
+            VertexPositionNormalTangentColorTexture(
+                FXMVECTOR iposition,
+                FXMVECTOR inormal,
+                FXMVECTOR itangent,
+                CXMVECTOR icolor,
+                CXMVECTOR itextureCoordinate) noexcept
+                : color{}
+            {
+                XMStoreFloat3(&this->position, iposition);
+                XMStoreFloat3(&this->normal, inormal);
+                XMStoreFloat4(&this->tangent, itangent);
+                XMStoreFloat2(&this->textureCoordinate, itextureCoordinate);
+
+                SetColor(icolor);
+            }
+
+            void __cdecl SetColor(XMFLOAT4 const& icolor) noexcept { SetColor(XMLoadFloat4(&icolor)); }
+            void XM_CALLCONV SetColor(FXMVECTOR icolor) noexcept;
+
+            static constexpr unsigned int InputElementCount = 5;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+
+
+        // Vertex struct for Visual Studio Shader Designer (DGSL) holding position, normal,
+        // tangent, color (RGBA), texture mapping information, and skinning weights
+        struct VertexPositionNormalTangentColorTextureSkinning : public VertexPositionNormalTangentColorTexture
+        {
+            VertexPositionNormalTangentColorTextureSkinning() = default;
+
+            VertexPositionNormalTangentColorTextureSkinning(const VertexPositionNormalTangentColorTextureSkinning&) = default;
+            VertexPositionNormalTangentColorTextureSkinning& operator=(const VertexPositionNormalTangentColorTextureSkinning&) = default;
+
+            VertexPositionNormalTangentColorTextureSkinning(VertexPositionNormalTangentColorTextureSkinning&&) = default;
+            VertexPositionNormalTangentColorTextureSkinning& operator=(VertexPositionNormalTangentColorTextureSkinning&&) = default;
+
+            uint32_t indices;
+            uint32_t weights;
+
+            VertexPositionNormalTangentColorTextureSkinning(
+                XMFLOAT3 const& iposition,
+                XMFLOAT3 const& inormal,
+                XMFLOAT4 const& itangent,
+                uint32_t irgba,
+                XMFLOAT2 const& itextureCoordinate,
+                XMUINT4 const& iindices,
+                XMFLOAT4 const& iweights) noexcept
+                : VertexPositionNormalTangentColorTexture(iposition, inormal, itangent, irgba, itextureCoordinate),
+                indices{},
+                weights{}
+            {
+                SetBlendIndices(iindices);
+                SetBlendWeights(iweights);
+            }
+
+            VertexPositionNormalTangentColorTextureSkinning(
+                FXMVECTOR iposition,
+                FXMVECTOR inormal,
+                FXMVECTOR itangent,
+                uint32_t irgba,
+                CXMVECTOR itextureCoordinate,
+                XMUINT4 const& iindices,
+                CXMVECTOR iweights) noexcept
+                : VertexPositionNormalTangentColorTexture(iposition, inormal, itangent, irgba, itextureCoordinate),
+                indices{},
+                weights{}
+            {
+                SetBlendIndices(iindices);
+                SetBlendWeights(iweights);
+            }
+
+            VertexPositionNormalTangentColorTextureSkinning(
+                XMFLOAT3 const& iposition,
+                XMFLOAT3 const& inormal,
+                XMFLOAT4 const& itangent,
+                XMFLOAT4 const& icolor,
+                XMFLOAT2 const& itextureCoordinate,
+                XMUINT4 const& iindices,
+                XMFLOAT4 const& iweights) noexcept
+                : VertexPositionNormalTangentColorTexture(iposition, inormal, itangent, icolor, itextureCoordinate),
+                indices{},
+                weights{}
+            {
+                SetBlendIndices(iindices);
+                SetBlendWeights(iweights);
+            }
+
+            VertexPositionNormalTangentColorTextureSkinning(
+                FXMVECTOR iposition,
+                FXMVECTOR inormal,
+                FXMVECTOR itangent,
+                CXMVECTOR icolor,
+                CXMVECTOR itextureCoordinate,
+                XMUINT4 const& iindices,
+                CXMVECTOR iweights) noexcept
+                : VertexPositionNormalTangentColorTexture(iposition, inormal, itangent, icolor, itextureCoordinate),
+                indices{},
+                weights{}
+            {
+                SetBlendIndices(iindices);
+                SetBlendWeights(iweights);
+            }
+
+            void __cdecl SetBlendIndices(XMUINT4 const& iindices) noexcept;
+
+            void __cdecl SetBlendWeights(XMFLOAT4 const& iweights) noexcept { SetBlendWeights(XMLoadFloat4(&iweights)); }
+            void XM_CALLCONV SetBlendWeights(FXMVECTOR iweights) noexcept;
+
+            static constexpr unsigned int InputElementCount = 7;
+            static const D3D11_INPUT_ELEMENT_DESC InputElements[InputElementCount];
+        };
+    }
+}

enginecustom/include/Inc/WICTextureLoader.h

@@ -0,0 +1,177 @@
+//--------------------------------------------------------------------------------------
+// File: WICTextureLoader.h
+//
+// Function for loading a WIC image and creating a Direct3D runtime texture for it
+// (auto-generating mipmaps if possible)
+//
+// Note: Assumes application has already called CoInitializeEx
+//
+// Warning: CreateWICTexture* functions are not thread-safe if given a d3dContext instance for
+//          auto-gen mipmap support.
+//
+// Note these functions are useful for images created as simple 2D textures. For
+// more complex resources, DDSTextureLoader is an excellent light-weight runtime loader.
+// For a full-featured DDS file reader, writer, and texture processing pipeline see
+// the 'Texconv' sample and the 'DirectXTex' library.
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248926
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#include <cstddef>
+#include <cstdint>
+
+#ifdef _MSC_VER
+#pragma comment(lib,"uuid.lib")
+#endif
+
+
+namespace DirectX
+{
+    inline namespace DX11
+    {
+        enum WIC_LOADER_FLAGS : uint32_t
+        {
+            WIC_LOADER_DEFAULT = 0,
+            WIC_LOADER_FORCE_SRGB = 0x1,
+            WIC_LOADER_IGNORE_SRGB = 0x2,
+            WIC_LOADER_SRGB_DEFAULT = 0x4,
+            WIC_LOADER_FIT_POW2 = 0x20,
+            WIC_LOADER_MAKE_SQUARE = 0x40,
+            WIC_LOADER_FORCE_RGBA32 = 0x80,
+        };
+    }
+
+    // Standard version
+    HRESULT __cdecl CreateWICTextureFromMemory(
+        _In_ ID3D11Device* d3dDevice,
+        _In_reads_bytes_(wicDataSize) const uint8_t* wicData,
+        _In_ size_t wicDataSize,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0) noexcept;
+
+    HRESULT __cdecl CreateWICTextureFromFile(
+        _In_ ID3D11Device* d3dDevice,
+        _In_z_ const wchar_t* szFileName,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0) noexcept;
+
+    // Standard version with optional auto-gen mipmap support
+    HRESULT __cdecl CreateWICTextureFromMemory(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_reads_bytes_(wicDataSize) const uint8_t* wicData,
+        _In_ size_t wicDataSize,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0) noexcept;
+
+    HRESULT __cdecl CreateWICTextureFromFile(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_z_ const wchar_t* szFileName,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _In_ size_t maxsize = 0) noexcept;
+
+    // Extended version
+    HRESULT __cdecl CreateWICTextureFromMemoryEx(
+        _In_ ID3D11Device* d3dDevice,
+        _In_reads_bytes_(wicDataSize) const uint8_t* wicData,
+        _In_ size_t wicDataSize,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ WIC_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept;
+
+    HRESULT __cdecl CreateWICTextureFromFileEx(
+        _In_ ID3D11Device* d3dDevice,
+        _In_z_ const wchar_t* szFileName,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ WIC_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept;
+
+    // Extended version with optional auto-gen mipmap support
+    HRESULT __cdecl CreateWICTextureFromMemoryEx(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_reads_bytes_(wicDataSize) const uint8_t* wicData,
+        _In_ size_t wicDataSize,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ WIC_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept;
+
+    HRESULT __cdecl CreateWICTextureFromFileEx(
+    #if defined(_XBOX_ONE) && defined(_TITLE)
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_opt_ ID3D11DeviceContextX* d3dContext,
+    #else
+        _In_ ID3D11Device* d3dDevice,
+        _In_opt_ ID3D11DeviceContext* d3dContext,
+    #endif
+        _In_z_ const wchar_t* szFileName,
+        _In_ size_t maxsize,
+        _In_ D3D11_USAGE usage,
+        _In_ unsigned int bindFlags,
+        _In_ unsigned int cpuAccessFlags,
+        _In_ unsigned int miscFlags,
+        _In_ WIC_LOADER_FLAGS loadFlags,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView) noexcept;
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#endif
+
+    inline namespace DX11
+    {
+        DEFINE_ENUM_FLAG_OPERATORS(WIC_LOADER_FLAGS);
+    }
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}

enginecustom/include/Inc/XboxDDSTextureLoader.h

@@ -0,0 +1,67 @@
+//--------------------------------------------------------------------------------------
+// File: XboxDDSTextureLoader.h
+//
+// Functions for loading a DDS texture using the XBOX extended header and creating a
+// Direct3D11.X runtime resource for it via the CreatePlacement APIs
+//
+// Note these functions will not load standard DDS files. Use the DDSTextureLoader
+// module in the DirectXTex package or as part of the DirectXTK library to load
+// these files which use standard Direct3D resource creation APIs.
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248926
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#if !defined(_XBOX_ONE) || !defined(_TITLE)
+#error This module only supports Xbox One exclusive apps
+#endif
+
+#include <d3d11_x.h>
+
+#include <cstddef>
+#include <cstdint>
+
+#ifndef DDS_ALPHA_MODE_DEFINED
+#define DDS_ALPHA_MODE_DEFINED
+namespace DirectX
+{
+    enum DDS_ALPHA_MODE : uint32_t
+    {
+        DDS_ALPHA_MODE_UNKNOWN = 0,
+        DDS_ALPHA_MODE_STRAIGHT = 1,
+        DDS_ALPHA_MODE_PREMULTIPLIED = 2,
+        DDS_ALPHA_MODE_OPAQUE = 3,
+        DDS_ALPHA_MODE_CUSTOM = 4,
+    };
+}
+#endif
+
+namespace Xbox
+{
+    using DirectX::DDS_ALPHA_MODE;
+
+    HRESULT __cdecl CreateDDSTextureFromMemory(
+        _In_ ID3D11DeviceX* d3dDevice,
+        _In_reads_bytes_(ddsDataSize) const uint8_t* ddsData,
+        _In_ size_t ddsDataSize,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _Outptr_ void** grfxMemory,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr,
+        _In_ bool forceSRGB = false) noexcept;
+
+    HRESULT __cdecl CreateDDSTextureFromFile( _In_ ID3D11DeviceX* d3dDevice,
+        _In_z_ const wchar_t* szFileName,
+        _Outptr_opt_ ID3D11Resource** texture,
+        _Outptr_opt_ ID3D11ShaderResourceView** textureView,
+        _Outptr_ void** grfxMemory,
+        _Out_opt_ DDS_ALPHA_MODE* alphaMode = nullptr,
+        _In_ bool forceSRGB = false) noexcept;
+
+    void FreeDDSTextureMemory( _In_opt_ void* grfxMemory ) noexcept;
+}

enginecustom/include/Src/CMO.h

@@ -0,0 +1,181 @@
+//--------------------------------------------------------------------------------------
+// File: CMO.h
+//
+// .CMO files are built by Visual Studio's MeshContentTask and an example renderer was
+// provided in the VS Direct3D Starter Kit
+// https://devblogs.microsoft.com/cppblog/developing-an-app-with-the-visual-studio-3d-starter-kit-part-1-of-3/
+// https://devblogs.microsoft.com/cppblog/developing-an-app-with-the-visual-studio-3d-starter-kit-part-2-of-3/
+// https://devblogs.microsoft.com/cppblog/developing-an-app-with-the-visual-studio-3d-starter-kit-part-3-of-3/
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <DirectXMath.h>
+
+#include <cstdint>
+
+
+namespace VSD3DStarter
+{
+    // .CMO files
+
+    // UINT - Mesh count
+    // { [Mesh count]
+    //      UINT - Length of name
+    //      wchar_t[] - Name of mesh (if length > 0)
+    //      UINT - Material count
+    //      { [Material count]
+    //          UINT - Length of material name
+    //          wchar_t[] - Name of material (if length > 0)
+    //          Material structure
+    //          UINT - Length of pixel shader name
+    //          wchar_t[] - Name of pixel shader (if length > 0)
+    //          { [8]
+    //              UINT - Length of texture name
+    //              wchar_t[] - Name of texture (if length > 0)
+    //          }
+    //      }
+    //      BYTE - 1 if there is skeletal animation data present
+    //      UINT - SubMesh count
+    //      { [SubMesh count]
+    //          SubMesh structure
+    //      }
+    //      UINT - IB Count
+    //      { [IB Count]
+    //          UINT - Number of USHORTs in IB
+    //          USHORT[] - Array of indices
+    //      }
+    //      UINT - VB Count
+    //      { [VB Count]
+    //          UINT - Number of verts in VB
+    //          Vertex[] - Array of vertices
+    //      }
+    //      UINT - Skinning VB Count
+    //      { [Skinning VB Count]
+    //          UINT - Number of verts in Skinning VB
+    //          SkinningVertex[] - Array of skinning verts
+    //      }
+    //      MeshExtents structure
+    //      [If skeleton animation data is not present, file ends here]
+    //      UINT - Bone count
+    //      { [Bone count]
+    //          UINT - Length of bone name
+    //          wchar_t[] - Bone name (if length > 0)
+    //          Bone structure
+    //      }
+    //      UINT - Animation clip count
+    //      { [Animation clip count]
+    //          UINT - Length of clip name
+    //          wchar_t[] - Clip name (if length > 0)
+    //          float - Start time
+    //          float - End time
+    //          UINT - Keyframe count
+    //          { [Keyframe count]
+    //              Keyframe structure
+    //          }
+    //      }
+    // }
+
+#pragma pack(push,1)
+
+    struct Material
+    {
+        DirectX::XMFLOAT4   Ambient;
+        DirectX::XMFLOAT4   Diffuse;
+        DirectX::XMFLOAT4   Specular;
+        float               SpecularPower;
+        DirectX::XMFLOAT4   Emissive;
+        DirectX::XMFLOAT4X4 UVTransform;
+    };
+
+    constexpr uint32_t MAX_TEXTURE = 8;
+
+    struct SubMesh
+    {
+        uint32_t MaterialIndex;
+        uint32_t IndexBufferIndex;
+        uint32_t VertexBufferIndex;
+        uint32_t StartIndex;
+        uint32_t PrimCount;
+    };
+
+    constexpr uint32_t NUM_BONE_INFLUENCES = 4;
+
+    // Vertex struct for Visual Studio Shader Designer (DGSL) holding position, normal,
+    // tangent, color (RGBA), and texture mapping information
+    struct VertexPositionNormalTangentColorTexture
+    {
+        DirectX::XMFLOAT3 position;
+        DirectX::XMFLOAT3 normal;
+        DirectX::XMFLOAT4 tangent;
+        uint32_t color;
+        DirectX::XMFLOAT2 textureCoordinate;
+    };
+
+    struct SkinningVertex
+    {
+        uint32_t boneIndex[NUM_BONE_INFLUENCES];
+        float boneWeight[NUM_BONE_INFLUENCES];
+    };
+
+    struct MeshExtents
+    {
+        float CenterX, CenterY, CenterZ;
+        float Radius;
+
+        float MinX, MinY, MinZ;
+        float MaxX, MaxY, MaxZ;
+    };
+
+    struct Bone
+    {
+        int32_t ParentIndex;
+        DirectX::XMFLOAT4X4 InvBindPos;
+        DirectX::XMFLOAT4X4 BindPos;
+        DirectX::XMFLOAT4X4 LocalTransform;
+    };
+
+    struct Clip
+    {
+        float StartTime;
+        float EndTime;
+        uint32_t keys;
+    };
+
+    struct Keyframe
+    {
+        uint32_t BoneIndex;
+        float Time;
+        DirectX::XMFLOAT4X4 Transform;
+    };
+
+#pragma pack(pop)
+
+    const Material s_defMaterial =
+    {
+        { 0.2f, 0.2f, 0.2f, 1.f },
+        { 0.8f, 0.8f, 0.8f, 1.f },
+        { 0.0f, 0.0f, 0.0f, 1.f },
+        1.f,
+        { 0.0f, 0.0f, 0.0f, 1.0f },
+        { 1.f, 0.f, 0.f, 0.f,
+          0.f, 1.f, 0.f, 0.f,
+          0.f, 0.f, 1.f, 0.f,
+          0.f, 0.f, 0.f, 1.f },
+    };
+} // namespace
+
+static_assert(sizeof(VSD3DStarter::Material) == 132, "CMO Mesh structure size incorrect");
+static_assert(sizeof(VSD3DStarter::SubMesh) == 20, "CMO Mesh structure size incorrect");
+static_assert(sizeof(VSD3DStarter::VertexPositionNormalTangentColorTexture) == 52, "CMO Mesh structure size incorrect");
+static_assert(sizeof(VSD3DStarter::SkinningVertex) == 32, "CMO Mesh structure size incorrect");
+static_assert(sizeof(VSD3DStarter::MeshExtents) == 40, "CMO Mesh structure size incorrect");
+static_assert(sizeof(VSD3DStarter::Bone) == 196, "CMO Mesh structure size incorrect");
+static_assert(sizeof(VSD3DStarter::Clip) == 12, "CMO Mesh structure size incorrect");
+static_assert(sizeof(VSD3DStarter::Keyframe) == 72, "CMO Mesh structure size incorrect");

enginecustom/include/Src/DDS.h

@@ -0,0 +1,330 @@
+//--------------------------------------------------------------------------------------
+// DDS.h
+//
+// This header defines constants and structures that are useful when parsing
+// DDS files.  DDS files were originally designed to use several structures
+// and constants that are native to DirectDraw and are defined in ddraw.h,
+// such as DDSURFACEDESC2 and DDSCAPS2.  This file defines similar
+// (compatible) constants and structures so that one can use DDS files
+// without needing to include ddraw.h.
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248926
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <cstdint>
+
+namespace DirectX
+{
+
+#pragma pack(push,1)
+
+    constexpr uint32_t DDS_MAGIC = 0x20534444; // "DDS "
+
+    struct DDS_PIXELFORMAT
+    {
+        uint32_t    size;
+        uint32_t    flags;
+        uint32_t    fourCC;
+        uint32_t    RGBBitCount;
+        uint32_t    RBitMask;
+        uint32_t    GBitMask;
+        uint32_t    BBitMask;
+        uint32_t    ABitMask;
+    };
+
+#define DDS_FOURCC        0x00000004  // DDPF_FOURCC
+#define DDS_RGB           0x00000040  // DDPF_RGB
+#define DDS_RGBA          0x00000041  // DDPF_RGB | DDPF_ALPHAPIXELS
+#define DDS_LUMINANCE     0x00020000  // DDPF_LUMINANCE
+#define DDS_LUMINANCEA    0x00020001  // DDPF_LUMINANCE | DDPF_ALPHAPIXELS
+#define DDS_ALPHAPIXELS   0x00000001  // DDPF_ALPHAPIXELS
+#define DDS_ALPHA         0x00000002  // DDPF_ALPHA
+#define DDS_PAL8          0x00000020  // DDPF_PALETTEINDEXED8
+#define DDS_PAL8A         0x00000021  // DDPF_PALETTEINDEXED8 | DDPF_ALPHAPIXELS
+#define DDS_BUMPLUMINANCE 0x00040000  // DDPF_BUMPLUMINANCE
+#define DDS_BUMPDUDV      0x00080000  // DDPF_BUMPDUDV
+#define DDS_BUMPDUDVA     0x00080001  // DDPF_BUMPDUDV | DDPF_ALPHAPIXELS
+
+#ifndef MAKEFOURCC
+#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
+                (static_cast<uint32_t>(static_cast<uint8_t>(ch0)) \
+                | (static_cast<uint32_t>(static_cast<uint8_t>(ch1)) << 8) \
+                | (static_cast<uint32_t>(static_cast<uint8_t>(ch2)) << 16) \
+                | (static_cast<uint32_t>(static_cast<uint8_t>(ch3)) << 24))
+#endif /* MAKEFOURCC */
+
+#ifndef DDSGLOBALCONST
+#if defined(__GNUC__) && !defined(__MINGW32__)
+#define DDSGLOBALCONST extern const __attribute__((weak))
+#else
+#define DDSGLOBALCONST extern const __declspec(selectany)
+#endif
+#endif /* DDSGLOBALCONST */
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT1 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT2 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','2'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT3 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','3'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT4 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','4'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT5 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','5'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_UNORM =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','U'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_SNORM =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','S'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_UNORM =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','U'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_SNORM =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','S'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8_B8G8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('R','G','B','G'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G8R8_G8B8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('G','R','G','B'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_YUY2 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('Y','U','Y','2'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_UYVY =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('U','Y','V','Y'), 0, 0, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R8G8B8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8R8G8B8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB,  0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8B8G8R8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8B8G8R8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB,  0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G16R16 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB,  0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R5G6B5 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xf800, 0x07e0, 0x001f, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A1R5G5B5 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x7c00, 0x03e0, 0x001f, 0x8000 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X1R5G5B5 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x7c00, 0x03e0, 0x001f, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4R4G4B4 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x0f00, 0x00f0, 0x000f, 0xf000 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X4R4G4B4 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x0f00, 0x00f0, 0x000f, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8B8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R3G3B2 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00e0, 0x001c, 0x0003, 0xff00 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R3G3B2 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xe0, 0x1c, 0x03, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4L4 =
+    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x0f, 0, 0, 0xf0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 8, 0xff, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16 =
+    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 16, 0xffff, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 16, 0x00ff, 0, 0, 0xff00 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_ALT =
+    { sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x00ff, 0, 0, 0xff00 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8_NVTT1 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xff, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16_NVTT1 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xffff, 0, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_NVTT1 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00ff, 0, 0, 0xff00 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_ALPHA, 0, 8, 0, 0, 0, 0xff };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V8U8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 16, 0x00ff, 0xff00, 0, 0 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_Q8W8V8U8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
+
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V16U16 =
+    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
+
+// D3DFMT_A2R10G10B10/D3DFMT_A2B10G10R10 should be written using DX10 extension to avoid D3DX 10:10:10:2 reversal issue
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2R10G10B10 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000 };
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 =
+    { sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 };
+
+// The following legacy Direct3D 9 formats use 'mixed' signed & unsigned channels so requires special handling
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2W10V10U10 =
+    { sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDVA, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 };
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L6V5U5 =
+    { sizeof(DDS_PIXELFORMAT), DDS_BUMPLUMINANCE, 0, 16, 0x001f, 0x03e0, 0xfc00, 0 };
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8L8V8U8 =
+    { sizeof(DDS_PIXELFORMAT), DDS_BUMPLUMINANCE, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
+
+// This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat)
+    DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 =
+    { sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','1','0'), 0, 0, 0, 0, 0 };
+
+#define DDS_HEADER_FLAGS_TEXTURE        0x00001007  // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
+#define DDS_HEADER_FLAGS_MIPMAP         0x00020000  // DDSD_MIPMAPCOUNT
+#define DDS_HEADER_FLAGS_VOLUME         0x00800000  // DDSD_DEPTH
+#define DDS_HEADER_FLAGS_PITCH          0x00000008  // DDSD_PITCH
+#define DDS_HEADER_FLAGS_LINEARSIZE     0x00080000  // DDSD_LINEARSIZE
+
+#define DDS_HEIGHT 0x00000002 // DDSD_HEIGHT
+#define DDS_WIDTH  0x00000004 // DDSD_WIDTH
+
+#define DDS_SURFACE_FLAGS_TEXTURE 0x00001000 // DDSCAPS_TEXTURE
+#define DDS_SURFACE_FLAGS_MIPMAP  0x00400008 // DDSCAPS_COMPLEX | DDSCAPS_MIPMAP
+#define DDS_SURFACE_FLAGS_CUBEMAP 0x00000008 // DDSCAPS_COMPLEX
+
+#define DDS_CUBEMAP_POSITIVEX 0x00000600 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEX
+#define DDS_CUBEMAP_NEGATIVEX 0x00000a00 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEX
+#define DDS_CUBEMAP_POSITIVEY 0x00001200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEY
+#define DDS_CUBEMAP_NEGATIVEY 0x00002200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEY
+#define DDS_CUBEMAP_POSITIVEZ 0x00004200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_POSITIVEZ
+#define DDS_CUBEMAP_NEGATIVEZ 0x00008200 // DDSCAPS2_CUBEMAP | DDSCAPS2_CUBEMAP_NEGATIVEZ
+
+#define DDS_CUBEMAP_ALLFACES ( DDS_CUBEMAP_POSITIVEX | DDS_CUBEMAP_NEGATIVEX |\
+                               DDS_CUBEMAP_POSITIVEY | DDS_CUBEMAP_NEGATIVEY |\
+                               DDS_CUBEMAP_POSITIVEZ | DDS_CUBEMAP_NEGATIVEZ )
+
+#define DDS_CUBEMAP 0x00000200 // DDSCAPS2_CUBEMAP
+
+#define DDS_FLAGS_VOLUME 0x00200000 // DDSCAPS2_VOLUME
+
+// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
+    enum DDS_RESOURCE_DIMENSION : uint32_t
+    {
+        DDS_DIMENSION_TEXTURE1D = 2,
+        DDS_DIMENSION_TEXTURE2D = 3,
+        DDS_DIMENSION_TEXTURE3D = 4,
+    };
+
+    // Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
+    enum DDS_RESOURCE_MISC_FLAG : uint32_t
+    {
+        DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
+    };
+
+    enum DDS_MISC_FLAGS2 : uint32_t
+    {
+        DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x7L,
+    };
+
+#ifndef DDS_ALPHA_MODE_DEFINED
+#define DDS_ALPHA_MODE_DEFINED
+    enum DDS_ALPHA_MODE : uint32_t
+    {
+        DDS_ALPHA_MODE_UNKNOWN = 0,
+        DDS_ALPHA_MODE_STRAIGHT = 1,
+        DDS_ALPHA_MODE_PREMULTIPLIED = 2,
+        DDS_ALPHA_MODE_OPAQUE = 3,
+        DDS_ALPHA_MODE_CUSTOM = 4,
+    };
+#endif
+
+    struct DDS_HEADER
+    {
+        uint32_t        size;
+        uint32_t        flags;
+        uint32_t        height;
+        uint32_t        width;
+        uint32_t        pitchOrLinearSize;
+        uint32_t        depth; // only if DDS_HEADER_FLAGS_VOLUME is set in flags
+        uint32_t        mipMapCount;
+        uint32_t        reserved1[11];
+        DDS_PIXELFORMAT ddspf;
+        uint32_t        caps;
+        uint32_t        caps2;
+        uint32_t        caps3;
+        uint32_t        caps4;
+        uint32_t        reserved2;
+    };
+
+    struct DDS_HEADER_DXT10
+    {
+        DXGI_FORMAT     dxgiFormat;
+        uint32_t        resourceDimension;
+        uint32_t        miscFlag; // see D3D11_RESOURCE_MISC_FLAG
+        uint32_t        arraySize;
+        uint32_t        miscFlags2; // see DDS_MISC_FLAGS2
+    };
+
+#pragma pack(pop)
+
+    static_assert(sizeof(DDS_PIXELFORMAT) == 32, "DDS pixel format size mismatch");
+    static_assert(sizeof(DDS_HEADER) == 124, "DDS Header size mismatch");
+    static_assert(sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch");
+
+    constexpr size_t DDS_MIN_HEADER_SIZE = sizeof(uint32_t) + sizeof(DDS_HEADER);
+    constexpr size_t DDS_DX10_HEADER_SIZE = sizeof(uint32_t) + sizeof(DDS_HEADER) + sizeof(DDS_HEADER_DXT10);
+    static_assert(DDS_DX10_HEADER_SIZE > DDS_MIN_HEADER_SIZE, "DDS DX10 Header should be larger than standard header");
+
+} // namespace
+
+namespace Xbox
+{
+    DDSGLOBALCONST DirectX::DDS_PIXELFORMAT DDSPF_XBOX =
+    { sizeof(DirectX::DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('X','B','O','X'), 0, 0, 0, 0, 0 };
+
+#pragma pack(push,1)
+
+    struct DDS_HEADER_XBOX
+        // Must match structure in XboxDDSTextureLoader module
+    {
+        DXGI_FORMAT dxgiFormat;
+        uint32_t    resourceDimension;
+        uint32_t    miscFlag; // see DDS_RESOURCE_MISC_FLAG
+        uint32_t    arraySize;
+        uint32_t    miscFlags2; // see DDS_MISC_FLAGS2
+        uint32_t    tileMode; // see XG_TILE_MODE / XG_SWIZZLE_MODE
+        uint32_t    baseAlignment;
+        uint32_t    dataSize;
+        uint32_t    xdkVer; // matching _XDK_VER / _GXDK_VER
+    };
+
+#pragma pack(pop)
+
+    static_assert(sizeof(DDS_HEADER_XBOX) == 36, "DDS XBOX Header size mismatch");
+    static_assert(sizeof(DDS_HEADER_XBOX) > sizeof(DirectX::DDS_HEADER_DXT10), "DDS XBOX Header should be larger than DX10 header");
+
+    constexpr size_t DDS_XBOX_HEADER_SIZE = sizeof(uint32_t) + sizeof(DirectX::DDS_HEADER) + sizeof(DDS_HEADER_XBOX);
+
+    constexpr uint32_t XBOX_TILEMODE_SCARLETT = 0x1000000;
+} // namespace

enginecustom/include/Src/DirectXHelpers.cpp

@@ -0,0 +1,54 @@
+//--------------------------------------------------------------------------------------
+// File: DirectXHelpers.cpp
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#include "pch.h"
+#include "DirectXHelpers.h"
+#include "Effects.h"
+#include "PlatformHelpers.h"
+
+
+using namespace DirectX;
+
+_Use_decl_annotations_
+HRESULT DirectX::CreateInputLayoutFromEffect(
+    ID3D11Device* device,
+    IEffect* effect,
+    const D3D11_INPUT_ELEMENT_DESC* desc,
+    size_t count,
+    ID3D11InputLayout** pInputLayout) noexcept
+{
+    if (!pInputLayout)
+        return E_INVALIDARG;
+
+    *pInputLayout = nullptr;
+
+    if (!device || !effect || !desc || !count)
+        return E_INVALIDARG;
+
+    void const* shaderByteCode;
+    size_t byteCodeLength;
+
+    try
+    {
+        effect->GetVertexShaderBytecode(&shaderByteCode, &byteCodeLength);
+    }
+    catch (com_exception e)
+    {
+        return e.get_result();
+    }
+    catch (...)
+    {
+        return E_FAIL;
+    }
+
+    return device->CreateInputLayout(
+        desc, static_cast<UINT>(count),
+        shaderByteCode, byteCodeLength,
+        pInputLayout);
+}

enginecustom/include/Src/PlatformHelpers.h

@@ -0,0 +1,94 @@
+//--------------------------------------------------------------------------------------
+// File: PlatformHelpers.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4324)
+#endif
+
+#include <exception>
+#include <memory>
+
+#ifndef MAKEFOURCC
+#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
+                (static_cast<uint32_t>(static_cast<uint8_t>(ch0)) \
+                | (static_cast<uint32_t>(static_cast<uint8_t>(ch1)) << 8) \
+                | (static_cast<uint32_t>(static_cast<uint8_t>(ch2)) << 16) \
+                | (static_cast<uint32_t>(static_cast<uint8_t>(ch3)) << 24))
+#endif /* defined(MAKEFOURCC) */
+
+// See https://walbourn.github.io/modern-c++-bitmask-types/
+#ifndef ENUM_FLAGS_CONSTEXPR
+#if defined(NTDDI_WIN10_RS1) && !defined(__MINGW32__)
+#define ENUM_FLAGS_CONSTEXPR constexpr
+#else
+#define ENUM_FLAGS_CONSTEXPR const
+#endif
+#endif
+
+namespace DirectX
+{
+    // Helper class for COM exceptions
+    class com_exception : public std::exception
+    {
+    public:
+        com_exception(HRESULT hr) noexcept : result(hr) {}
+
+        const char* what() const noexcept override
+        {
+            static char s_str[64] = {};
+            sprintf_s(s_str, "Failure with HRESULT of %08X", static_cast<unsigned int>(result));
+            return s_str;
+        }
+
+        HRESULT get_result() const noexcept { return result; }
+
+    private:
+        HRESULT result;
+    };
+
+    // Helper utility converts D3D API failures into exceptions.
+    inline void ThrowIfFailed(HRESULT hr) noexcept(false)
+    {
+        if (FAILED(hr))
+        {
+            throw com_exception(hr);
+        }
+    }
+
+
+    // Helper for output debug tracing
+    inline void DebugTrace(_In_z_ _Printf_format_string_ const char* format, ...) noexcept
+    {
+    #ifdef _DEBUG
+        va_list args;
+        va_start(args, format);
+
+        char buff[1024] = {};
+        vsprintf_s(buff, format, args);
+        OutputDebugStringA(buff);
+        va_end(args);
+    #else
+        UNREFERENCED_PARAMETER(format);
+    #endif
+    }
+
+    // Helper smart-pointers
+#if (_WIN32_WINNT >= _WIN32_WINNT_WIN10) || (defined(_XBOX_ONE) && defined(_TITLE)) || !defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP)
+    struct virtual_deleter { void operator()(void* p) noexcept { if (p) VirtualFree(p, 0, MEM_RELEASE); } };
+#endif
+
+    struct handle_closer { void operator()(HANDLE h) noexcept { if (h) CloseHandle(h); } };
+
+    using ScopedHandle = std::unique_ptr<void, handle_closer>;
+
+    inline HANDLE safe_handle(HANDLE h) noexcept { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }
+}

enginecustom/include/Src/SimpleMath.cpp

@@ -0,0 +1,247 @@
+//-------------------------------------------------------------------------------------
+// SimpleMath.cpp -- Simplified C++ Math wrapper for DirectXMath
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+// http://go.microsoft.com/fwlink/?LinkID=615561
+//-------------------------------------------------------------------------------------
+
+#include "pch.h"
+#include "SimpleMath.h"
+
+/****************************************************************************
+ *
+ * Constants
+ *
+ ****************************************************************************/
+
+namespace DirectX
+{
+    namespace SimpleMath
+    {
+        const Vector2 Vector2::Zero = { 0.f, 0.f };
+        const Vector2 Vector2::One = { 1.f, 1.f };
+        const Vector2 Vector2::UnitX = { 1.f, 0.f };
+        const Vector2 Vector2::UnitY = { 0.f, 1.f };
+
+        const Vector3 Vector3::Zero = { 0.f, 0.f, 0.f };
+        const Vector3 Vector3::One = { 1.f, 1.f, 1.f };
+        const Vector3 Vector3::UnitX = { 1.f, 0.f, 0.f };
+        const Vector3 Vector3::UnitY = { 0.f, 1.f, 0.f };
+        const Vector3 Vector3::UnitZ = { 0.f, 0.f, 1.f };
+        const Vector3 Vector3::Up = { 0.f, 1.f, 0.f };
+        const Vector3 Vector3::Down = { 0.f, -1.f, 0.f };
+        const Vector3 Vector3::Right = { 1.f, 0.f, 0.f };
+        const Vector3 Vector3::Left = { -1.f, 0.f, 0.f };
+        const Vector3 Vector3::Forward = { 0.f, 0.f, -1.f };
+        const Vector3 Vector3::Backward = { 0.f, 0.f, 1.f };
+
+        const Vector4 Vector4::Zero = { 0.f, 0.f, 0.f, 0.f };
+        const Vector4 Vector4::One = { 1.f, 1.f, 1.f, 1.f };
+        const Vector4 Vector4::UnitX = { 1.f, 0.f, 0.f, 0.f };
+        const Vector4 Vector4::UnitY = { 0.f, 1.f, 0.f, 0.f };
+        const Vector4 Vector4::UnitZ = { 0.f, 0.f, 1.f, 0.f };
+        const Vector4 Vector4::UnitW = { 0.f, 0.f, 0.f, 1.f };
+
+        const Matrix Matrix::Identity = { 1.f, 0.f, 0.f, 0.f,
+                                          0.f, 1.f, 0.f, 0.f,
+                                          0.f, 0.f, 1.f, 0.f,
+                                          0.f, 0.f, 0.f, 1.f };
+
+        const Quaternion Quaternion::Identity = { 0.f, 0.f, 0.f, 1.f };
+    }
+}
+
+using namespace DirectX;
+using namespace DirectX::SimpleMath;
+
+/****************************************************************************
+ *
+ * Quaternion
+ *
+ ****************************************************************************/
+
+void Quaternion::RotateTowards(const Quaternion& target, float maxAngle, Quaternion& result) const noexcept
+{
+    const XMVECTOR T = XMLoadFloat4(this);
+
+    // We can use the conjugate here instead of inverse assuming q1 & q2 are normalized.
+    const XMVECTOR R = XMQuaternionMultiply(XMQuaternionConjugate(T), target);
+
+    const float rs = XMVectorGetW(R);
+    const XMVECTOR L = XMVector3Length(R);
+    const float angle = 2.f * atan2f(XMVectorGetX(L), rs);
+    if (angle > maxAngle)
+    {
+        const XMVECTOR delta = XMQuaternionRotationAxis(R, maxAngle);
+        const XMVECTOR Q = XMQuaternionMultiply(delta, T);
+        XMStoreFloat4(&result, Q);
+    }
+    else
+    {
+        // Don't overshoot.
+        result = target;
+    }
+}
+
+void Quaternion::FromToRotation(const Vector3& fromDir, const Vector3& toDir, Quaternion& result) noexcept
+{
+    // Melax, "The Shortest Arc Quaternion", Game Programming Gems, Charles River Media (2000).
+
+    const XMVECTOR F = XMVector3Normalize(fromDir);
+    const XMVECTOR T = XMVector3Normalize(toDir);
+
+    const float dot = XMVectorGetX(XMVector3Dot(F, T));
+    if (dot >= 1.f)
+    {
+        result = Identity;
+    }
+    else if (dot <= -1.f)
+    {
+        XMVECTOR axis = XMVector3Cross(F, Vector3::Right);
+        if (XMVector3NearEqual(XMVector3LengthSq(axis), g_XMZero, g_XMEpsilon))
+        {
+            axis = XMVector3Cross(F, Vector3::Up);
+        }
+
+        const XMVECTOR Q = XMQuaternionRotationAxis(axis, XM_PI);
+        XMStoreFloat4(&result, Q);
+    }
+    else
+    {
+        const XMVECTOR C = XMVector3Cross(F, T);
+        XMStoreFloat4(&result, C);
+
+        const float s = sqrtf((1.f + dot) * 2.f);
+        result.x /= s;
+        result.y /= s;
+        result.z /= s;
+        result.w = s * 0.5f;
+    }
+}
+
+void Quaternion::LookRotation(const Vector3& forward, const Vector3& up, Quaternion& result) noexcept
+{
+    Quaternion q1;
+    FromToRotation(Vector3::Forward, forward, q1);
+
+    const XMVECTOR C = XMVector3Cross(forward, up);
+    if (XMVector3NearEqual(XMVector3LengthSq(C), g_XMZero, g_XMEpsilon))
+    {
+        // forward and up are co-linear
+        result = q1;
+        return;
+    }
+
+    const XMVECTOR U = XMQuaternionMultiply(q1, Vector3::Up);
+
+    Quaternion q2;
+    FromToRotation(U, up, q2);
+
+    XMStoreFloat4(&result, XMQuaternionMultiply(q2, q1));
+}
+
+
+ /****************************************************************************
+ *
+ * Viewport
+ *
+ ****************************************************************************/
+
+#if defined(__d3d11_h__) || defined(__d3d11_x_h__)
+static_assert(sizeof(DirectX::SimpleMath::Viewport) == sizeof(D3D11_VIEWPORT), "Size mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, x) == offsetof(D3D11_VIEWPORT, TopLeftX), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, y) == offsetof(D3D11_VIEWPORT, TopLeftY), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, width) == offsetof(D3D11_VIEWPORT, Width), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, height) == offsetof(D3D11_VIEWPORT, Height), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, minDepth) == offsetof(D3D11_VIEWPORT, MinDepth), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, maxDepth) == offsetof(D3D11_VIEWPORT, MaxDepth), "Layout mismatch");
+#endif
+
+#if defined(__d3d12_h__) || defined(__d3d12_x_h__) || defined(__XBOX_D3D12_X__)
+static_assert(sizeof(DirectX::SimpleMath::Viewport) == sizeof(D3D12_VIEWPORT), "Size mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, x) == offsetof(D3D12_VIEWPORT, TopLeftX), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, y) == offsetof(D3D12_VIEWPORT, TopLeftY), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, width) == offsetof(D3D12_VIEWPORT, Width), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, height) == offsetof(D3D12_VIEWPORT, Height), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, minDepth) == offsetof(D3D12_VIEWPORT, MinDepth), "Layout mismatch");
+static_assert(offsetof(DirectX::SimpleMath::Viewport, maxDepth) == offsetof(D3D12_VIEWPORT, MaxDepth), "Layout mismatch");
+#endif
+
+#if defined(__dxgi1_2_h__) || defined(__d3d11_x_h__) || defined(__d3d12_x_h__) || defined(__XBOX_D3D12_X__)
+RECT Viewport::ComputeDisplayArea(DXGI_SCALING scaling, UINT backBufferWidth, UINT backBufferHeight, int outputWidth, int outputHeight) noexcept
+{
+    RECT rct = {};
+
+    switch (int(scaling))
+    {
+    case DXGI_SCALING_STRETCH:
+        // Output fills the entire window area
+        rct.top = 0;
+        rct.left = 0;
+        rct.right = outputWidth;
+        rct.bottom = outputHeight;
+        break;
+
+    case 2 /*DXGI_SCALING_ASPECT_RATIO_STRETCH*/:
+        // Output fills the window area but respects the original aspect ratio, using pillar boxing or letter boxing as required
+        // Note: This scaling option is not supported for legacy Win32 windows swap chains
+        {
+            assert(backBufferHeight > 0);
+            const float aspectRatio = float(backBufferWidth) / float(backBufferHeight);
+
+            // Horizontal fill
+            float scaledWidth = float(outputWidth);
+            float scaledHeight = float(outputWidth) / aspectRatio;
+            if (scaledHeight >= float(outputHeight))
+            {
+                // Do vertical fill
+                scaledWidth = float(outputHeight) * aspectRatio;
+                scaledHeight = float(outputHeight);
+            }
+
+            const float offsetX = (float(outputWidth) - scaledWidth) * 0.5f;
+            const float offsetY = (float(outputHeight) - scaledHeight) * 0.5f;
+
+            rct.left = static_cast<LONG>(offsetX);
+            rct.top = static_cast<LONG>(offsetY);
+            rct.right = static_cast<LONG>(offsetX + scaledWidth);
+            rct.bottom = static_cast<LONG>(offsetY + scaledHeight);
+
+            // Clip to display window
+            rct.left = std::max<LONG>(0, rct.left);
+            rct.top = std::max<LONG>(0, rct.top);
+            rct.right = std::min<LONG>(outputWidth, rct.right);
+            rct.bottom = std::min<LONG>(outputHeight, rct.bottom);
+        }
+        break;
+
+    case DXGI_SCALING_NONE:
+    default:
+        // Output is displayed in the upper left corner of the window area
+        rct.top = 0;
+        rct.left = 0;
+        rct.right = std::min<LONG>(static_cast<LONG>(backBufferWidth), outputWidth);
+        rct.bottom = std::min<LONG>(static_cast<LONG>(backBufferHeight), outputHeight);
+        break;
+    }
+
+    return rct;
+}
+#endif
+
+RECT Viewport::ComputeTitleSafeArea(UINT backBufferWidth, UINT backBufferHeight) noexcept
+{
+    const float safew = (float(backBufferWidth) + 19.f) / 20.f;
+    const float safeh = (float(backBufferHeight) + 19.f) / 20.f;
+
+    RECT rct;
+    rct.left = static_cast<LONG>(safew);
+    rct.top = static_cast<LONG>(safeh);
+    rct.right = static_cast<LONG>(float(backBufferWidth) - safew + 0.5f);
+    rct.bottom = static_cast<LONG>(float(backBufferHeight) - safeh + 0.5f);
+
+    return rct;
+}

enginecustom/include/Src/pch.cpp

@@ -0,0 +1,10 @@
+//--------------------------------------------------------------------------------------
+// File: pch.cpp
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#include "pch.h"

enginecustom/include/Src/pch.h

@@ -0,0 +1,193 @@
+//--------------------------------------------------------------------------------------
+// File: pch.h
+//
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+//
+// http://go.microsoft.com/fwlink/?LinkId=248929
+//--------------------------------------------------------------------------------------
+
+#pragma once
+
+#ifdef _MSC_VER
+// Off by default warnings
+#pragma warning(disable : 4619 4616 4061 4265 4365 4571 4623 4625 4626 4628 4668 4710 4711 4746 4774 4820 4987 5026 5027 5031 5032 5039 5045 5219 5264 26812)
+// C4619/4616 #pragma warning warnings
+// C4061 enumerator 'X' in switch of enum 'X' is not explicitly handled by a case label
+// C4265 class has virtual functions, but destructor is not virtual
+// C4365 signed/unsigned mismatch
+// C4571 behavior change
+// C4623 default constructor was implicitly defined as deleted
+// C4625 copy constructor was implicitly defined as deleted
+// C4626 assignment operator was implicitly defined as deleted
+// C4628 digraphs not supported
+// C4668 not defined as a preprocessor macro
+// C4710 function not inlined
+// C4711 selected for automatic inline expansion
+// C4746 volatile access of '<expression>' is subject to /volatile:<iso|ms> setting
+// C4774 format string expected in argument 3 is not a string literal
+// C4820 padding added after data member
+// C4987 nonstandard extension used
+// C5026 move constructor was implicitly defined as deleted
+// C5027 move assignment operator was implicitly defined as deleted
+// C5031/5032 push/pop mismatches in windows headers
+// C5039 pointer or reference to potentially throwing function passed to extern C function under - EHc
+// C5045 Spectre mitigation warning
+// C5219 implicit conversion from 'int' to 'float', possible loss of data
+// C5264 'const' variable is not used
+// 26812: The enum type 'x' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
+
+#if defined(_XBOX_ONE) && defined(_TITLE)
+// Xbox One XDK related Off by default warnings
+#pragma warning(disable : 4471 4643 4917 4986 5029 5038 5040 5043 5204 5246 5256 5262 5267)
+// C4471 forward declaration of an unscoped enumeration must have an underlying type
+// C4643 Forward declaring in namespace std is not permitted by the C++ Standard
+// C4917 a GUID can only be associated with a class, interface or namespace
+// C4986 exception specification does not match previous declaration
+// C5029 nonstandard extension used
+// C5038 data member 'X' will be initialized after data member 'Y'
+// C5040 dynamic exception specifications are valid only in C++14 and earlier; treating as noexcept(false)
+// C5043 exception specification does not match previous declaration
+// C5204 class has virtual functions, but its trivial destructor is not virtual; instances of objects derived from this class may not be destructed correctly
+// C5246 'anonymous struct or union': the initialization of a subobject should be wrapped in braces
+// C5256 a non-defining declaration of an enumeration with a fixed underlying type is only permitted as a standalone declaration
+// C5262 implicit fall-through occurs here; are you missing a break statement?
+// C5267 definition of implicit copy constructor for 'X' is deprecated because it has a user-provided assignment operator
+#endif // _XBOX_ONE && _TITLE
+#endif // _MSC_VER
+
+#ifdef __INTEL_COMPILER
+#pragma warning(disable : 161 2960 3280)
+// warning #161: unrecognized #pragma
+// message #2960: allocation may not satisfy the type's alignment; consider using <aligned_new> header
+// message #3280: declaration hides member
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#pragma clang diagnostic ignored "-Wc++98-compat-local-type-template-args"
+#pragma clang diagnostic ignored "-Wcovered-switch-default"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wfloat-equal"
+#pragma clang diagnostic ignored "-Wglobal-constructors"
+#pragma clang diagnostic ignored "-Wgnu-anonymous-struct"
+#pragma clang diagnostic ignored "-Wlanguage-extension-token"
+#pragma clang diagnostic ignored "-Wmissing-variable-declarations"
+#pragma clang diagnostic ignored "-Wmicrosoft-include"
+#pragma clang diagnostic ignored "-Wnested-anon-types"
+#pragma clang diagnostic ignored "-Wreserved-id-macro"
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#pragma clang diagnostic ignored "-Wunused-const-variable"
+#pragma clang diagnostic ignored "-Wunused-member-function"
+#pragma clang diagnostic ignored "-Wunknown-warning-option"
+#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 4005)
+#define NOMINMAX 1
+#define NODRAWTEXT
+#define NOGDI
+#define NOBITMAP
+#define NOMCX
+#define NOSERVICE
+#define NOHELP
+#pragma warning(pop)
+
+#include <Windows.h>
+
+#ifndef _WIN32_WINNT_WIN10
+#define _WIN32_WINNT_WIN10 0x0A00
+#endif
+
+#ifndef WINAPI_FAMILY_GAMES
+#define WINAPI_FAMILY_GAMES 6
+#endif
+
+#ifdef _GAMING_XBOX
+#error This version of DirectX Tool Kit not supported for GDKX
+#elif defined(_XBOX_ONE) && defined(_TITLE)
+#include <xdk.h>
+
+#if _XDK_VER < 0x42EE13B6 /* XDK Edition 180704 */
+#error DirectX Tool Kit for Direct3D 11 requires the July 2018 QFE4 XDK or later
+#endif
+
+#include <d3d11_x.h>
+#else
+#include <d3d11_1.h>
+#endif
+
+#define _USE_MATH_DEFINES
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <cwchar>
+#include <exception>
+#include <iterator>
+#include <list>
+#include <map>
+#include <memory>
+#include <new>
+#include <set>
+#include <stdexcept>
+#include <string>
+#include <system_error>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#pragma warning(push)
+#pragma warning(disable : 4702)
+#include <functional>
+#pragma warning(pop)
+
+#include <malloc.h>
+
+#define _XM_NO_XMVECTOR_OVERLOADS_
+
+#include <DirectXMath.h>
+#include <DirectXPackedVector.h>
+#include <DirectXCollision.h>
+
+#if (DIRECTX_MATH_VERSION < 315)
+#define XM_ALIGNED_STRUCT(x) __declspec(align(x)) struct
+#endif
+
+#pragma warning(push)
+#pragma warning(disable : 4467 4986 5038 5204 5220 6101)
+#ifdef __MINGW32__
+#include <wrl/client.h>
+#else
+#include <wrl.h>
+#endif
+#pragma warning(pop)
+
+#include <wincodec.h>
+
+#if defined(NTDDI_WIN10_FE) || defined(__MINGW32__)
+#include <ocidl.h>
+#else
+#include <OCIdl.h>
+#endif
+
+#if (defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)) || (defined(_XBOX_ONE) && defined(_TITLE))
+#pragma warning(push)
+#pragma warning(disable: 4471 5204 5256)
+#include <Windows.UI.Core.h>
+#pragma warning(pop)
+#endif
+
+#include <mutex>

enginecustom/modelclass.cpp

@@ -5,7 +5,6 @@ ModelClass::ModelClass()
 {
 	m_vertexBuffer = 0;
 	m_indexBuffer = 0;
-	m_Textures = 0;
 	m_model = 0;
 }
 
@@ -19,16 +18,14 @@ ModelClass::~ModelClass()
 {
 }
 
-bool ModelClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* modelFilename, vector<string> filename)
-{
-	Logger::Get().Log("Initializing model class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+bool ModelClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* modelFilename, std::vector<ID3D11ShaderResourceView*> textures) {
+	Logger::Get().Log("Initializing model class with preloaded textures", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
 	bool result;
 
 	// Load in the model data.
 	result = LoadModel(modelFilename);
-	if (!result)
-	{
+	if (!result) {
 		Logger::Get().Log("Failed to load model data", __FILE__, __LINE__, Logger::LogLevel::Error);
 		return false;
 	}
@@ -38,20 +35,14 @@ bool ModelClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCon
 
 	// Initialize the vertex and index buffers.
 	result = InitializeBuffers(device);
-	if (!result)
-	{
+	if (!result) {
 		Logger::Get().Log("Failed to initialize buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
 		return false;
 	}
-	// Load the textures for this model.
-	result = LoadTextures(device, deviceContext, filename);
-	if (!result)
-	{
-		Logger::Get().Log("Failed to load textures", __FILE__, __LINE__, Logger::LogLevel::Error);
-		return false;
-	}
 
-	Logger::Get().Log("Model class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+	m_Textures = textures;
+
+	Logger::Get().Log("Model class initialized with preloaded textures", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
 	return true;
 }
@@ -86,12 +77,13 @@ int ModelClass::GetIndexCount()
 	return m_indexCount;
 }
 
-ID3D11ShaderResourceView* ModelClass::GetTexture(int index)
-{
-	return m_Textures[index].GetTexture();
+ID3D11ShaderResourceView* ModelClass::GetTexture(int index) const {
+	if (index >= 0 && index < m_Textures.size()) {
+		return m_Textures[index];
+	}
+	return nullptr; // Retourne nullptr si l'index est hors limites
 }
 
-
 bool ModelClass::InitializeBuffers(ID3D11Device* device)
 {
 	Logger::Get().Log("Initializing buffers", __FILE__, __LINE__, Logger::LogLevel::Initialize);
@@ -221,52 +213,23 @@ void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
 	return;
 }
 
-
-bool ModelClass::LoadTextures(ID3D11Device* device, ID3D11DeviceContext* deviceContext, vector<string> textureFile)
-{
-	Logger::Get().Log("Loading textures", __FILE__, __LINE__);
-
-	bool result;
-
-	// Create and initialize the texture object array.
-	m_Textures = new TextureClass[textureFile.size()];
-
-	for (int i = 0; i < textureFile.size(); i++)
-	{
-		result = m_Textures[i].Initialize(device, deviceContext, textureFile[i]);
-		if (!result)
-		{
-			Logger::Get().Log("Failed to initialize texture", __FILE__, __LINE__, Logger::LogLevel::Error);
-			return false;
-		}
-	}
-
-	Logger::Get().Log("Textures loaded", __FILE__, __LINE__);
-
-	return true;
-}
-
 void ModelClass::ReleaseTextures()
 {
 	Logger::Get().Log("Releasing textures", __FILE__, __LINE__);
 
 	// Release the texture object array.
-	if (m_Textures)
+	for (auto& texture : m_Textures)
 	{
-		m_Textures[0].Shutdown();
-		m_Textures[1].Shutdown();
-		m_Textures[2].Shutdown();
-		m_Textures[3].Shutdown();
-		m_Textures[4].Shutdown();
-		m_Textures[5].Shutdown();
-
-		delete[] m_Textures;
-		m_Textures = 0;
+		if (texture)
+		{
+			texture->Release();
+			texture = nullptr;
+		}
 	}
 
-	Logger::Get().Log("Textures released", __FILE__, __LINE__);
+	m_Textures.clear();
 
-	return;
+	Logger::Get().Log("Textures released", __FILE__, __LINE__);
 }
 
 bool ModelClass::LoadModel(char* filename)
@@ -590,23 +553,39 @@ void ModelClass::ReleaseModel()
 
 bool ModelClass::ChangeTexture(ID3D11Device* device, ID3D11DeviceContext* deviceContext, std::wstring filename, int index)
 {
-	bool result;
+	Logger::Get().Log("Changing texture", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
-	// convert wstring to string
-	std::string str(filename.begin(), filename.end());
+	HRESULT result;
+	ID3D11ShaderResourceView* newTexture = nullptr;
 
-	// Release the old texture object.
-	m_Textures[index].Shutdown();
-
-	// Initialize the new texture object.
-	result = m_Textures[index].Initialize(device, deviceContext, str);
-	if (!result)
+	// Load the new texture using WICTextureLoader.
+	result = DirectX::CreateWICTextureFromFile(device, deviceContext, filename.c_str(), nullptr, &newTexture);
+	if (FAILED(result))
 	{
-		Logger::Get().Log("Failed to initialize texture", __FILE__, __LINE__, Logger::LogLevel::Error);
+		Logger::Get().Log("Failed to load new texture", __FILE__, __LINE__, Logger::LogLevel::Error);
 		return false;
 	}
 
-	Logger::Get().Log("Texture changed", __FILE__, __LINE__, Logger::LogLevel::Debug);
+	// Release the old texture if it exists.
+	if (index >= 0 && index < m_Textures.size() && m_Textures[index])
+	{
+		m_Textures[index]->Release();
+		m_Textures[index] = nullptr;
+	}
 
+	// Assign the new texture to the specified index.
+	if (index >= 0 && index < m_Textures.size())
+	{
+		m_Textures[index] = newTexture;
+	}
+	else
+	{
+		// If the index is out of range, log an error and release the new texture.
+		Logger::Get().Log("Texture index out of range", __FILE__, __LINE__, Logger::LogLevel::Error);
+		newTexture->Release();
+		return false;
+	}
+
+	Logger::Get().Log("Texture changed successfully", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 	return true;
 }

enginecustom/modelclass.h

@@ -13,6 +13,7 @@
 #include <sstream>
 #include <vector>
 #include <string>
+#include <WICTextureLoader.h>
 using namespace DirectX;
 using namespace std;
 
@@ -82,12 +83,13 @@ public:
 	ModelClass(const ModelClass&);
 	~ModelClass();
 
-	bool Initialize(ID3D11Device*, ID3D11DeviceContext*, char*, vector<string>);
+	bool Initialize(ID3D11Device*, ID3D11DeviceContext*, char*, std::vector<ID3D11ShaderResourceView*>);
+
 	void Shutdown();
 	void Render(ID3D11DeviceContext*);
 
 	int GetIndexCount();
-	ID3D11ShaderResourceView* GetTexture(int);
+	ID3D11ShaderResourceView* GetTexture(int index) const;
 	bool ChangeTexture(ID3D11Device*, ID3D11DeviceContext*, std::wstring filename, int index);
 
 private:
@@ -108,7 +110,7 @@ private:
 private:
 	ID3D11Buffer* m_vertexBuffer, * m_indexBuffer;
 	int m_vertexCount, m_indexCount;
-	TextureClass* m_Textures;
+	std::vector<ID3D11ShaderResourceView*> m_Textures;
 	ModelType* m_model;
 };