minor update - préparation sunlight

enginecustom/Lightshaderclass.h

@@ -3,7 +3,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef _LIGHTSHADERCLASS_H_
 #define _LIGHTSHADERCLASS_H_
-
+#pragma once
 
 /////////////
 // GLOBALS //

enginecustom/applicationclass.cpp

@@ -29,6 +29,9 @@ ApplicationClass::ApplicationClass() : m_ShouldQuit(false)
 	m_terrainChunk.clear();
 	m_object.clear();
 	m_RenderQueues.clear();
+	m_Skybox.clear();
+	m_Lights.clear();
+	m_SunLight = 0;
 }
 
 ApplicationClass::~ApplicationClass()
@@ -274,6 +277,15 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
 		m_Lights[3]->SetSpecularPower(16.0f);
 		m_Lights[3]->SetPosition(-10.0f, 7.0f, 5.0f);
 
+		// Create || THE SUN ||
+		m_SunLight = new LightClass;
+		m_SunLight->SetDiffuseColor(1.0f, 1.0f, 1.0f, 1.0f);  // White
+		m_SunLight->SetDirection(0.0f, -1.0f, 0.0f);
+		m_SunLight->SetAmbientColor(0.15f, 0.15f, 0.15f, 1.0f);
+		m_SunLight->SetSpecularColor(1.0f, 1.0f, 1.0f, 1.0f);
+		m_SunLight->SetSpecularPower(16.0f);
+		m_SunLight->SetPosition(0.0f, 100.0f, 0.0f);
+
 		// Create and initialize the normal map shader object.
 		m_ShaderManager = new ShaderManagerClass;
 
@@ -1442,15 +1454,11 @@ void ApplicationClass::GenerateTerrain()
 		{
 			Object* newTerrain = new Object();
 			newTerrain->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, textures);
-
 			newTerrain->SetScaleMatrix(scaleMatrix);
-
 			newTerrain->SetTranslateMatrix(XMMatrixTranslation(i / 2 * scaleX , -12.0f, j * scaleZ));
-
 			newTerrain->SetName(filenameWithoutExtension);
-
 			newTerrain->SetType(ObjectType::Cube);
-
+			newTerrain->SetActiveShader(Object::SUNLIGHT);
 			m_terrainChunk.push_back(newTerrain);
 
 		}
@@ -1922,6 +1930,8 @@ bool ApplicationClass::RenderPass(const std::vector<std::reference_wrapper<std::
 					Logger::Get().Log("Could not render the model using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
 					return false;
 				}
+				break;
+
 			case Object::LIGHTING:
 				result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, view, projection,
 					object->GetTexture(0), diffuse, position, ambient);
@@ -1931,6 +1941,16 @@ bool ApplicationClass::RenderPass(const std::vector<std::reference_wrapper<std::
 					return false;
 				}
 				break;
+
+			case Object::SUNLIGHT:
+				result = m_ShaderManager->RenderSunlightShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, view, projection,
+					object->GetTexture(0), m_SunLight->GetDiffuseColor(), m_SunLight->GetPosition(), m_SunLight->GetAmbientColor());
+				if (!result)
+				{
+					Logger::Get().Log("Could not render the object model using the sunlight shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+					return false;
+				}
+				break;
 			default:
 				result = m_ShaderManager->RenderlightShader(m_Direct3D->GetDeviceContext(), object->GetIndexCount(), worldMatrix, view, projection,
 					object->GetTexture(0), diffuse, position, ambient);

enginecustom/applicationclass.h

@@ -201,6 +201,7 @@ private :
 	LightClass* m_Light;
 	std::vector<LightClass*> m_Lights;
 	int m_numLights;
+	LightClass* m_SunLight;
 
 	XMFLOAT3 TrueLightPosition;
 	ModelClass* m_LightModel;

enginecustom/enginecustom.vcxproj

@@ -62,6 +62,7 @@
     <ClCompile Include="rendertextureclass.cpp" />
     <ClCompile Include="specmapshaderclass.cpp" />
     <ClCompile Include="Spriteclass.cpp" />
+    <ClCompile Include="sunlightshaderclass.cpp" />
     <ClCompile Include="Systemclass.cpp" />
     <ClCompile Include="textclass.cpp" />
     <ClCompile Include="textureclass.cpp" />
@@ -118,6 +119,7 @@
     <ClInclude Include="resources.h" />
     <ClInclude Include="specmapshaderclass.h" />
     <ClInclude Include="Spriteclass.h" />
+    <ClInclude Include="sunlightshaderclass.h" />
     <ClInclude Include="systemclass.h" />
     <ClInclude Include="textclass.h" />
     <ClInclude Include="textureclass.h" />
@@ -207,6 +209,12 @@
     <CopyFileToFolders Include="water.vs">
       <FileType>Document</FileType>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="sunlight.ps">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="sunlight.vs">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
   </ItemGroup>
   <ItemGroup>
     <CopyFileToFolders Include="Color.ps">

enginecustom/enginecustom.vcxproj.filters

@@ -222,6 +222,9 @@
     <ClCompile Include="frustum.cpp">
       <Filter>Fichiers sources\System</Filter>
     </ClCompile>
+    <ClCompile Include="sunlightshaderclass.cpp">
+      <Filter>Fichiers sources\Shader</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="systemclass.h">
@@ -389,6 +392,9 @@
     <ClInclude Include="frustum.h">
       <Filter>Fichiers d%27en-tête\System</Filter>
     </ClInclude>
+    <ClInclude Include="sunlightshaderclass.h">
+      <Filter>Fichiers d%27en-tête\Shader</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Image Include="KhaoticIcon.ico">
@@ -644,5 +650,11 @@
     <CopyFileToFolders Include="assets\Skybox\skybox_top.png">
       <Filter>Assets\Skybox</Filter>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="sunlight.ps">
+      <Filter>shader</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="sunlight.vs">
+      <Filter>shader</Filter>
+    </CopyFileToFolders>
   </ItemGroup>
 </Project>

enginecustom/imgui.ini

@@ -25,13 +25,12 @@ DockId=0x00000009,0
 Pos=8,27
 Size=330,487
 Collapsed=0
-DockId=0x00000004,1
 
 [Window][Shader Manager]
 Pos=8,27
 Size=330,487
 Collapsed=0
-DockId=0x00000004,2
+DockId=0x00000001,2
 
 [Window][Engine Settings]
 Pos=1180,27
@@ -73,9 +72,7 @@ DockId=0x0000000E,0
 
 [Docking][Data]
 DockSpace         ID=0xC0DFADC4 Pos=8,27 Size=1568,826 Split=X
-  DockNode        ID=0x00000001 Parent=0xC0DFADC4 SizeRef=330,1094 Split=Y Selected=0x393905AB
+  DockNode        ID=0x00000001 Parent=0xC0DFADC4 SizeRef=330,1094 Selected=0x393905AB
-    DockNode      ID=0x00000004 Parent=0x00000001 SizeRef=330,487 Selected=0x393905AB
-    DockNode      ID=0x00000006 Parent=0x00000001 SizeRef=330,485 Selected=0x031DC75C
   DockNode        ID=0x00000003 Parent=0xC0DFADC4 SizeRef=1700,1094 CentralNode=1
 DockSpace         ID=0xCCBD8CF7 Window=0x3DA2F1DE Pos=8,27 Size=1568,826 Split=Y
   DockNode        ID=0x0000000D Parent=0xCCBD8CF7 SizeRef=1568,598 Split=Y

enginecustom/lightshaderclass.h

@@ -3,7 +3,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 #ifndef _LIGHTSHADERCLASS_H_
 #define _LIGHTSHADERCLASS_H_
-
+#pragma once
 
 /////////////
 // GLOBALS //

enginecustom/object.h

@@ -76,7 +76,8 @@ public:
 		REFLECTION,
 		REFRACTION,
 		TEXTURE,
-		SKYBOX
+		SKYBOX,
+		SUNLIGHT
 	};
 
 	ShaderType GetActiveShader() const { return m_activeShader; };

enginecustom/shadermanagerclass.cpp

@@ -134,6 +134,13 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
         return false;
     }
 
+	m_SunlightShader = new SunlightShaderClass;
+	result = m_SunlightShader->Initialize(device, hwnd);
+	if (!result)
+	{
+		return false;
+	}
+
     Logger::Get().Log("ShaderManagerClass initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
 
     return true;
@@ -239,6 +246,13 @@ void ShaderManagerClass::Shutdown()
         m_CelShadingShader = 0;
     }
 
+	if (m_SunlightShader)
+	{
+		m_SunlightShader->Shutdown();
+		delete m_SunlightShader;
+		m_SunlightShader = 0;
+	}
+
     Logger::Get().Log("ShaderManagerClass shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
 }
 
@@ -419,4 +433,18 @@ bool ShaderManagerClass::RenderCelShadingShader(ID3D11DeviceContext* deviceConte
     }
 
     return true;
+}
+
+bool ShaderManagerClass::RenderSunlightShader(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
+	ID3D11ShaderResourceView* texture, XMFLOAT4 ambientColor, XMFLOAT4 diffuseColor, XMFLOAT4 sunColor)
+{
+	bool result;
+
+	result = m_SunlightShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, ambientColor, diffuseColor, sunColor);
+	if (!result)
+	{
+		return false;
+	}
+
+	return true;
 }

enginecustom/shadermanagerclass.h

@@ -17,6 +17,7 @@
 #include "refractionshaderclass.h"
 #include "watershaderclass.h"
 #include "celshadingshader.h"
+#include "sunlightshaderclass.h"
 
 using namespace DirectX;
 
@@ -42,8 +43,7 @@ public:
     bool RenderRefractionShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4[], XMFLOAT4[], XMFLOAT4[], XMFLOAT4);
     bool RenderWaterShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, ID3D11ShaderResourceView*, float, float);
     bool RenderCelShadingShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT3, XMFLOAT4, XMFLOAT3);
-    bool RenderSkyboxShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, const std::vector<ID3D11ShaderResourceView*>&);
+	bool RenderSunlightShader(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT4, XMFLOAT4, XMFLOAT4);
-
 private:
     TextureShaderClass* m_TextureShader;
     NormalMapShaderClass* m_NormalMapShader;
@@ -57,7 +57,7 @@ private:
     RefractionShaderClass* m_RefractionShader;
     WaterShaderClass* m_WaterShader;
     CelShadingShader* m_CelShadingShader;
+	SunlightShaderClass* m_SunlightShader;
 };
 
-#endif
+#endif
-

enginecustom/sunlight.ps

@@ -0,0 +1,69 @@
+/////////////
+// GLOBALS //
+/////////////
+Texture2D shaderTexture : register(t0);
+SamplerState SampleType : register(s0);
+cbuffer SunLightBuffer
+{
+    float4 ambientColor;
+    float3 lightDirection;
+    float padding;
+    float specularPower;
+    float4 specularColor;
+};
+
+cbuffer SunLightColorBuffer
+{
+    float4 sunColor;
+};
+
+
+//////////////
+// TYPEDEFS //
+//////////////
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float3 normal : NORMAL;
+    float3 sunPos : TEXCOORD1;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Pixel Shader
+////////////////////////////////////////////////////////////////////////////////
+float4 SunLightPixelShader(PixelInputType input) : SV_TARGET
+{
+    float4 textureColor;
+    float3 lightDir;
+    float4 color;
+    float3 reflection;
+    float4 specular;
+    float lightIntensity;
+    float4 colorArray;
+    float4 colorSum;
+    int i;
+
+    // Sample the pixel color from the texture using the sampler at this texture coordinate location.
+    textureColor = shaderTexture.Sample(SampleType, input.tex);
+
+    // Calculate the different amounts of light on this pixel based on the positions of the lights.
+    lightIntensity = saturate(dot(input.normal, input.sunPos));
+
+    // Determine the diffuse color amount of each of the four lights.
+    colorArray = sunColor * lightIntensity;
+
+    // Initialize the sum of colors.
+    colorSum = float4(0.0f, 0.0f, 0.0f, 1.0f);
+
+    // Add all of the light colors up.
+    colorSum.r += colorArray.r;
+    colorSum.g += colorArray.g;
+    colorSum.b += colorArray.b;
+
+    // Multiply the texture pixel by the combination of all four light colors to get the final result.
+    color = saturate(colorSum) * textureColor;
+
+    return color;
+}

enginecustom/sunlight.vs

@@ -0,0 +1,78 @@
+/////////////
+// GLOBALS //
+/////////////
+cbuffer MatrixBuffer
+{
+    matrix worldMatrix;
+    matrix viewMatrix;
+    matrix projectionMatrix;
+};
+
+cbuffer CameraBuffer
+{
+    float3 cameraPosition;
+    float padding;
+};
+
+cbuffer SunLightPositionBuffer
+{
+    float4 sunPosition;
+};
+
+//////////////
+// TYPEDEFS //
+//////////////
+struct VertexInputType
+{
+    float4 position : POSITION;
+    float2 tex : TEXCOORD0;
+    float3 normal : NORMAL;
+};
+
+struct PixelInputType
+{
+    float4 position : SV_POSITION;
+    float2 tex : TEXCOORD0;
+    float3 normal : NORMAL;
+    float3 lightPos : TEXCOORD1;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Vertex Shader
+////////////////////////////////////////////////////////////////////////////////
+PixelInputType SunLightVertexShader(VertexInputType input)
+{
+    PixelInputType output;
+    float4 worldPosition;
+    int i;
+
+    // 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.
+    output.position = mul(input.position, worldMatrix);
+    output.position = mul(output.position, viewMatrix);
+    output.position = mul(output.position, projectionMatrix);
+    
+    // Store the texture coordinates for the pixel shader.
+    output.tex = input.tex;
+    
+    // Calculate the normal vector against the world matrix only.
+    output.normal = mul(input.normal, (float3x3) worldMatrix);
+	
+    // Normalize the normal vector.
+    output.normal = normalize(output.normal);
+
+     // Calculate the position of the vertex in the world.
+    worldPosition = mul(input.position, worldMatrix);
+
+    // Determine the light positions based on the position of the lights and the position of the vertex in the world.
+    output.lightPos = sunPosition.xyz - worldPosition.xyz;
+
+    // Normalize the light position vectors.
+    output.lightPos = normalize(output.lightPos);
+    
+
+    return output;
+}

enginecustom/sunlightshaderclass.cpp

@@ -0,0 +1,538 @@
+////////////////////////////////////////////////////////////////////////////////
+// Filename: lightshaderclass.cpp
+////////////////////////////////////////////////////////////////////////////////
+#include "sunlightshaderclass.h"
+
+
+SunlightShaderClass::SunlightShaderClass()
+{
+    m_vertexShader = 0;
+    m_pixelShader = 0;
+    m_layout = 0;
+    m_sampleState = 0;
+    m_matrixBuffer = 0;
+    m_cameraBuffer = 0;
+    m_sunlightBuffer = 0;
+    m_sunlightColorBuffer = 0;
+    m_sunlightPositionBuffer = 0;
+}
+
+
+SunlightShaderClass::SunlightShaderClass(const SunlightShaderClass& other)
+{
+}
+
+
+SunlightShaderClass::~SunlightShaderClass()
+{
+}
+
+
+bool SunlightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
+{
+    Logger::Get().Log("Initializing LightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+
+    wchar_t vsFilename[128];
+    wchar_t psFilename[128];
+    int error;
+    bool result;
+
+    // Set the filename of the vertex shader.
+    error = wcscpy_s(vsFilename, 128, L"sunlight.vs");
+    if (error != 0)
+    {
+        Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Set the filename of the pixel shader.
+    error = wcscpy_s(psFilename, 128, L"sunlight.ps");
+    if (error != 0)
+    {
+        Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+    // Initialize the vertex and pixel shaders.
+    result = InitializeShader(device, hwnd, vsFilename, psFilename);
+    if (!result)
+    {
+        Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    Logger::Get().Log("SunLightShaderClass initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+
+    return true;
+}
+
+
+void SunlightShaderClass::Shutdown()
+{
+    // Shutdown the vertex and pixel shaders as well as the related objects.
+    ShutdownShader();
+
+    return;
+}
+
+bool SunlightShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
+    ID3D11ShaderResourceView* texture, XMFLOAT4 diffuseColor, XMFLOAT4 lightPosition, XMFLOAT4 ambientClor)
+{
+    bool result;
+
+
+    // Set the shader parameters that it will use for rendering.
+    result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, lightPosition, ambientClor);
+    if (!result)
+    {
+        Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Now render the prepared buffers with the shader.
+    RenderShader(deviceContext, indexCount);
+
+    return true;
+}
+
+
+bool SunlightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
+{
+    Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+
+    HRESULT result;
+    ID3D10Blob* errorMessage;
+    ID3D10Blob* vertexShaderBuffer;
+    ID3D10Blob* pixelShaderBuffer;
+    D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
+    unsigned int numElements;
+    D3D11_SAMPLER_DESC samplerDesc;
+    D3D11_BUFFER_DESC matrixBufferDesc;
+    D3D11_BUFFER_DESC cameraBufferDesc;
+    D3D11_BUFFER_DESC lightColorBufferDesc;
+    D3D11_BUFFER_DESC lightPositionBufferDesc;
+
+
+    // Initialize the pointers this function will use to null.
+    errorMessage = 0;
+    vertexShaderBuffer = 0;
+    pixelShaderBuffer = 0;
+
+    // Compile the vertex shader code.
+    result = D3DCompileFromFile(vsFilename, NULL, NULL, "SunLightVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
+    if (FAILED(result))
+    {
+        // If the shader failed to compile it should have writen 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
+        {
+            Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+        }
+
+        return false;
+    }
+
+    // Compile the pixel shader code.
+    result = D3DCompileFromFile(psFilename, NULL, NULL, "SunLightPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
+    if (FAILED(result))
+    {
+        // If the shader failed to compile it should have writen 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
+        {
+            Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+        }
+
+        return false;
+    }
+
+    // Create the vertex shader from the buffer.
+    result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Create the pixel shader from the buffer.
+    result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Create the vertex input layout description.
+    // This setup needs to match the VertexType stucture in the ModelClass and in the shader.
+    polygonLayout[0].SemanticName = "POSITION";
+    polygonLayout[0].SemanticIndex = 0;
+    polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
+    polygonLayout[0].InputSlot = 0;
+    polygonLayout[0].AlignedByteOffset = 0;
+    polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
+    polygonLayout[0].InstanceDataStepRate = 0;
+
+    polygonLayout[1].SemanticName = "TEXCOORD";
+    polygonLayout[1].SemanticIndex = 0;
+    polygonLayout[1].Format = DXGI_FORMAT_R32G32_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 = "NORMAL";
+    polygonLayout[2].SemanticIndex = 0;
+    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_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))
+    {
+        Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
+    vertexShaderBuffer->Release();
+    vertexShaderBuffer = 0;
+
+    pixelShaderBuffer->Release();
+    pixelShaderBuffer = 0;
+
+    // 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))
+    {
+        Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // 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, NULL, &m_matrixBuffer);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+
+
+    // Setup the description of the camera dynamic constant buffer that is in the vertex shader.
+    cameraBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+    cameraBufferDesc.ByteWidth = sizeof(CameraBufferType);
+    cameraBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    cameraBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    cameraBufferDesc.MiscFlags = 0;
+    cameraBufferDesc.StructureByteStride = 0;
+
+    // Create the camera constant buffer pointer so we can access the vertex shader constant buffer from within this class.
+    result = device->CreateBuffer(&cameraBufferDesc, NULL, &m_cameraBuffer);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to create camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Setup the description of the dynamic constant buffer that is in the pixel shader.
+    lightColorBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+    lightColorBufferDesc.ByteWidth = sizeof(SunLightColorBufferType);
+    lightColorBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    lightColorBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    lightColorBufferDesc.MiscFlags = 0;
+    lightColorBufferDesc.StructureByteStride = 0;
+
+    // Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class.
+    result = device->CreateBuffer(&lightColorBufferDesc, NULL, &m_sunlightColorBuffer);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to create sunlight color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Setup the description of the dynamic constant buffer that is in the vertex shader.
+    lightPositionBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+    lightPositionBufferDesc.ByteWidth = sizeof(SunLightPositionBufferType);
+    lightPositionBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+    lightPositionBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+    lightPositionBufferDesc.MiscFlags = 0;
+    lightPositionBufferDesc.StructureByteStride = 0;
+
+    // Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
+    result = device->CreateBuffer(&lightPositionBufferDesc, NULL, &m_sunlightPositionBuffer);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to create sunlight position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
+
+    return true;
+}
+
+
+void SunlightShaderClass::ShutdownShader()
+{
+    Logger::Get().Log("Shutting down SunLightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
+
+    // Release the light constant buffers.
+    if (m_sunlightColorBuffer)
+    {
+        m_sunlightColorBuffer->Release();
+        m_sunlightColorBuffer = 0;
+    }
+
+    if (m_sunlightPositionBuffer)
+    {
+        m_sunlightPositionBuffer->Release();
+        m_sunlightPositionBuffer = 0;
+    }
+
+    // Release the light constant buffer.
+    if (m_sunlightBuffer)
+    {
+        m_sunlightBuffer->Release();
+        m_sunlightBuffer = 0;
+    }
+
+    // Release the camera constant buffer.
+    if (m_cameraBuffer)
+    {
+        m_cameraBuffer->Release();
+        m_cameraBuffer = 0;
+    }
+
+    // Release the matrix constant buffer.
+    if (m_matrixBuffer)
+    {
+        m_matrixBuffer->Release();
+        m_matrixBuffer = 0;
+    }
+
+    // Release the sampler state.
+    if (m_sampleState)
+    {
+        m_sampleState->Release();
+        m_sampleState = 0;
+    }
+
+    // Release the layout.
+    if (m_layout)
+    {
+        m_layout->Release();
+        m_layout = 0;
+    }
+
+    // Release the pixel shader.
+    if (m_pixelShader)
+    {
+        m_pixelShader->Release();
+        m_pixelShader = 0;
+    }
+
+    // Release the vertex shader.
+    if (m_vertexShader)
+    {
+        m_vertexShader->Release();
+        m_vertexShader = 0;
+    }
+
+    Logger::Get().Log("SunLightShaderClass shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
+
+    return;
+}
+
+
+void SunlightShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
+{
+    char* compileErrors;
+    unsigned __int64 bufferSize, i;
+    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 = 0;
+
+    // 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);
+
+    return;
+}
+
+
+bool SunlightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
+    ID3D11ShaderResourceView* texture, XMFLOAT4 diffuseColor, XMFLOAT4 lightPosition, XMFLOAT4 ambientColor)
+{
+    HRESULT result;
+    D3D11_MAPPED_SUBRESOURCE mappedResource;
+    unsigned int bufferNumber;
+    MatrixBufferType* dataPtr;
+    SunLightPositionBufferType* dataPtr2;
+    SunLightColorBufferType* dataPtr3;
+
+    // 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))
+    {
+        Logger::Get().Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        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;
+
+    // Now set the constant buffer in the vertex shader with the updated values.
+    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
+
+    // Lock the camera constant buffer so it can be written to.
+    result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to map camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Lock the light position constant buffer so it can be written to.
+    result = deviceContext->Map(m_sunlightPositionBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to map sunlight position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Get a pointer to the data in the constant buffer.
+    dataPtr2 = (SunLightPositionBufferType*)mappedResource.pData;
+
+    // Copy the light position variables into the constant buffer.
+    dataPtr2->sunPosition = lightPosition;
+
+    // Unlock the constant buffer.
+    deviceContext->Unmap(m_sunlightPositionBuffer, 0);
+
+    // Set the position of the constant buffer in the vertex shader.
+    bufferNumber = 1;
+
+    // Finally set the constant buffer in the vertex shader with the updated values.
+    deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_sunlightPositionBuffer);
+
+    // Set shader texture resource in the pixel shader.
+    deviceContext->PSSetShaderResources(0, 1, &texture);
+
+    // Lock the light color constant buffer so it can be written to.
+    result = deviceContext->Map(m_sunlightColorBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+    if (FAILED(result))
+    {
+        Logger::Get().Log("Failed to map sunlight color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
+        return false;
+    }
+
+    // Get a pointer to the data in the constant buffer.
+    dataPtr3 = (SunLightColorBufferType*)mappedResource.pData;
+
+    // Copy the light color variables into the constant buffer.
+    dataPtr3->sunColor = diffuseColor;
+
+    // Unlock the constant buffer.
+    deviceContext->Unmap(m_sunlightColorBuffer, 0);
+
+    // Set the position of the constant buffer in the pixel shader.
+    bufferNumber = 0;
+
+    // Finally set the constant buffer in the pixel shader with the updated values.
+    deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_sunlightColorBuffer);
+
+
+    return true;
+}
+
+
+void SunlightShaderClass::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, NULL, 0);
+    deviceContext->PSSetShader(m_pixelShader, NULL, 0);
+
+    // Set the sampler state in the pixel shader.
+    deviceContext->PSSetSamplers(0, 1, &m_sampleState);
+
+    // Render the triangle.
+    deviceContext->DrawIndexed(indexCount, 0, 0);
+
+    return;
+}

enginecustom/sunlightshaderclass.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "Logger.h"
+#include <d3d11.h>
+#include <d3dcompiler.h>
+#include <directxmath.h>
+#include <fstream>
+using namespace DirectX;
+using namespace std;
+
+class SunlightShaderClass
+{
+
+private :
+	struct MatrixBufferType
+	{
+		XMMATRIX world;
+		XMMATRIX view;
+		XMMATRIX projection;
+	};
+
+	struct CameraBufferType
+	{
+		XMFLOAT3 cameraPosition;
+		float padding;
+	};
+
+	struct SunLightBufferType
+	{
+		XMFLOAT4 ambientColor;
+		XMFLOAT4 diffuseColor;
+		XMFLOAT3 lightDirection;
+		float padding;  // Added extra padding so structure is a multiple of 16 for CreateBuffer function requirements.
+		float specularPower;
+		XMFLOAT4 specularColor;
+	};
+
+	struct SunLightColorBufferType
+	{
+		XMFLOAT4 sunColor;
+	};
+
+	struct SunLightPositionBufferType
+	{
+		XMFLOAT4 sunPosition;
+	};
+
+public :
+	SunlightShaderClass();
+	SunlightShaderClass(const SunlightShaderClass&);
+	~SunlightShaderClass();
+
+	bool Initialize(ID3D11Device*, HWND);
+	void Shutdown();
+	bool Render(ID3D11DeviceContext*, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT4, XMFLOAT4, XMFLOAT4);
+
+private:
+	bool InitializeShader(ID3D11Device*, HWND, WCHAR*, WCHAR*);
+	void ShutdownShader();
+	void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);
+
+	bool SetShaderParameters(ID3D11DeviceContext*, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView*, XMFLOAT4, XMFLOAT4, XMFLOAT4);
+	void RenderShader(ID3D11DeviceContext*, int);
+
+private:
+	ID3D11VertexShader* m_vertexShader;
+	ID3D11PixelShader* m_pixelShader;
+	ID3D11InputLayout* m_layout;
+	ID3D11SamplerState* m_sampleState;
+	ID3D11Buffer* m_matrixBuffer;
+	ID3D11Buffer* m_cameraBuffer;
+	ID3D11Buffer* m_sunlightBuffer;
+	ID3D11Buffer* m_sunlightColorBuffer;
+	ID3D11Buffer* m_sunlightPositionBuffer;
+};