Fix shadow again

.gitignore

@@ -25,4 +25,5 @@ bld/
 .vs
 cmake-build-debug
 cmake-build-release
-cmake-build-debug-visual-studio
+cmake-build-debug-visual-studio
+cmake-**

project/CMakeLists.txt

@@ -5,6 +5,7 @@ set(SOURCES
     "src/Renderer.cpp"
     "src/Timer.cpp"
     "src/Mesh.cpp"
+    "src/ShadowMesh.cpp"
     "src/InstancedMesh.cpp"
     "src/Camera.cpp"
     "src/Texture.cpp"
@@ -12,13 +13,23 @@ set(SOURCES
     "src/Utils.cpp"
     "src/HitTest.cpp"
     "src/Material.cpp"
-	"src/Math/Vector2.cpp"
+    "src/DirectionalLight.cpp"
+
+    "src/Math/Vector2.cpp"
     "src/Math/Vector3.cpp"
     "src/Math/Vector4.cpp"
     "src/Math/Matrix.cpp"
+
+    "src/BRDF.h"
+
     "src/Effects/Effect.cpp"
     "src/Effects/BaseEffect.cpp"
     "src/Effects/FireEffect.cpp"
+    "src/Effects/ShadowEffect.cpp"
+    "src/Effects/ShadowDiffuse.cpp"
+
+    "src/Singleton.h"
+    "src/RenderSettings.h"
 
     "src/PerlinNoise.hpp"
 
@@ -27,6 +38,12 @@ set(SOURCES
     "src/Scenes/DioramaScene.cpp"
     "src/Scenes/InstancedScene.cpp"
     "src/Scenes/PlanetScene.cpp"
+    "src/Scenes/ShadowTestScene.cpp"
+
+    "src/Buffers/ShadowMapBuffer.cpp"
+    "src/Buffers/SamplerState.cpp"
+    "src/Buffers/DepthBuffer.cpp"
+    "src/Buffers/DX11Viewport.cpp"
 )
 
 SET(INCLUDE_DIRS
@@ -34,6 +51,7 @@ SET(INCLUDE_DIRS
     "src/Math"
     "src/Effects"
     "src/Scenes"
+    "src/Buffers"
 )
 
 # Create the executable

project/resources/ShadingDemo.mtl

@@ -0,0 +1,42 @@
+# Blender 4.3.2 MTL File: 'None'
+# www.blender.org
+
+newmtl Material.001
+Ns 250.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800119 0.001607 0.000000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.500000
+d 1.000000
+illum 2
+
+newmtl Material.002
+Ns 250.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800149 0.000000 0.387990
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.500000
+d 1.000000
+illum 2
+
+newmtl Material.003
+Ns 250.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.003822 0.800111 0.000000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.500000
+d 1.000000
+illum 2
+
+newmtl Material.004
+Ns 250.000000
+Ka 1.000000 1.000000 1.000000
+Kd 0.800000 0.800000 0.800000
+Ks 0.500000 0.500000 0.500000
+Ke 0.000000 0.000000 0.000000
+Ni 1.500000
+d 1.000000
+illum 2

project/resources/SuperSimpleDiffuse.fx

@@ -0,0 +1,163 @@
+
+texture2D gShadowMap : ShadowMap;
+float4x4 gLightWorldViewProj : LightViewProjection;
+
+DepthStencilState ShadowDepthStencilState
+{
+    DepthEnable = true;
+    DepthWriteMask = ALL;       // Write depth to the shadow map
+    DepthFunc = LESS_EQUAL;     // Compare depth in the shadow map
+    StencilEnable = false;      // We don't need stencil operations here
+};
+
+SamplerState gShadowSampler2 : ShadowSampler {
+    Filter = MIN_MAG_MIP_POINT;
+    AddressU = CLAMP;
+    AddressV = CLAMP;
+    ComparisonFunc = LESS_EQUAL;
+};
+
+
+SamplerState gSampleState : SampleState;
+
+RasterizerState gRasterizerState : RastState;
+
+float4x4 gWorldViewProj : WorldViewProjection;
+float4x4 gWorldMatrix : WorldMatrix;
+
+texture2D gDiffuseMap : DiffuseMap;
+texture2D gNormalMap : Normal;
+texture2D gSpecularMap : Specular;
+texture2D gGlossMap : Gloss;
+
+float3 gLightDirection : LightDirection;
+float3 gLightColor : LightColor;
+float3 gCameraPosition : CameraPosition;
+bool gUseNormal : UseNormal;
+
+static const float3 gAmbient = float3(.03f, .03f, .03f);
+
+// Input output structures
+struct VS_INPUT {
+    float3 Position : POSITION;
+    float2 TexCoord : TEXCOORD;
+    float3 Normal : NORMAL;
+    float3 Tangent : TANGENT;
+};
+
+struct VS_OUTPUT {
+    float4 Position : SV_POSITION;
+    float4 WorldPosition : WORLDPOSITION;
+    float2 TexCoord : TEXCOORD;
+    float3 Normal : NORMAL;
+    float3 Tangent : TANGENT;
+    float4 ShadowCoord : SHADOWCOORD;  // Add this to store shadow map coordinates
+};
+
+// Vertex shader
+VS_OUTPUT VS(VS_INPUT input) {
+    VS_OUTPUT output = (VS_OUTPUT)0;
+
+    output.WorldPosition = mul(float4(input.Position, 1.f), gWorldMatrix);
+    output.Position = mul(float4(input.Position, 1.f), gWorldViewProj);
+
+
+    output.TexCoord = input.TexCoord;
+    output.Normal = mul(input.Normal, (float3x3) gWorldMatrix);
+    output.Tangent = mul(input.Tangent, (float3x3) gWorldMatrix);
+
+    // Calculate shadow map coordinates
+    // lightSpaceMatrix * vec4(vs_out.FragPos, 1.0);
+    output.ShadowCoord = mul(float4(input.Position, 1.f) , gLightWorldViewProj);
+    return output;
+}
+
+// Shadow sampling function
+float ShadowCalculation(float4 shadowCoord, float3 normal) {
+    // Normalize the depth by dividing by the w component
+    float3 projCoord = shadowCoord.xyz / shadowCoord.w;
+
+    float shadow = 0.0;
+    uint width, height;
+    gShadowMap.GetDimensions(width, height);
+    float2 texelSize = float2(1.f / width, 1.f / height);
+
+    // Convert from [-1, 1] to [0, 1]
+    float2 UVCoords;
+    UVCoords.x = 0.5f * projCoord.x + 0.5f;
+    UVCoords.y = -0.5f * projCoord.y + 0.5f;
+    float z = projCoord.z;
+
+    float bias = max(0.05 * (1.0 - dot(normal, -gLightDirection)), 0.005);
+
+    for(int x = -1; x <= 1; ++x)
+    {
+        for(int y = -1; y <= 1; ++y)
+        {
+            float pcfDepth = gShadowMap.Sample(gShadowSampler2, UVCoords.xy + float2(x, y) * texelSize).r;
+            shadow += z - bias > pcfDepth ? 1.0 : 0.0;
+        }
+    }
+
+    shadow /= 9.0f;
+
+
+    if(projCoord.z > 1.0)
+            shadow = 0.0;
+
+    return shadow;
+}
+// Pixel shader
+// float4 PS(VS_OUTPUT input) : SV_TARGET {
+//     float shadowFactor = ShadowCalculation(input.ShadowCoord, input.Normal);
+//
+//     float3 diffuseColor = gDiffuseMap.Sample(gSampleState, input.TexCoord).rgb;
+//
+//     float3 finalColor = diffuseColor * (1 - shadowFactor);
+//     finalColor += gAmbient;
+//
+//     return float4(finalColor, 1.0f);
+// }
+
+float4 PS(VS_OUTPUT input) : SV_TARGET {
+    float3 color = gDiffuseMap.Sample(gSampleState, input.TexCoord).rgb;
+    float3 normal = normalize(input.Normal);
+
+    float3 lightDir = normalize(-gLightDirection);
+    float3 viewDir = normalize(gCameraPosition - input.WorldPosition.xyz);
+
+    float3 ambient = gAmbient;
+
+    float diff = max(dot(normal, lightDir), 0.0);
+
+    float3 diffuse = gLightColor * diff * color;
+
+    float3 reflectDir = reflect(-lightDir, normal);
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
+    float3 specular = gLightColor * spec;
+
+    float shadow = ShadowCalculation(input.ShadowCoord, normal);
+    float3 lighting = (ambient + (1.0 - shadow) * (diffuse + specular)) * color;
+
+    return float4(lighting, 1.0f);
+}
+
+// DepthStencilState
+DepthStencilState gDepthStencilState {
+    DepthEnable = true;
+    DepthWriteMask = ALL;
+    DepthFunc = LESS;
+    StencilEnable = true;
+};
+
+
+// Technique
+technique11 DefaultTechnique {
+    pass P0 {
+        SetDepthStencilState(ShadowDepthStencilState, 0);
+        SetRasterizerState(gRasterizerState);
+        SetVertexShader(CompileShader(vs_5_0, VS()));
+        SetGeometryShader(NULL);
+        SetPixelShader(CompileShader(ps_5_0, PS()));
+    }
+}

project/resources/shadowEffect.fx

@@ -0,0 +1,47 @@
+float4x4 gLightWorldViewProj : WorldViewProjection;
+float4x4 gWorldViewProj: WorldViewProjection; //For compatibility sake
+
+struct VS_Input {
+    float3 Position : POSITION;
+    float2 TexCoord : TEXCOORD;
+    float3 Normal : NORMAL;
+    float3 Tangent : TANGENT;
+};
+struct VS_Output
+{
+    float4 Position : SV_POSITION;
+};
+
+VS_Output VS_Shadow(VS_Input input)
+{
+    VS_Output output;
+    // Transform vertex position to light's clip space
+    output.Position = mul(float4(input.Position, 1.0f), gLightWorldViewProj);
+    return output;
+}
+
+float4 PS_Shadow(VS_Output input) : SV_TARGET
+{
+    // Output depth information (Z/W in clip space)
+    //    // gl_FragDepth = gl_FragCoord.z;
+    return float4(input.Position.z / input.Position.w, 0.0f, 0.0f, input.Position.z / input.Position.w);
+}
+
+// Rasterizer state for front face culling
+RasterizerState FrontFaceCull
+{
+    FrontCounterClockwise = FALSE;
+    CullMode = FRONT;
+};
+
+// Technique for rendering shadow map
+technique11 DefaultTechnique
+{
+    pass P0
+    {
+        //Set FrontFaceCulling
+        SetRasterizerState(FrontFaceCull);
+        SetVertexShader(CompileShader(vs_5_0, VS_Shadow()));
+        SetPixelShader(CompileShader(ps_5_0, PS_Shadow()));
+    }
+}

project/src/BRDF.h

@@ -0,0 +1,25 @@
+//
+// Created by Bram on 17/01/2025.
+//
+
+#ifndef GP1_DIRECTX_BRDF_H
+#define GP1_DIRECTX_BRDF_H
+
+#include "ColorRGB.h"
+#include "./math/Vector3.h"
+
+namespace dae{
+    static ColorRGB Phong(const ColorRGB& specularReflectance, float exp, const Vector3& lightDir, const Vector3& viewDir, const Vector3& normal)
+    {
+        const Vector3 reflect{ Vector3::Reflect(lightDir, normal) };
+        const float dot{ Saturate(Vector3::Dot(reflect, -viewDir)) };
+        return specularReflectance * powf(dot, exp);
+    }
+
+    static ColorRGB Lambert(float kd, const ColorRGB& diffuse)
+    {
+        return kd * diffuse;
+    }
+}
+
+#endif //GP1_DIRECTX_BRDF_H

project/src/Buffers/DX11Viewport.cpp

@@ -0,0 +1,35 @@
+//
+// Created by Bram on 16/01/2025.
+//
+
+#include "DX11Viewport.h"
+
+DX11Viewport::DX11Viewport(float width, float height, float topLeftX, float topLeftY, float minDepth, float maxDepth) {
+    viewport.Width = width;
+    viewport.Height = height;
+    viewport.TopLeftX = topLeftX;
+    viewport.TopLeftY = topLeftY;
+    viewport.MinDepth = minDepth;
+    viewport.MaxDepth = maxDepth;
+}
+
+void DX11Viewport::Apply(ID3D11DeviceContext *context) {
+    if (context) {
+        context->RSSetViewports(1, &viewport);
+    }
+}
+
+void DX11Viewport::SetDimensions(float width, float height) {
+    viewport.Width = width;
+    viewport.Height = height;
+}
+
+void DX11Viewport::SetPosition(float topLeftX, float topLeftY) {
+    viewport.TopLeftX = topLeftX;
+    viewport.TopLeftY = topLeftY;
+}
+
+void DX11Viewport::SetDepthRange(float minDepth, float maxDepth) {
+    viewport.MinDepth = minDepth;
+    viewport.MaxDepth = maxDepth;
+}

project/src/Buffers/DX11Viewport.h

@@ -0,0 +1,24 @@
+#ifndef GP1_DIRECTX_DX11VIEWPORT_H
+#define GP1_DIRECTX_DX11VIEWPORT_H
+
+#include <d3d11.h>
+
+class DX11Viewport {
+public:
+    DX11Viewport(float width, float height, float topLeftX = 0.0f, float topLeftY = 0.0f, float minDepth = 0.0f, float maxDepth = 1.0f);
+
+    void Apply(ID3D11DeviceContext *context);
+
+    void SetDimensions(float width, float height);
+
+    void SetPosition(float topLeftX, float topLeftY);
+
+    void SetDepthRange(float minDepth, float maxDepth);
+
+    const D3D11_VIEWPORT &GetViewport() const { return viewport; }
+
+private:
+    D3D11_VIEWPORT viewport;
+};
+
+#endif //GP1_DIRECTX_DX11VIEWPORT_H

project/src/Buffers/DepthBuffer.cpp

@@ -0,0 +1,50 @@
+#include "DepthBuffer.h"
+
+DepthBuffer::DepthBuffer(ID3D11Device *device, UINT width, UINT height)
+        : m_device(device), m_width(width), m_height(height), m_depthBuffer(nullptr), m_depthStencilView(nullptr) {
+}
+
+DepthBuffer::~DepthBuffer() {
+    if (m_depthStencilView) m_depthStencilView->Release();
+    if (m_depthBuffer) m_depthBuffer->Release();
+}
+
+bool DepthBuffer::Initialize() {
+    // Create a depth buffer with a typeless format
+    D3D11_TEXTURE2D_DESC desc = {};
+    desc.Width = m_width;
+    desc.Height = m_height;
+    desc.MipLevels = 1;
+    desc.ArraySize = 1;
+    desc.Format = DXGI_FORMAT_R32_TYPELESS; // Typeless format
+    desc.SampleDesc.Count = 1;
+    desc.Usage = D3D11_USAGE_DEFAULT;
+    desc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE; // Add shader resource binding
+    desc.CPUAccessFlags = 0;
+    desc.MiscFlags = 0;
+
+    HRESULT hr = m_device->CreateTexture2D(&desc, nullptr, &m_depthBuffer);
+    if (FAILED(hr)) {
+        return false;
+    }
+
+    // Create DepthStencilView
+    D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc = {};
+    dsvDesc.Format = DXGI_FORMAT_D32_FLOAT; // Depth format
+    dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
+    dsvDesc.Texture2D.MipSlice = 0;
+    hr = m_device->CreateDepthStencilView(m_depthBuffer, &dsvDesc, &m_depthStencilView);
+    if (FAILED(hr)) {
+        return false;
+    }
+
+    return true;
+}
+
+ID3D11Texture2D *DepthBuffer::GetDepthBuffer() {
+    return m_depthBuffer;
+}
+
+ID3D11DepthStencilView *DepthBuffer::GetDepthStencilView() {
+    return m_depthStencilView;
+}

project/src/Buffers/DepthBuffer.h

@@ -0,0 +1,31 @@
+#ifndef GP1_DIRECTX_DEPTHBUFFER_H
+#define GP1_DIRECTX_DEPTHBUFFER_H
+
+#include <d3d11.h>
+
+class DepthBuffer
+{
+public:
+    DepthBuffer(ID3D11Device* device, UINT width, UINT height);
+    ~DepthBuffer();
+
+    bool Initialize();
+    ID3D11Texture2D* GetDepthBuffer() const { return m_depthBuffer; }
+    ID3D11DepthStencilView* GetDepthStencilView() const { return m_depthStencilView; }
+
+    ID3D11DepthStencilView *GetDepthStencilView();
+
+    ID3D11Texture2D *GetDepthBuffer();
+
+private:
+    ID3D11Device* m_device;
+    UINT m_width;
+    UINT m_height;
+
+    ID3D11Texture2D* m_depthBuffer;
+    ID3D11DepthStencilView* m_depthStencilView;
+
+};
+
+
+#endif //GP1_DIRECTX_DEPTHBUFFER_H

project/src/Buffers/SamplerState.cpp

@@ -0,0 +1,29 @@
+#include "SamplerState.h"
+
+SamplerState::SamplerState(ID3D11Device *device)
+        : m_device(device), m_samplerState(nullptr) {
+}
+
+SamplerState::~SamplerState() {
+    if (m_samplerState) m_samplerState->Release();
+}
+bool SamplerState::Initialize() {
+    D3D11_SAMPLER_DESC samplerDesc = {};
+    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
+    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
+    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
+//    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
+//    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
+//    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
+    samplerDesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
+    samplerDesc.MinLOD = 0;
+    samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
+
+    HRESULT hr = m_device->CreateSamplerState(&samplerDesc, &m_samplerState);
+    if (FAILED(hr)) {
+        return false;
+    }
+
+    return true;
+}

project/src/Buffers/SamplerState.h

@@ -0,0 +1,19 @@
+#ifndef GP1_DIRECTX_SAMPLERSTATE_H
+#define GP1_DIRECTX_SAMPLERSTATE_H
+
+#include <d3d11.h>
+
+class SamplerState
+{
+public:
+    SamplerState(ID3D11Device* device);
+    ~SamplerState();
+
+    bool Initialize();
+    ID3D11SamplerState* GetSamplerState() const { return m_samplerState; }
+private:
+    ID3D11Device* m_device;
+    ID3D11SamplerState* m_samplerState;
+};
+
+#endif //GP1_DIRECTX_SAMPLERSTATE_H

project/src/Buffers/ShadowMapBuffer.cpp

@@ -0,0 +1,50 @@
+#include "ShadowMapBuffer.h"
+
+ShadowMapBuffer::ShadowMapBuffer(ID3D11Device *device, UINT width, UINT height)
+        : m_device(device), m_width(width), m_height(height), m_shaderResourceView(nullptr),
+          m_depthBuffer(device, width, height), m_samplerState(device) {
+}
+
+ShadowMapBuffer::~ShadowMapBuffer() {
+    if (m_shaderResourceView) m_shaderResourceView->Release();
+}
+bool ShadowMapBuffer::Initialize() {
+    if (!m_depthBuffer.Initialize()) {
+        return false;
+    }
+
+    if (!m_samplerState.Initialize()) {
+        return false;
+    }
+
+    // Create ShaderResourceView for the depth buffer
+    D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
+    srvDesc.Format = DXGI_FORMAT_R32_FLOAT; // Shader-readable format
+    srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+    srvDesc.Texture2D.MipLevels = 1;
+    srvDesc.Texture2D.MostDetailedMip = 0;
+
+    HRESULT hr = m_device->CreateShaderResourceView(m_depthBuffer.GetDepthBuffer(), &srvDesc, &m_shaderResourceView);
+    if (FAILED(hr))
+    {
+        OutputDebugStringA("Failed to create ShaderResourceView for ShadowMapBuffer.\n");
+        return false;
+    }
+
+    return true;
+}
+
+
+void ShadowMapBuffer::SetRenderTarget(ID3D11DeviceContext *deviceContext) {
+    deviceContext->OMSetRenderTargets(0, nullptr, m_depthBuffer.GetDepthStencilView());
+}
+
+
+void ShadowMapBuffer::ResetRenderTarget(ID3D11DeviceContext *deviceContext) {
+    ID3D11RenderTargetView *nullRTV = nullptr;
+    deviceContext->OMSetRenderTargets(1, &nullRTV, nullptr);
+}
+
+ID3D11DepthStencilView *ShadowMapBuffer::GetDepthStencilView() {
+    return m_depthBuffer.GetDepthStencilView();
+}

project/src/Buffers/ShadowMapBuffer.h

@@ -0,0 +1,37 @@
+#ifndef GP1_DIRECTX_SHADOWMAPBUFFER_H
+#define GP1_DIRECTX_SHADOWMAPBUFFER_H
+
+#include <d3d11.h>
+#include <DirectXMath.h>
+#include "DepthBuffer.h"
+#include "SamplerState.h"
+
+class ShadowMapBuffer {
+public:
+    ShadowMapBuffer(ID3D11Device *device, UINT width, UINT height);
+
+    ~ShadowMapBuffer();
+
+    bool Initialize();
+
+    void SetRenderTarget(ID3D11DeviceContext *deviceContext);
+
+    void ResetRenderTarget(ID3D11DeviceContext *deviceContext);
+
+    ID3D11ShaderResourceView *GetShaderResourceView() const { return m_shaderResourceView; }
+
+    ID3D11SamplerState *GetSamplerState() const { return m_samplerState.GetSamplerState(); }
+
+    ID3D11DepthStencilView *GetDepthStencilView();
+private:
+    ID3D11Device *m_device;
+    UINT m_width;
+    UINT m_height;
+
+    DepthBuffer m_depthBuffer;
+    SamplerState m_samplerState;
+
+    ID3D11ShaderResourceView *m_shaderResourceView;
+};
+
+#endif //GP1_DIRECTX_SHADOWMAPBUFFER_H

project/src/Camera.cpp

@@ -193,7 +193,7 @@ const dae::Vector3 & dae::Camera::GetPosition() const {
     return origin;
 }
 
-const dae::Vector3 dae::Camera::GetRotation() const {
+dae::Vector3 dae::Camera::GetRotation() const {
     return {totalPitch, totalYaw, 0.f};
 }
 

project/src/Camera.h

@@ -11,7 +11,7 @@
 #include "Math/Matrix.h"
 
 namespace dae {
-    class Camera {
+    class Camera final {
     public:
         Camera() = default;
 
@@ -32,7 +32,7 @@ namespace dae {
         const Vector3 & GetPosition() const;
         void SetPosition(const Vector3& position);
 
-        const Vector3 GetRotation() const;
+        Vector3 GetRotation() const;
         void SetRotation(const Vector3& rotation);
 
     private:

project/src/DirectionalLight.cpp

@@ -0,0 +1,53 @@
+#include "DirectionalLight.h"
+#include <cmath>
+
+DirectionalLight::DirectionalLight()
+        : m_Position(0.0f, 10.0f, 0.0f),
+          m_Target(0.0f, 0.0f, 0.0f),
+          m_Up(0.0f, 1.0f, 0.0f),
+          m_ViewMatrix(dae::Matrix()),
+          m_ProjectionMatrix(dae::Matrix()) {}
+
+void DirectionalLight::SetPosition(const dae::Vector3 &position) {
+    m_Position = position;
+}
+
+void DirectionalLight::SetTarget(const dae::Vector3 &target) {
+    m_Target = target;
+}
+
+void DirectionalLight::SetUp(const dae::Vector3 &up) {
+    m_Up = up;
+}
+
+dae::Matrix DirectionalLight::GetViewMatrix() const {
+    return dae::Matrix::CreateLookAtLH(m_Position, m_Target, m_Up);
+}
+
+dae::Matrix DirectionalLight::GetProjectionMatrix(float nearPlane, float farPlane, float size) const {
+    return dae::Matrix::CreateOrthographic(size, size, nearPlane, farPlane);
+}
+
+dae::Matrix DirectionalLight::GetViewProjectionMatrix(float nearPlane, float farPlane, float size) const {
+    return GetViewMatrix() * GetProjectionMatrix(nearPlane, farPlane, size);
+}
+
+void DirectionalLight::Update() {
+    // If the light position or target changes dynamically, this is where updates would be managed.
+//    m_ViewMatrix = dae::Matrix::CreateLookAtLH(m_Position, m_Target, m_Up);
+//    m_ProjectionMatrix = dae::Matrix::CreateOrthographic(size, size, nearPlane, farPlane);
+}
+
+dae::Vector3 DirectionalLight::GetTarget() {
+    return m_Target;
+}
+
+dae::Vector3 DirectionalLight::GetPosition() {
+    return m_Position;
+}
+
+void DirectionalLight::SetColor(const dae::ColorRGB &color) { m_Color = color; }
+
+dae::Vector3 DirectionalLight::GetDirection() const { return m_Target - m_Position; }
+
+dae::ColorRGB DirectionalLight::GetColor() const { return m_Color; }

project/src/DirectionalLight.h

@@ -0,0 +1,40 @@
+#ifndef GP1_DIRECTX_DIRECTIONALLIGHT_H
+#define GP1_DIRECTX_DIRECTIONALLIGHT_H
+
+
+#include "Math/Vector3.h"
+#include "Math/Matrix.h"
+#include "ColorRGB.h"
+
+class DirectionalLight {
+public:
+    DirectionalLight();
+    ~DirectionalLight() = default;
+
+    void SetPosition(const dae::Vector3 &position);
+    void SetTarget(const dae::Vector3 &target);
+    void SetUp(const dae::Vector3 &up);
+    void SetColor(const dae::ColorRGB &color);
+
+    dae::Matrix GetViewMatrix() const;
+    dae::Matrix GetProjectionMatrix(float nearPlane = 0.1f, float farPlane = 100.0f, float size = 50.0f) const;
+    dae::Matrix GetViewProjectionMatrix(float nearPlane = 0.1f, float farPlane = 100.0f, float size = 50.0f) const;
+
+    void Update();
+
+    dae::Vector3 GetTarget();
+    dae::Vector3 GetPosition();
+    dae::Vector3 GetDirection() const;
+    dae::ColorRGB GetColor() const;
+private:
+    dae::Vector3 m_Position;
+    dae::Vector3 m_Target;
+    dae::Vector3 m_Up;
+
+    dae::ColorRGB m_Color{1.f, 1.f, 1.f};
+
+    dae::Matrix m_ViewMatrix;
+    dae::Matrix m_ProjectionMatrix;
+};
+
+#endif //GP1_DIRECTX_DIRECTIONALLIGHT_H

project/src/Effects/BaseEffect.cpp

@@ -73,7 +73,6 @@ void BaseEffect::SetWorldViewProjMatrix(const dae::Matrix &matrix) {
 }
 
 void BaseEffect::NextSamplingState() {
-
 }
 
 void BaseEffect::SetCameraPos(const dae::Vector3 &vector3) const {

project/src/Effects/BaseEffect.h

@@ -1,7 +1,3 @@
-//
-// Created by Bram on 20/12/2024.
-//
-
 #ifndef GP1_DIRECTX_BASEEFFECT_H
 #define GP1_DIRECTX_BASEEFFECT_H
 

project/src/Effects/Effect.cpp

@@ -52,6 +52,7 @@ Effect::Effect(ID3D11Device *devicePtr, const std::wstring &filePath)
     if(!m_RasterizerVariablePtr->IsValid())
         std::wcout << L"gRasterizerState Rasterizer is not valid" << std::endl;
 
+
     m_UseNormalMapVariablePtr->SetBool(m_UseNormalMap);
 
 
@@ -201,4 +202,4 @@ void Effect::InitRasterizer(ID3D11Device *devicePtr) {
     rasterDesc.CullMode = D3D11_CULL_NONE;
 
     devicePtr->CreateRasterizerState(&rasterDesc, &m_RasterizerStates[static_cast<int>(CullMode::None)]);
-}
+}

project/src/Effects/Effect.h

@@ -3,16 +3,13 @@
 #include "BaseEffect.h"
 #include <array>
 
-
-
 enum class CullMode {
     None = 0,
     Front = 1,
     Back = 2
 };
 
-
-class Effect: public BaseEffect {
+class Effect final: public BaseEffect {
 public:
     Effect(ID3D11Device *devicePtr, const std::wstring &filePath);
 
@@ -60,4 +57,4 @@ private:
     CullMode m_CullMode{ CullMode::Back };
 
     bool m_UseNormalMap{true};
-};
+};

project/src/Effects/FireEffect.h

@@ -9,7 +9,7 @@
 #include <array>
 #include "BaseEffect.h"
 
-class FireEffect: public BaseEffect {
+class FireEffect final : public BaseEffect {
 public:
     FireEffect(ID3D11Device *devicePtr, const std::wstring &filePath);
 
@@ -20,14 +20,13 @@ public:
     void NextSamplingState() override;
 
 private:
-    void InitSamplers(ID3D11Device* devicePtr);
-
+    void InitSamplers(ID3D11Device *devicePtr);
 
     ID3DX11EffectShaderResourceVariable *m_DiffuseMapVariablePtr{};
 
     ID3DX11EffectSamplerVariable *m_SamplerVariablePtr{};
 
-    std::array<ID3D11SamplerState*, 3> m_SamplerStates{};
+    std::array<ID3D11SamplerState *, 3> m_SamplerStates{};
 
     TechniqueType m_TechniqueType{TechniqueType::Linear};
 

project/src/Effects/ShadowDiffuse.cpp

@@ -0,0 +1,247 @@
+#include "../pch.h"
+#include "ShadowDiffuse.h"
+#include "../Utils.h"
+
+#include <fstream>
+
+ShadowDiffuse::ShadowDiffuse(ID3D11Device *devicePtr, const std::wstring &filePath)
+        : BaseEffect(devicePtr, filePath) {
+
+    m_LightPosVariablePtr = m_EffectPtr->GetVariableByName("gLightDirection")->AsVector();
+    if (!m_LightPosVariablePtr->IsValid())
+        std::wcout << L"gLightDirection Vector is not valid" << std::endl;
+
+
+    m_SamplerVariablePtr = m_EffectPtr->GetVariableByName("gSampleState")->AsSampler();
+    if (!m_SamplerVariablePtr->IsValid())
+        std::wcout << L"gSampleState Sampler is not valid" << std::endl;
+
+    m_MatWorldVariablePtr = m_EffectPtr->GetVariableByName("gWorldMatrix")->AsMatrix();
+    if (!m_MatWorldVariablePtr->IsValid())
+        std::wcout << L"gWorld Matrix is not valid" << std::endl;
+
+    m_DiffuseMapVariablePtr = m_EffectPtr->GetVariableByName("gDiffuseMap")->AsShaderResource();
+    if (!m_DiffuseMapVariablePtr->IsValid())
+        std::wcout << L"gDiffuseMap ShaderResource is not valid" << std::endl;
+
+    m_NormalMapVariablePtr = m_EffectPtr->GetVariableByName("gNormalMap")->AsShaderResource();
+    if (!m_NormalMapVariablePtr->IsValid())
+        std::wcout << L"gNormalMap ShaderResource is not valid" << std::endl;
+
+    m_SpecularMapVariablePtr = m_EffectPtr->GetVariableByName("gSpecularMap")->AsShaderResource();
+    if (!m_SpecularMapVariablePtr->IsValid())
+        std::wcout << L"gSpecularMap ShaderResource is not valid" << std::endl;
+
+    m_GlossMapVariablePtr = m_EffectPtr->GetVariableByName("gGlossMap")->AsShaderResource();
+    if (!m_GlossMapVariablePtr->IsValid())
+        std::wcout << L"gGlossMap ShaderResource is not valid" << std::endl;
+
+    m_CameraPosVariablePtr = m_EffectPtr->GetVariableByName("gCameraPosition")->AsVector();
+    if (!m_CameraPosVariablePtr->IsValid())
+        std::wcout << L"gCameraPos Vector is not valid" << std::endl;
+
+    m_LightColorVariablePtr = m_EffectPtr->GetVariableByName("gLightColor")->AsVector();
+    if (!m_LightColorVariablePtr->IsValid())
+        std::wcout << L"gLightColor Vector is not valid" << std::endl;
+
+    m_UseNormalMapVariablePtr = m_EffectPtr->GetVariableByName("gUseNormal")->AsScalar();
+    if (!m_UseNormalMapVariablePtr->IsValid())
+        std::wcout << L"gUseNormalMap Scalar is not valid" << std::endl;
+
+    m_RasterizerVariablePtr = m_EffectPtr->GetVariableByName("gRasterizerState")->AsRasterizer();
+    if (!m_RasterizerVariablePtr->IsValid())
+        std::wcout << L"gRasterizerState Rasterizer is not valid" << std::endl;
+
+    m_ShadowMapVariablePtr = m_EffectPtr->GetVariableByName("gShadowMap")->AsShaderResource();
+    if (!m_ShadowMapVariablePtr->IsValid())
+        std::wcout << L"gShadowMapSampler Sampler is not valid" << std::endl;
+
+    m_LightWorldViewProjVariablePtr = m_EffectPtr->GetVariableByName("gLightWorldViewProj")->AsMatrix();
+    if (!m_LightWorldViewProjVariablePtr->IsValid())
+        std::wcout << L"gLightWorldViewProj Matrix is not valid" << std::endl;
+
+    m_LightDirectionVariablePtr = m_EffectPtr->GetVariableByName("gLightDirection")->AsVector();
+    if (!m_LightDirectionVariablePtr->IsValid())
+        std::wcout << L"gLightDirection Vector is not valid" << std::endl;
+
+    m_LightColorVariablePtr = m_EffectPtr->GetVariableByName("gLightColor")->AsVector();
+    if (!m_LightColorVariablePtr->IsValid())
+        std::wcout << L"gLightColor Vector is not valid" << std::endl;
+
+    m_UseNormalMapVariablePtr->SetBool(m_UseNormalMap);
+
+    constexpr int vectorSize{4};
+    constexpr float lightDirection[vectorSize]{.577f, -.577f, .577f, 0.f};
+    m_LightPosVariablePtr->SetFloatVector(lightDirection);
+
+    constexpr float lightColor[vectorSize]{1.f, 1.f, 1.f, 1.f};
+    m_LightColorVariablePtr->SetFloatVector(lightColor);
+
+    this->InitSamplers(devicePtr);
+    this->InitRasterizer(devicePtr);
+
+    m_SamplerVariablePtr->SetSampler(0, m_SamplerStates[static_cast<int>(m_TechniqueType)]);
+    m_RasterizerVariablePtr->SetRasterizerState(0, m_RasterizerStates[static_cast<int>(m_CullMode)]);
+}
+
+ShadowDiffuse::~ShadowDiffuse() {
+    m_MatWorldVariablePtr->Release();
+    m_MatWorldVariablePtr = nullptr;
+
+    m_DiffuseMapVariablePtr->Release();
+    m_DiffuseMapVariablePtr = nullptr;
+
+    m_NormalMapVariablePtr->Release();
+    m_NormalMapVariablePtr = nullptr;
+
+    m_SpecularMapVariablePtr->Release();
+    m_SpecularMapVariablePtr = nullptr;
+
+    m_GlossMapVariablePtr->Release();
+    m_GlossMapVariablePtr = nullptr;
+
+    m_CameraPosVariablePtr->Release();
+    m_CameraPosVariablePtr = nullptr;
+
+    m_LightPosVariablePtr->Release();
+    m_LightPosVariablePtr = nullptr;
+
+    m_LightColorVariablePtr->Release();
+    m_LightColorVariablePtr = nullptr;
+
+    m_UseNormalMapVariablePtr->Release();
+    m_UseNormalMapVariablePtr = nullptr;
+
+    m_SamplerVariablePtr->Release();
+    m_SamplerVariablePtr = nullptr;
+
+    m_RasterizerVariablePtr->Release();
+    m_RasterizerVariablePtr = nullptr;
+
+    m_LightDirectionVariablePtr->Release();
+    m_LightDirectionVariablePtr = nullptr;
+
+    if (m_ShadowMapVariablePtr) {
+        m_ShadowMapVariablePtr->Release();
+        m_ShadowMapVariablePtr = nullptr;
+    }
+    if (m_LightWorldViewProjVariablePtr) {
+        m_LightWorldViewProjVariablePtr->Release();
+        m_LightWorldViewProjVariablePtr = nullptr;
+    }
+
+
+    for (auto sampler: m_SamplerStates) {
+        sampler->Release();
+    }
+
+    for (auto rasterizer: m_RasterizerStates) {
+        rasterizer->Release();
+    }
+
+    m_EffectPtr->Release();
+    m_EffectPtr = nullptr;
+}
+
+void ShadowDiffuse::SetWorldMatrix(const dae::Matrix &world) const {
+    m_MatWorldVariablePtr->SetMatrix(reinterpret_cast<const float *>(&world));
+}
+
+void ShadowDiffuse::SetMaterial(Material *material) {
+    if (material->diffuseTexturePtr)
+        m_DiffuseMapVariablePtr->SetResource(material->diffuseTexturePtr->GetSrv());
+    if (material->normalTexturePtr)
+        m_NormalMapVariablePtr->SetResource(material->normalTexturePtr->GetSrv());
+    if (material->specularTexturePtr)
+        m_SpecularMapVariablePtr->SetResource(material->specularTexturePtr->GetSrv());
+    if (material->glossTexturePtr)
+        m_GlossMapVariablePtr->SetResource(material->glossTexturePtr->GetSrv());
+}
+
+void ShadowDiffuse::SetCameraPos(const dae::Vector3 &pos) const {
+    m_CameraPosVariablePtr->SetFloatVector(reinterpret_cast<const float *>(&pos));
+}
+
+void ShadowDiffuse::NextSamplingState() {
+    switch (m_TechniqueType) {
+        case TechniqueType::Point:
+            m_TechniqueType = TechniqueType::Linear;
+            break;
+        case TechniqueType::Linear:
+            m_TechniqueType = TechniqueType::Anisotropic;
+            break;
+        case TechniqueType::Anisotropic:
+            m_TechniqueType = TechniqueType::Point;
+            break;
+    }
+    m_SamplerVariablePtr->SetSampler(0, m_SamplerStates[static_cast<int>(m_TechniqueType)]);
+}
+
+void ShadowDiffuse::ToggleNormals() {
+    m_UseNormalMap = !m_UseNormalMap;
+    m_UseNormalMapVariablePtr->SetBool(m_UseNormalMap);
+}
+
+void ShadowDiffuse::InitSamplers(ID3D11Device *devicePtr) {
+    D3D11_SAMPLER_DESC samplerDesc{};
+    samplerDesc.Filter = D3D11_FILTER_ANISOTROPIC;
+    samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
+    samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
+    samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
+    samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
+
+    devicePtr->CreateSamplerState(&samplerDesc, &m_SamplerStates[static_cast<int>(TechniqueType::Anisotropic)]);
+
+    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+    devicePtr->CreateSamplerState(&samplerDesc, &m_SamplerStates[static_cast<int>(TechniqueType::Linear)]);
+
+    samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
+    devicePtr->CreateSamplerState(&samplerDesc, &m_SamplerStates[static_cast<int>(TechniqueType::Point)]);
+
+    m_SamplerVariablePtr->SetSampler(0, m_SamplerStates[static_cast<int>(m_TechniqueType)]);
+}
+
+void ShadowDiffuse::NextCullMode() {
+    m_CullMode = static_cast<CullMode>((static_cast<int>(m_CullMode) + 1) % 3);
+    m_RasterizerVariablePtr->SetRasterizerState(0, m_RasterizerStates[static_cast<int>(m_CullMode)]);
+}
+
+void ShadowDiffuse::InitRasterizer(ID3D11Device *devicePtr) {
+    D3D11_RASTERIZER_DESC rasterDesc = {};
+    rasterDesc.FillMode = D3D11_FILL_SOLID;  // Solid fill
+    rasterDesc.FrontCounterClockwise = FALSE;
+    rasterDesc.DepthBias = D3D11_DEFAULT_DEPTH_BIAS;
+    rasterDesc.SlopeScaledDepthBias = D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;
+    rasterDesc.DepthClipEnable = TRUE;
+    rasterDesc.ScissorEnable = FALSE;
+    rasterDesc.MultisampleEnable = FALSE;
+    rasterDesc.AntialiasedLineEnable = FALSE;
+
+    rasterDesc.CullMode = D3D11_CULL_BACK;   // Cull back faces
+
+    devicePtr->CreateRasterizerState(&rasterDesc, &m_RasterizerStates[static_cast<int>(CullMode::Back)]);
+
+    rasterDesc.CullMode = D3D11_CULL_FRONT;
+
+    devicePtr->CreateRasterizerState(&rasterDesc, &m_RasterizerStates[static_cast<int>(CullMode::Front)]);
+
+    rasterDesc.CullMode = D3D11_CULL_NONE;
+
+    devicePtr->CreateRasterizerState(&rasterDesc, &m_RasterizerStates[static_cast<int>(CullMode::None)]);
+}
+
+void ShadowDiffuse::SetShadowMap(ID3D11ShaderResourceView *shadowMapSRV) {
+    m_ShadowMapVariablePtr->SetResource(shadowMapSRV);
+}
+
+void ShadowDiffuse::SetLightViewProjMatrix(Matrix matrix) {
+    m_LightWorldViewProjVariablePtr->SetMatrix(reinterpret_cast<const float *>(&matrix));
+}
+
+void ShadowDiffuse::SetLightDirection(Vector3 direction) {
+    m_LightDirectionVariablePtr->SetFloatVector(reinterpret_cast<const float *>(&direction));
+}
+
+void ShadowDiffuse::SetLightColor(ColorRGB rgb) {
+    m_LightColorVariablePtr->SetFloatVector(reinterpret_cast<const float *>(&rgb));
+}

project/src/Effects/ShadowDiffuse.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "BaseEffect.h"
+#include "Effect.h"
+#include <array>
+
+class ShadowDiffuse final: public BaseEffect {
+public:
+    ShadowDiffuse(ID3D11Device *devicePtr, const std::wstring &filePath);
+
+    virtual ~ShadowDiffuse() override;
+
+    void SetWorldMatrix(const dae::Matrix &world) const override;
+
+    void SetCameraPos(const dae::Vector3 &pos) const override;
+
+    void SetMaterial(Material *material) override;
+
+    void ToggleNormals() override;
+
+    void NextSamplingState() override;
+
+    void NextCullMode() override;
+
+    void SetShadowMap(ID3D11ShaderResourceView* shadowMapSRV);
+
+    void SetLightViewProjMatrix(Matrix matrix);
+
+    void SetLightDirection(Vector3 direction);
+
+    void SetLightColor(ColorRGB rgb);
+
+private:
+    void InitSamplers(ID3D11Device* devicePtr);
+    void InitRasterizer(ID3D11Device* devicePtr);
+
+    ID3DX11EffectMatrixVariable *m_MatWorldVariablePtr{};
+
+    ID3DX11EffectShaderResourceVariable *m_DiffuseMapVariablePtr{};
+    ID3DX11EffectShaderResourceVariable *m_NormalMapVariablePtr{};
+    ID3DX11EffectShaderResourceVariable *m_SpecularMapVariablePtr{};
+    ID3DX11EffectShaderResourceVariable *m_GlossMapVariablePtr{};
+
+    ID3DX11EffectVectorVariable *m_CameraPosVariablePtr{};
+    ID3DX11EffectVectorVariable *m_LightPosVariablePtr{};
+    ID3DX11EffectVectorVariable *m_LightColorVariablePtr{};
+    ID3DX11EffectVectorVariable *m_LightDirectionVariablePtr{};
+
+    ID3DX11EffectScalarVariable *m_UseNormalMapVariablePtr{};
+
+    ID3DX11EffectSamplerVariable *m_SamplerVariablePtr{};
+
+    ID3DX11EffectRasterizerVariable* m_RasterizerVariablePtr{};
+
+    ID3DX11EffectMatrixVariable* m_LightWorldViewProjVariablePtr{};
+
+    ID3DX11EffectShaderResourceVariable* m_ShadowMapVariablePtr{};
+
+    TechniqueType m_TechniqueType{TechniqueType::Linear};
+
+    std::array<ID3D11SamplerState*, 3> m_SamplerStates{};
+    std::array<ID3D11RasterizerState*, 3> m_RasterizerStates{};
+
+    CullMode m_CullMode{ CullMode::Back };
+
+    bool m_UseNormalMap{true};
+};

project/src/Effects/ShadowEffect.cpp

@@ -0,0 +1,64 @@
+//
+// Created by Bram on 13/01/2025.
+//
+
+#include "ShadowEffect.h"
+
+ShadowEffect::ShadowEffect(ID3D11Device *devicePtr, const std::wstring &filePath)
+        : BaseEffect(devicePtr, filePath) {
+    // Retrieve shadow-specific variables
+    m_LightWorldViewProjVariable = m_EffectPtr->GetVariableByName("gLightWorldViewProj")->AsMatrix();
+    if (!m_LightWorldViewProjVariable->IsValid()) {
+        throw std::runtime_error("Failed to retrieve gLightWorldViewProj variable in ShadowEffect.");
+    }
+
+
+//    m_ShadowMapVariable = m_EffectPtr->GetVariableByName("gShadowMap")->AsShaderResource();
+//    if (!m_ShadowMapVariable->IsValid()) {
+//        throw std::runtime_error("Failed to retrieve gShadowMap variable in ShadowEffect.");
+//    }
+//
+
+//    m_ShadowMapSamplerVariable = m_EffectPtr->GetVariableByName("gShadowMapSampler")->AsSampler();
+//    if (!m_ShadowMapSamplerVariable->IsValid()) {
+//        throw std::runtime_error("Failed to retrieve gShadowMapSampler variable in ShadowEffect.");
+//    }
+}
+
+void ShadowEffect::SetLightWorldViewProjMatrix(const Matrix &matrix) {
+    if (m_LightWorldViewProjVariable) {
+        m_LightWorldViewProjVariable->SetMatrix(reinterpret_cast<const float*>(&matrix));
+    }
+}
+
+void ShadowEffect::SetShadowMap(ID3D11ShaderResourceView *shadowMapSRV) {
+    if (m_ShadowMapVariable) {
+        m_ShadowMapVariable->SetResource(shadowMapSRV);
+    }
+}
+void ShadowEffect::SetShadowMapSampler(ID3D11SamplerState *samplerState) {
+    if (m_ShadowMapSamplerVariable) {
+        m_ShadowMapSamplerVariable->SetSampler(0, samplerState);
+    }
+}
+
+ShadowEffect::~ShadowEffect() {
+    if (m_LightWorldViewProjVariable) {
+        m_LightWorldViewProjVariable->Release();
+        m_LightWorldViewProjVariable = nullptr;
+    }
+
+    if (m_ShadowMapVariable) {
+        m_ShadowMapVariable->Release();
+        m_ShadowMapVariable = nullptr;
+    }
+
+    if (m_ShadowMapSamplerVariable) {
+        m_ShadowMapSamplerVariable->Release();
+        m_ShadowMapSamplerVariable = nullptr;
+    }
+
+    m_EffectPtr->Release();
+    m_EffectPtr = nullptr;
+}
+

project/src/Effects/ShadowEffect.h

@@ -0,0 +1,23 @@
+
+#ifndef GP1_DIRECTX_SHADOWEFFECT_H
+#define GP1_DIRECTX_SHADOWEFFECT_H
+
+#include "BaseEffect.h"
+
+class ShadowEffect : public BaseEffect {
+public:
+    ShadowEffect(ID3D11Device* devicePtr, const std::wstring& filePath);
+
+    ~ShadowEffect() override;
+
+    void SetLightWorldViewProjMatrix(const dae::Matrix& matrix);
+    void SetShadowMap(ID3D11ShaderResourceView* shadowMapSRV);
+    void SetShadowMapSampler(ID3D11SamplerState* samplerState);
+
+private:
+    ID3DX11EffectMatrixVariable* m_LightWorldViewProjVariable{nullptr};
+    ID3DX11EffectShaderResourceVariable* m_ShadowMapVariable{nullptr};
+    ID3DX11EffectSamplerVariable* m_ShadowMapSamplerVariable{nullptr};
+};
+
+#endif //GP1_DIRECTX_SHADOWEFFECT_H

project/src/GamePadController.h

@@ -2,16 +2,17 @@
 #define GP1_DIRECTX_GAMEPADCONTROLLER_H
 
 #include <vector>
+#include <array>
 
 #include "SDL_gamecontroller.h"
 #include "SDL.h"
 
 
 struct GamePad{
-    bool buttons[SDL_CONTROLLER_BUTTON_MAX];
-    float axis[SDL_CONTROLLER_AXIS_MAX];
+    std::array<bool, SDL_CONTROLLER_BUTTON_MAX> buttons{false};
+    std::array<float, SDL_CONTROLLER_AXIS_MAX> axis{0.0f};
 
-    bool prevButtons[SDL_CONTROLLER_BUTTON_MAX]{ false };
+    std::array<bool, SDL_CONTROLLER_BUTTON_MAX> prevButtons{ false };
 };
 
 enum class GamePadButton {
@@ -42,7 +43,7 @@ enum class GamePadButton {
 
 enum Controllers {PLAYER1, PLAYER2, PLAYER3, PLAYER4};
 
-class GamePadController {
+class GamePadController final {
 public:
 
     static GamePadController& GetInstance()
@@ -66,7 +67,6 @@ private:
     GamePadController();
     std::vector<SDL_GameController*> m_pGameControllers;
     std::vector<GamePad> m_GamePads;
-
 };
 
 

project/src/HitTest.cpp

@@ -1,7 +1,5 @@
 #include "HitTest.h"
 
-
-
 float CrossZ(const Vector3& p0, const Vector3& p1, const Vector3& point)
 {
     return (p1.x - p0.x) * (point.y - p0.y)
@@ -70,4 +68,3 @@ std::optional<Sample> TriangleHitTest(const Vector3& fragPos, const VertexOut& v
             .mesh = v0.mesh
     };
 }
-

project/src/HitTest.h

@@ -7,11 +7,12 @@
 #include "Math/Vector3.h"
 #include "Math/Vector2.h"
 #include "Mesh.h"
+#include "Effects/Effect.h"
 
 using namespace dae;
 
 
-struct Sample
+struct Sample final
 {
     Vector2 uv{};
     Vector3 normal{};
@@ -23,6 +24,6 @@ struct Sample
 };
 
 
-std::optional<Sample> TriangleHitTest(const Vector3& fragPos, const VertexOut& v0, const VertexOut& v1, const VertexOut& v2);
+std::optional<Sample> TriangleHitTest(const Vector3 &fragPos, const VertexOut &v0, const VertexOut &v1, const VertexOut &v2);
 
 #endif //GP1_DIRECTX_HITTEST_H

project/src/InstancedMesh.cpp

@@ -2,8 +2,8 @@
 #include "InstancedMesh.h"
 
 InstancedMesh::InstancedMesh(ID3D11Device *devicePtr, const std::vector<VertexIn> &verticesIn, const std::vector<Uint32> &indices,
-                             std::shared_ptr<Material> material, BaseEffect *effectPtr, const std::vector<InstancedData> &instanceData)
-        : m_EffectPtr(effectPtr),
+                             std::shared_ptr<Material> material, std::unique_ptr<BaseEffect> effectPtr, const std::vector<InstancedData> &instanceData)
+        : m_EffectPtr(std::move(effectPtr)),
           m_InputLayoutPtr(nullptr),
           m_VertexBufferPtr(nullptr),
           m_IndexBufferPtr(nullptr),
@@ -152,9 +152,6 @@ InstancedMesh::~InstancedMesh() {
         m_InstanceBufferPtr = nullptr;
     }
 
-    delete m_EffectPtr;
-    m_EffectPtr = nullptr;
-
     m_Material.reset();
 
     m_InstancedData.clear();

project/src/InstancedMesh.h

@@ -13,10 +13,10 @@ struct alignas(16) InstancedData {
     Vector4 color;
 };
 
-class InstancedMesh {
+class InstancedMesh final {
 public:
     InstancedMesh(ID3D11Device *devicePtr, const std::vector<VertexIn> &verticesIn, const std::vector<Uint32> &indices,
-            std::shared_ptr<Material> material, BaseEffect* effectPtr, const std::vector<InstancedData>& instanceData);
+                  std::shared_ptr<Material> material, std::unique_ptr<BaseEffect> effectPtr, const std::vector<InstancedData>& instanceData);
 
     ~InstancedMesh();
 
@@ -26,7 +26,6 @@ public:
 
     Matrix GetWorldMatrix() const;
 
-
     Material* GetMaterial() const;
 
     void SetWorldMatrix(const Matrix &matrix);
@@ -40,7 +39,7 @@ public:
     void UpdateInstanceData(ID3D11DeviceContext* deviceContextPtr, const std::vector<InstancedData>& instanceData);
 
 private:
-    BaseEffect *m_EffectPtr;
+    std::unique_ptr<BaseEffect> m_EffectPtr;
 
     Matrix m_WorldMatrix{};
 

project/src/Material.h

@@ -3,7 +3,7 @@
 
 #include "Texture.h"
 
-struct Material {
+struct Material final {
     Texture *diffuseTexturePtr{nullptr};
     Texture *normalTexturePtr{nullptr};
     Texture *specularTexturePtr{nullptr};

project/src/Math/Matrix.cpp

@@ -302,5 +302,14 @@ namespace dae {
         data[3] = {vector3, 1};
     }
 
+    Matrix Matrix::CreateOrthographic(float width, float height, float zn, float zf) {
+        return Matrix(
+                {2.f / width, 0, 0, 0},
+                {0, 2.f / height, 0, 0},
+                {0, 0, 1.f / (zf - zn), 0},
+                {0, 0, -zn / (zf - zn), 1}
+        );
+    }
+
 #pragma endregion
 }

project/src/Math/Matrix.h

@@ -50,7 +50,7 @@ namespace dae {
 
 		static Matrix CreateLookAtLH(const Vector3& origin, const Vector3& forward, const Vector3& up);
 		static Matrix CreatePerspectiveFovLH(float fovy, float aspect, float zn, float zf);
-
+        static Matrix CreateOrthographic(float width, float height, float zn, float zf);
 		Vector4& operator[](int index);
 		Vector4 operator[](int index) const;
 		Matrix operator*(const Matrix& m) const;

project/src/Mesh.cpp

@@ -5,8 +5,8 @@
 
 #include "Effects/Effect.h"
 
-Mesh::Mesh(ID3D11Device *devicePtr, const std::vector<VertexIn> &verticesIn, const std::vector<Uint32> &indices, std::shared_ptr<Material> material, BaseEffect* effectPtr) :
-        m_EffectPtr(effectPtr),
+Mesh::Mesh(ID3D11Device *devicePtr, const std::vector<VertexIn> &verticesIn, const std::vector<Uint32> &indices, std::shared_ptr<Material> material, std::unique_ptr<BaseEffect> effectPtr) :
+        m_EffectPtr(std::move(effectPtr)),
         m_InputLayoutPtr(nullptr),
         m_VertexBufferPtr(nullptr),
         m_IndexBufferPtr(nullptr),
@@ -91,8 +91,6 @@ Mesh::~Mesh() {
     m_IndexBufferPtr->Release();
     m_IndexBufferPtr = nullptr;
 
-    delete m_EffectPtr;
-    m_EffectPtr = nullptr;
 }
 
 void Mesh::Render(ID3D11DeviceContext *deviceContextPtr, const Matrix &worldViewProj) const {

project/src/Mesh.h

@@ -19,12 +19,10 @@ enum class PrimitiveTopology {
 };
 
 
-
-
 class Mesh final {
 public:
     Mesh(ID3D11Device *devicePtr, const std::vector<VertexIn> &verticesIn, const std::vector<Uint32> &indices,
-         std::shared_ptr<Material> material, BaseEffect* effectPtr);
+         std::shared_ptr<Material> material, std::unique_ptr<BaseEffect> effectPtr);
 
     ~Mesh();
 
@@ -54,7 +52,7 @@ public:
     bool GetShouldRender() const { return m_ShouldRender; }
 
 private:
-    BaseEffect *m_EffectPtr;
+    std::unique_ptr<BaseEffect> m_EffectPtr;
 
     Matrix m_WorldMatrix{};
 

project/src/RenderSettings.h

@@ -0,0 +1,26 @@
+//
+// Created by Bram on 16/01/2025.
+//
+
+#ifndef GP1_DIRECTX_RENDERSETTINGS_H
+#define GP1_DIRECTX_RENDERSETTINGS_H
+
+#include "Singleton.h"
+
+class RenderSettings : public Singleton<RenderSettings> {
+public:
+    void setWidth(int w) { width = w; }
+    void setHeight(int h) { height = h; }
+    int getWidth() const { return width; }
+    int getHeight() const { return height; }
+
+private:
+    friend class Singleton<RenderSettings>;
+    RenderSettings() : width(1920), height(1080) {} // Default values
+
+    int width;
+    int height;
+};
+
+
+#endif //GP1_DIRECTX_RENDERSETTINGS_H

project/src/Renderer.cpp

@@ -4,12 +4,13 @@
 #include "Utils.h"
 #include "Texture.h"
 #include "Effects/Effect.h"
-#include "Effects/FireEffect.h"
 #include "HitTest.h"
 #include "Scenes/MainScene.h"
 #include "Scenes/DioramaScene.h"
 #include "Scenes/InstancedScene.h"
 #include "Scenes/PlanetScene.h"
+#include "Scenes/ShadowTestScene.h"
+#include "BRDF.h"
 
 
 namespace dae {
@@ -36,14 +37,14 @@ namespace dae {
 
         InitializeSDLRasterizer();
 
-        m_pScene = new MainScene();
+        m_pScene = std::make_unique<ShadowTestScene>();
         m_pScene->Initialize(m_DevicePtr, m_DeviceContextPtr, nullptr);
 
         if (!m_pScene->GetMeshes().empty()) {
-            m_pFireMesh = m_pScene->GetMeshes().back();
+            m_pFireMesh = m_pScene->GetMeshes().back().get();
         }
 
-        float aspectRatio = static_cast<float>(m_Width) / static_cast<float>(m_Height);
+        const float aspectRatio = static_cast<float>(m_Width) / static_cast<float>(m_Height);
         m_Camera = Camera({.0f, .0f, .0f}, 45.f);
         m_Camera.Initialize(45.f, {.0f, .0f, .0f}, aspectRatio);
     }
@@ -66,7 +67,6 @@ namespace dae {
         m_DevicePtr->Release();
 
         m_pScene->Cleanup();
-        delete m_pScene;
         //SDL
 
         SDL_FreeSurface(m_pBackBuffer);
@@ -79,7 +79,7 @@ namespace dae {
     void Renderer::Update(const Timer *pTimer) {
         m_Camera.Update(pTimer);
 
-        for (auto mesh: m_pScene->GetMeshes()) {
+        for (auto& mesh: m_pScene->GetMeshes()) {
             mesh->SetCameraPos(m_Camera.GetPosition());
         }
         if (m_Rotating) {
@@ -89,7 +89,7 @@ namespace dae {
 
             Matrix rotationMatrix = Matrix::CreateRotationY(rotationThisFrame);
 
-            for (auto mesh: m_pScene->GetMeshes()) {
+            for (auto& mesh: m_pScene->GetMeshes()) {
                 Matrix originalWorldMatrix = mesh->GetWorldMatrix();
                 Matrix world = rotationMatrix * originalWorldMatrix;
 
@@ -121,7 +121,7 @@ namespace dae {
         m_DeviceContextPtr->ClearDepthStencilView(m_DepthStencilViewPtr, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
 
         Matrix viewProjMatrix = m_Camera.GetViewProjectionMatrix();
-        for (auto mesh: m_pScene->GetMeshes()) {
+        for (auto& mesh: m_pScene->GetMeshes()) {
             if (mesh->GetShouldRender()) {
                 Matrix modelMatrix = mesh->GetWorldMatrix();
                 Matrix worldViewProjMatrix = modelMatrix * viewProjMatrix;
@@ -149,8 +149,8 @@ namespace dae {
         m_VerticiesScreenSpace.clear();
 
 
-        for (auto *currentMesh: m_pScene->GetMeshes()) {
-
+        for (auto& currentMeshUP: m_pScene->GetMeshes()) {
+            Mesh* currentMesh = currentMeshUP.get();
             if (!currentMesh->GetShouldRender()) {
                 continue;
             }
@@ -200,14 +200,12 @@ namespace dae {
                     continue;
                 }
 
-
                 const float minX{std::min(vertex0.position.x, std::min(vertex1.position.x, vertex2.position.x))};
                 const float minY{std::min(vertex0.position.y, std::min(vertex1.position.y, vertex2.position.y))};
 
                 const float maxX{std::max(vertex0.position.x, std::max(vertex1.position.x, vertex2.position.x))};
                 const float maxY{std::max(vertex0.position.y, std::max(vertex1.position.y, vertex2.position.y))};
 
-
                 const Vector3 side1{vertex1.position - vertex0.position};
                 const Vector3 side2{vertex2.position - vertex0.position};
 
@@ -283,6 +281,7 @@ namespace dae {
         SDL_UpdateWindowSurface(m_pWindow);
     }
 
+
     HRESULT Renderer::InitializeDirectX() {
         //1. Create device & deviceContext
         //=====
@@ -435,13 +434,14 @@ namespace dae {
             vertex_out.mesh = mesh;
             vertex_out.valid = isValid;
             vertex_out.viewDir  = (mesh->GetWorldMatrix().TransformPoint(vertex_out.position)
-                                                       - m_Camera.GetPosition().ToPoint4()).Normalized().GetXYZ();
+                                   - m_Camera.GetPosition().ToPoint4()).Normalized().GetXYZ();
 
             vertices_out.push_back(vertex_out);
         }
 
     }
 
+
     void Renderer::ToggleDepthBuffer() {
         m_isDepthBuffer = !m_isDepthBuffer;
 
@@ -470,10 +470,10 @@ namespace dae {
             const Vector3 biNormal{Vector3::Cross(normal, sample.tangent)};
 
             const Matrix tangentToWorld{
-                sample.tangent,
-                biNormal,
-                normal,
-                {0.f, 0.f, 0.f}
+                    sample.tangent,
+                    biNormal,
+                    normal,
+                    {0.f, 0.f, 0.f}
             };
 
             const ColorRGB normalSample{sample.mesh->GetMaterial()->normalTexturePtr->Sample(sample.uv)};
@@ -534,8 +534,10 @@ namespace dae {
         return color;
     }
 
+
+
     void Renderer::CycleCullMode() {
-        for (auto mesh: m_pScene->GetMeshes()) {
+        for (auto& mesh: m_pScene->GetMeshes()) {
             mesh->CycleCullMode();
         }
 
@@ -604,7 +606,7 @@ namespace dae {
     }
 
     void Renderer::NextSamplingState() {
-        for (auto mesh: m_pScene->GetMeshes()) {
+        for (auto& mesh: m_pScene->GetMeshes()) {
             mesh->NextSamplingState();
         }
 
@@ -629,7 +631,7 @@ namespace dae {
 
     void Renderer::ToggleNormals() {
         m_useNormals = !m_useNormals;
-        for (auto mesh: m_pScene->GetMeshes()) {
+        for (auto& mesh: m_pScene->GetMeshes()) {
             mesh->ToggleNormals();
         }
         std::string mode = m_useNormals ? "ON" : "OFF";
@@ -658,7 +660,6 @@ namespace dae {
 
     void Renderer::NextScene() {
         m_pScene->Cleanup();
-        delete m_pScene;
 
         //Calculate the next scene
         int index = static_cast<int>(m_CurrentScene);
@@ -667,32 +668,38 @@ namespace dae {
 
         switch (m_CurrentScene) {
             case SceneNames::Main:
-                m_pScene = new MainScene();
+                m_pScene = std::make_unique<MainScene>();
                 m_pFireMesh = nullptr;
 
                 std::cout << MAGENTA << "[SHARED]" << BLUE << " Scene = Main" << RESET << std::endl;
                 std::cout << MAGENTA << "This could take a second" << RESET << std::endl;
                 break;
             case SceneNames::Diorama:
-                m_pScene = new DioramaScene();
+                m_pScene = std::make_unique<DioramaScene>();
 
                 std::cout << MAGENTA << "[SHARED]" << BLUE << " Scene = Diorama" << RESET << std::endl;
                 std::cout << MAGENTA << "This could take a second" << RESET << std::endl;
                 break;
             case SceneNames::Instanced:
-                m_pScene = new InstancedScene();
+                m_pScene = std::make_unique<InstancedScene>();
 
                 std::cout << MAGENTA << "[SHARED]" << BLUE << " Scene = Instanced" << RESET << std::endl;
                 std::cout << MAGENTA << "This could take a second" << RESET << std::endl;
                 break;
 
             case SceneNames::Planet:
-                m_pScene = new PlanetScene();
+                m_pScene = std::make_unique<PlanetScene>();
 
                 std::cout << MAGENTA << "[SHARED]" << BLUE << " Scene = Planet" << RESET << std::endl;
                 std::cout << MAGENTA << "This could take a second" << RESET << std::endl;
                 break;
 
+            case SceneNames::ShadowTest:
+                m_pScene = std::make_unique<ShadowTestScene>();
+
+                std::cout << MAGENTA << "[SHARED]" << BLUE << " Scene = ShadowTest" << RESET << std::endl;
+                std::cout << MAGENTA << "This could take a second" << RESET << std::endl;
+
             case SceneNames::Count:
                 break;
         }
@@ -705,7 +712,7 @@ namespace dae {
 
         if (m_CurrentScene == SceneNames::Main) {
             //Kind of sloppy fix but hey :p
-            m_pFireMesh = m_pScene->GetMeshes().back();
+            m_pFireMesh = m_pScene->GetMeshes().back().get();
         }
     }
 

project/src/Renderer.h

@@ -28,6 +28,7 @@ enum class SceneNames{
     Diorama,
     Instanced,
     Planet,
+    ShadowTest,
 
     Count
 };
@@ -79,7 +80,7 @@ namespace dae
 
         Backendtype m_backendType{ Backendtype::DirectX };
 
-        BaseScene* m_pScene{};
+        std::unique_ptr<BaseScene> m_pScene{};
         SceneNames m_CurrentScene{ SceneNames::Main };
         //Pos rot
         std::unordered_map<SceneNames, std::pair<Vector3, Vector3>> m_SceneCameraPositions{};
@@ -90,7 +91,7 @@ namespace dae
         float m_currentRotation{};
         bool m_UseUniformClearColor{ false };
 
-        ColorRGB m_UniformClearColor{ ColorRGB{0.1f * 255.f, 0.1f * 255.f, 0.1 * 255.f} };
+        const ColorRGB m_UniformClearColor{ ColorRGB{0.1f * 255.f, 0.1f * 255.f, 0.1 * 255.f} };
 
 
         //DirectX vars
@@ -100,7 +101,7 @@ namespace dae
 		HRESULT InitializeDirectX();
         void RenderDirectX() const;
 
-        ColorRGB DirectXClearColor{ .39f * 255.f, .59f * 255.f, .93f * 255.f };
+        const ColorRGB DirectXClearColor{ .39f * 255.f, .59f * 255.f, .93f * 255.f };
 
         //Storing the mesh so i can deactivate it;
         Mesh* m_pFireMesh{};
@@ -134,7 +135,7 @@ namespace dae
         bool m_isDepthBuffer{ false };
 
 
-        ColorRGB m_ClearColorSoftware{ .39f * 255.f, .39f * 255.f, .39f * 255.f };
+        const ColorRGB m_ClearColorSoftware{ .39f * 255.f, .39f * 255.f, .39f * 255.f };
 
         float* m_pDepthBufferPixels{};
 

project/src/Scenes/BaseScene.h

@@ -25,7 +25,7 @@ public:
 
     virtual void Cleanup() = 0;
 
-    virtual std::vector<Mesh*>& GetMeshes() = 0;
+    virtual std::vector<std::unique_ptr<Mesh>>& GetMeshes() = 0;
     virtual std::vector<std::shared_ptr<Material>>& GetMaterials() = 0;
 };
 

project/src/Scenes/DioramaScene.cpp

@@ -15,19 +15,20 @@ void DioramaScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *Devi
     std::vector<std::unique_ptr<Utils::MaterialMesh>> materialMeshes;
     Utils::LoadObjWithMaterials("resources/scene.obj", materialMeshes, true, DevicePtr);
     for (const auto &mesh: materialMeshes) {
-        if (mesh->vertices.size() > 0) {
+        if (!mesh->vertices.empty()) {
             std::shared_ptr<Material> material = std::make_shared<Material>();
-            BaseEffect *effect{nullptr};
+            std::unique_ptr<BaseEffect> effect{};
 
-            if (mesh->opacity_map != "") {
-                effect = new FireEffect(DevicePtr, L"resources/Fire.fx");
+            if (!mesh->opacity_map.empty()) {
+                effect = std::make_unique<FireEffect>(DevicePtr, L"resources/Fire.fx");
                 material->diffuseTexturePtr = Texture::LoadFromFile("./resources/diorama/" + mesh->diffuse_texture, DevicePtr);
             } else {
                 material->diffuseTexturePtr = Texture::LoadFromFile("./resources/diorama/" + mesh->diffuse_texture, DevicePtr);
-                effect = new Effect(DevicePtr, L"resources/SimpleDiffuse.fx");
+                effect = std::make_unique<Effect>(DevicePtr, L"resources/SimpleDiffuse.fx");
             }
+            auto newMesh = std::make_unique<Mesh>(DevicePtr, mesh->vertices, mesh->indices, material, std::move(effect));
+            m_meshes.push_back(std::move(newMesh));
 
-            m_meshes.push_back(new Mesh(DevicePtr, mesh->vertices, mesh->indices, material, effect));
 
             Matrix worldMatrix = m_meshes.back()->GetWorldMatrix();
             worldMatrix *= Matrix::CreateScale(2.f, 2.f, 2.f);
@@ -42,13 +43,15 @@ void DioramaScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *Devi
     for (const auto &mesh: materialMeshes) {
         if (!mesh->vertices.empty()) {
             std::shared_ptr<Material> material = std::make_shared<Material>();
-            BaseEffect *effect{nullptr};
+            auto effect = std::make_unique<Effect>(DevicePtr, L"resources/SimpleDiffuse.fx");
 
-            effect = new Effect(DevicePtr, L"resources/SimpleDiffuse.fx");
             material->diffuseTexturePtr = Texture::LoadFromFile("./resources/brok/" + mesh->diffuse_texture, DevicePtr);
 
-            m_meshes.push_back(new Mesh(DevicePtr, mesh->vertices, mesh->indices, material, effect));
-            m_brokMeshses.push_back(m_meshes.back());
+
+            auto brokMesh = std::make_unique<Mesh>(DevicePtr, mesh->vertices, mesh->indices, material, std::move(effect));
+            m_brokMeshses.push_back(brokMesh.get());
+            m_meshes.push_back(std::move(brokMesh));
+
 
             Matrix worldMatrix = m_meshes.back()->GetWorldMatrix();
             worldMatrix *= Matrix::CreateRotationY(3.14f / 2.f);
@@ -81,7 +84,7 @@ void DioramaScene::Render(ID3D11DeviceContext *devicePtr, ID3D11RenderTargetView
 
 }
 
-std::vector<Mesh *> &DioramaScene::GetMeshes() {
+std::vector<std::unique_ptr<Mesh>> &DioramaScene::GetMeshes() {
     return m_meshes;
 }
 
@@ -90,9 +93,6 @@ std::vector<std::shared_ptr<Material>> &DioramaScene::GetMaterials() {
 }
 
 void DioramaScene::Cleanup() {
-    for (Mesh *mesh: m_meshes) {
-        delete mesh;
-    }
     m_meshes.clear();
     m_materials.clear();
 }

project/src/Scenes/DioramaScene.h

@@ -3,13 +3,13 @@
 
 #include "BaseScene.h"
 
-class DioramaScene : public BaseScene {
+class DioramaScene final : public BaseScene {
 public:
     void Cleanup() override;
 
     void Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceContextPtr, Camera *camera) override;
 
-    std::vector<Mesh *> &GetMeshes() override;
+    std::vector<std::unique_ptr<Mesh>> &GetMeshes() override;
 
     std::vector<std::shared_ptr<Material>> &GetMaterials() override;
 
@@ -18,7 +18,7 @@ public:
     void Render(ID3D11DeviceContext* devicePtr, ID3D11RenderTargetView *renderTargetViewPtr, ID3D11DepthStencilView *depthStencilViewPtr, const Camera& camera) override;
 
 private:
-    std::vector<Mesh *> m_meshes{};
+    std::vector<std::unique_ptr<Mesh>> m_meshes{};
     std::vector<std::shared_ptr<Material>> m_materials{};
 
     std::vector<Mesh*> m_brokMeshses{ nullptr };

project/src/Scenes/InstancedScene.cpp

@@ -43,7 +43,9 @@ void InstancedScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *De
             float scale = 2;
 
             //use the perlin noise to generate the YOffset
-            float YOffset = sin(x * 0.5f + SDL_GetTicks() * 0.001f) + cos(y * 0.5f + SDL_GetTicks() * 0.001f);
+            float currentTick = static_cast<float>(SDL_GetTicks());
+
+            float YOffset = sin(x * 0.5f +currentTick * 0.001f) + cos(y * 0.5f + currentTick * 0.001f);
             data.worldMatrix = Matrix::CreateTranslation(x * scale, YOffset, y * scale);
             data.worldMatrix *= Matrix::CreateScale(0.5f, 0.5f, 0.5f);
             data.color = Vector4(float(x) / 255.f, float(y) / 255.f, 1.f, 1.0f);
@@ -51,26 +53,20 @@ void InstancedScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *De
         }
     }
 
-    auto *effect = new Effect(DevicePtr, L"resources/InstancedSimpleDiffuse.fx");
+    auto effect = std::make_unique<Effect>(DevicePtr, L"resources/InstancedSimpleDiffuse.fx");
     effect->NextSamplingState();
     effect->NextSamplingState(); //Dirty hack
-    m_instancedMeshes.push_back(new InstancedMesh(DevicePtr, vertices, indices, cubeMaterial, effect, instanceData));
+
+    auto cubeMesh = std::make_unique<InstancedMesh>(DevicePtr, vertices, indices, cubeMaterial, std::move(effect), instanceData);
+    m_instancedMeshes.push_back(std::move(cubeMesh));
 }
 
 void InstancedScene::Cleanup() {
-    for (auto mesh: m_instancedMeshes) {
-        delete mesh;
-    }
     m_instancedMeshes.clear();
-
-    for (auto mesh: m_meshes) {
-        delete mesh;
-    }
-
     m_meshes.clear();
 }
 
-std::vector<Mesh *> &InstancedScene::GetMeshes() {
+std::vector<std::unique_ptr<Mesh>> &InstancedScene::GetMeshes() {
     return m_meshes;
 }
 
@@ -81,7 +77,7 @@ std::vector<std::shared_ptr<Material>> &InstancedScene::GetMaterials() {
 void InstancedScene::Render(ID3D11DeviceContext *devicePtr, ID3D11RenderTargetView *renderTargetViewPtr,
                             ID3D11DepthStencilView *depthStencilViewPtr, const Camera &camera) {
     Matrix viewProjMatrix = camera.GetViewProjectionMatrix();
-    for (auto mesh: m_instancedMeshes) {
+    for (auto& mesh: m_instancedMeshes) {
         Matrix modelMatrix = mesh->GetWorldMatrix();
         Matrix worldViewProjMatrix = modelMatrix * viewProjMatrix;
         mesh->Render(devicePtr, worldViewProjMatrix);
@@ -96,8 +92,9 @@ void InstancedScene::Update() {
                 InstancedData data;
                 float scale = 2;
                 //Generate sine wave based on x and y and the SDL_GetTicks
-                float YOffset = sin(x * 0.5f + SDL_GetTicks() * 0.001f) + cos(y * 0.5f + SDL_GetTicks() * 0.001f);
-                YOffset += (x * 0.1f + y * 0.1f) * 0.1f;
+                float currentTick = static_cast<float>(SDL_GetTicks());
+                float YOffset = sin(static_cast<float>(x) * 0.5f + currentTick * 0.001f) + cos(static_cast<float>(y) * 0.5f + currentTick * 0.001f);
+                YOffset += (static_cast<float>(x) * 0.1f + static_cast<float>(y) * 0.1f) * 0.1f;
 
                 data.worldMatrix = Matrix::CreateTranslation(x * scale, YOffset, y * scale);
                 data.worldMatrix *= Matrix::CreateScale(0.5f, 0.5f, 0.5f);

project/src/Scenes/InstancedScene.h

@@ -6,7 +6,7 @@
 #include "../InstancedMesh.h"
 #include "../PerlinNoise.hpp"
 
-class InstancedScene : public BaseScene {
+class InstancedScene final : public BaseScene {
 public:
     void Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceContextPtr, Camera *camera) override;
 
@@ -16,7 +16,7 @@ public:
 
     void Cleanup() override;
 
-    std::vector<Mesh *> &GetMeshes() override;
+    std::vector<std::unique_ptr<Mesh>> &GetMeshes() override;
 
     std::vector<std::shared_ptr<Material>> &GetMaterials() override;
 
@@ -24,9 +24,9 @@ private:
 
     ID3D11DeviceContext* m_DeviceContextPtr{};
 
-    std::vector<Mesh*> m_meshes;
+    std::vector<std::unique_ptr<Mesh>> m_meshes;
     //Kind of hack since InstancedMesh doesnt extend mesh
-    std::vector<InstancedMesh*> m_instancedMeshes;
+    std::vector<std::unique_ptr<InstancedMesh>> m_instancedMeshes;
     std::vector<std::shared_ptr<Material>> m_materials;
 
     const siv::PerlinNoise::seed_type seed = 123456u;

project/src/Scenes/MainScene.cpp

@@ -26,8 +26,9 @@ void MainScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceC
     vehicleMaterial->specularTexturePtr = Texture::LoadFromFile("resources/vehicle_specular.png", DevicePtr);
     vehicleMaterial->glossTexturePtr = Texture::LoadFromFile("resources/vehicle_gloss.png", DevicePtr);
 
-    auto* effect = new Effect(DevicePtr, L"resources/PosCol3D.fx");
-    m_meshes.push_back(new Mesh(DevicePtr, vertices, indices, vehicleMaterial, effect));
+    auto effect = std::make_unique<Effect>(DevicePtr, L"resources/PosCol3D.fx");
+    auto vehicleMesh = std::make_unique<Mesh>(DevicePtr, vertices, indices, vehicleMaterial, std::move(effect));
+    m_meshes.push_back(std::move(vehicleMesh));
 
 
     Matrix worldMatrix = m_meshes.back()->GetWorldMatrix();
@@ -45,8 +46,9 @@ void MainScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceC
     std::shared_ptr<Material> FireMaterial = std::make_shared<Material>();
     FireMaterial->diffuseTexturePtr = Texture::LoadFromFile("resources/fireFX_diffuse.png", DevicePtr);
 
-    auto* fireEffect = new FireEffect(DevicePtr, L"resources/Fire.fx");
-    m_meshes.push_back(new Mesh(DevicePtr, vertices, indices, FireMaterial, fireEffect));
+    auto fireEffect = std::make_unique<FireEffect>(DevicePtr, L"resources/Fire.fx");
+    auto fireMesh = std::make_unique<Mesh>(DevicePtr, vertices, indices, FireMaterial, std::move(fireEffect));
+    m_meshes.push_back(std::move(fireMesh));
 
     worldMatrix = m_meshes.back()->GetWorldMatrix();
     worldMatrix *= Matrix::CreateTranslation(0, 0, 50.f);
@@ -55,13 +57,10 @@ void MainScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceC
 
 
 void MainScene::Cleanup() {
-    for (Mesh* mesh : m_meshes) {
-        delete mesh;
-    }
     m_meshes.clear();
 }
 
-std::vector<Mesh *> &MainScene::GetMeshes() {
+std::vector<std::unique_ptr<Mesh>> &MainScene::GetMeshes() {
     return m_meshes;
 }
 

project/src/Scenes/MainScene.h

@@ -10,13 +10,13 @@
 #include <memory>
 #include <vector>
 
-class MainScene : public BaseScene {
+class MainScene final : public BaseScene {
 public:
     void Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceContextPtr, Camera *camera) override;
 
     void Cleanup() override;
 
-    std::vector<Mesh *> &GetMeshes() override;
+    std::vector<std::unique_ptr<Mesh>> &GetMeshes() override;
 
     std::vector<std::shared_ptr<Material>> &GetMaterials() override;
 
@@ -27,7 +27,7 @@ public:
 
 private:
 
-    std::vector<Mesh*> m_meshes{};
+    std::vector<std::unique_ptr<Mesh>> m_meshes{};
     std::vector<std::shared_ptr<Material>> m_materials{};
 
 };

project/src/Scenes/PlanetScene.cpp

@@ -60,8 +60,9 @@ void PlanetScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *Devic
         m_InstancedData.push_back(data);
     }
 
-    auto *rockEffect = new Effect(DevicePtr, L"resources/InstancedSimpleDiffuse.fx");
-    m_instancedMeshes.push_back(new InstancedMesh(DevicePtr, vertices, indices, rockMaterial, rockEffect, m_InstancedData));
+    auto rockEffect = std::make_unique<Effect>(DevicePtr, L"resources/InstancedSimpleDiffuse.fx");
+    auto rockMesh = std::make_unique<InstancedMesh>(DevicePtr, vertices, indices, rockMaterial, std::move(rockEffect), m_InstancedData);
+    m_instancedMeshes.push_back(std::move(rockMesh));
 
     indices.clear();
     vertices.clear();
@@ -74,8 +75,10 @@ void PlanetScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *Devic
     std::shared_ptr<Material> planetMaterial = std::make_shared<Material>();
     planetMaterial->diffuseTexturePtr = Texture::LoadFromFile("resources/planet/mars.png", DevicePtr);
 
-    auto* planetEffect = new Effect(DevicePtr, L"resources/SimpleDiffuse.fx");
-    m_meshes.push_back(new Mesh(DevicePtr, vertices, indices, planetMaterial, planetEffect));
+    auto planetEffect = std::make_unique<Effect>(DevicePtr, L"resources/SimpleDiffuse.fx");
+    auto planetMesh = std::make_unique<Mesh>(DevicePtr, vertices, indices, planetMaterial, std::move(planetEffect));
+    m_planetMesh = planetMesh.get();
+    m_meshes.push_back(std::move(planetMesh));
 
     indices.clear();
     vertices.clear();
@@ -88,9 +91,10 @@ void PlanetScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *Devic
     std::shared_ptr<Material> skyboxMaterial = std::make_shared<Material>();
     skyboxMaterial->diffuseTexturePtr = Texture::LoadFromFile("resources/planet/skybox/space_nebula_6k.png", DevicePtr);
 
-    auto* skyboxEffect = new Effect(DevicePtr, L"resources/SimpleDiffuse.fx");
-    m_meshes.push_back(new Mesh(DevicePtr, vertices, indices, skyboxMaterial, skyboxEffect));
-    m_skyboxMesh = m_meshes.back();
+    auto skyboxEffect = std::make_unique<Effect>(DevicePtr, L"resources/SimpleDiffuse.fx");
+    auto skyBoxMesh = std::make_unique<Mesh>(DevicePtr, vertices, indices, skyboxMaterial, std::move(skyboxEffect));
+    m_meshes.push_back(std::move(skyBoxMesh));
+    m_skyboxMesh = m_meshes.back().get();
 
     Matrix worldMatrix = m_meshes.back()->GetWorldMatrix();
     worldMatrix *= Matrix::CreateScale(0.1f, 0.1f, 0.1f);
@@ -98,19 +102,12 @@ void PlanetScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *Devic
 }
 
 void PlanetScene::Cleanup() {
-    for (auto mesh: m_instancedMeshes) {
-        delete mesh;
-    }
     m_instancedMeshes.clear();
 
-    for (auto mesh: m_meshes) {
-        delete mesh;
-    }
-
     m_meshes.clear();
 }
 
-std::vector<Mesh *> &PlanetScene::GetMeshes() {
+std::vector<std::unique_ptr<Mesh>> &PlanetScene::GetMeshes() {
     return m_meshes;
 }
 
@@ -121,7 +118,7 @@ std::vector<std::shared_ptr<Material>> &PlanetScene::GetMaterials() {
 void PlanetScene::Render(ID3D11DeviceContext *devicePtr, ID3D11RenderTargetView *renderTargetViewPtr,
                             ID3D11DepthStencilView *depthStencilViewPtr, const Camera &camera) {
     Matrix viewProjMatrix = camera.GetViewProjectionMatrix();
-    for (auto mesh: m_instancedMeshes) {
+    for (auto& mesh: m_instancedMeshes) {
         Matrix modelMatrix = mesh->GetWorldMatrix();
         Matrix worldViewProjMatrix = modelMatrix * viewProjMatrix;
         mesh->Render(devicePtr, worldViewProjMatrix);
@@ -137,8 +134,13 @@ void PlanetScene::Update() {
 
     //set the skybox to the camera
     Matrix skyboxMatrix = m_skyboxMesh->GetWorldMatrix();
-
     Vector3 cameraPos = m_Camera->GetPosition();
     skyboxMatrix.SetTranslation(cameraPos);
     m_skyboxMesh->SetWorldMatrix(skyboxMatrix);
+
+    //Rotate the planet slowly
+    Matrix planetMatrix = m_planetMesh->GetWorldMatrix();
+    planetMatrix *= Matrix::CreateRotationY(-0.0001f);
+    m_planetMesh->SetWorldMatrix(planetMatrix);
+
 }

project/src/Scenes/PlanetScene.h

@@ -6,7 +6,7 @@
 #include "BaseScene.h"
 #include "../InstancedMesh.h"
 
-class PlanetScene : public BaseScene {
+class PlanetScene final : public BaseScene {
 public:
     void Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceContextPtr, Camera *camera) override;
 
@@ -16,7 +16,7 @@ public:
 
     void Cleanup() override;
 
-    std::vector<Mesh *> &GetMeshes() override;
+    std::vector<std::unique_ptr<Mesh>> &GetMeshes() override;
 
     std::vector<std::shared_ptr<Material>> &GetMaterials() override;
 
@@ -24,13 +24,14 @@ private:
 
     ID3D11DeviceContext* m_DeviceContextPtr{};
 
-    std::vector<Mesh*> m_meshes;
+    std::vector<std::unique_ptr<Mesh>> m_meshes;
     //Kind of hack since InstancedMesh doesnt extend mesh
-    std::vector<InstancedMesh*> m_instancedMeshes;
+    std::vector<std::unique_ptr<InstancedMesh>> m_instancedMeshes;
     std::vector<InstancedData> m_InstancedData;
     std::vector<std::shared_ptr<Material>> m_materials;
 
     Mesh* m_skyboxMesh;
+    Mesh* m_planetMesh;
 
     Camera* m_Camera;
 };

project/src/Scenes/ShadowTestScene.cpp

@@ -0,0 +1,186 @@
+//
+// Created by Bram on 14/01/2025.
+//
+
+#include "ShadowTestScene.h"
+#include "../Utils.h"
+#include "../Effects/ShadowEffect.h"
+#include "../Effects/Effect.h"
+#include "../Buffers/DX11Viewport.h"
+#include "../RenderSettings.h"
+
+void ShadowTestScene::Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceContextPtr, Camera *camera) {
+    // Initialize shadow map buffer
+    m_ShadowMapBuffer = new ShadowMapBuffer(DevicePtr, 1024 * 4, 1024 * 4); // Example resolution: 1024x1024
+    if(!m_ShadowMapBuffer->Initialize()){
+        assert(true && "Shadow map buffer failed to initialize");
+    }
+    // Initialize light source
+    m_Light.SetPosition({-20.0f, 60.0f, 0.0f});
+    m_Light.SetTarget({0, -5, 40});
+    m_Light.SetUp({0.0f, 1.0f, 0.0f});
+
+    std::vector<VertexIn> vertices{};
+    std::vector<uint32_t> indices{};
+
+    if(!Utils::ParseOBJNew("resources/ShadingDemo.obj", vertices, indices, true)){
+        assert(true && "Model failed to load");
+    }
+
+    auto material = std::make_shared<Material>();
+    material->diffuseTexturePtr = Texture::LoadFromFile("resources/shadowTestTexture.png", DevicePtr);
+
+    auto shadowEffect = new ShadowEffect(DevicePtr, L"resources/shadowEffect.fx");
+    auto otherEffect = new ShadowDiffuse(DevicePtr, L"resources/SuperSimpleDiffuse.fx");
+
+    auto shadowMesh = new ShadowMesh(DevicePtr, vertices, indices, material, shadowEffect, otherEffect);
+
+
+    if(!Utils::ParseOBJNew("resources/tuktuk.obj", vertices, indices, true)){
+        assert(true && "Model failed to load");
+    }
+
+    material = std::make_shared<Material>();
+    material->diffuseTexturePtr = Texture::LoadFromFile("resources/tuktuk.png", DevicePtr);
+
+    shadowEffect = new ShadowEffect(DevicePtr, L"resources/shadowEffect.fx");
+    otherEffect = new ShadowDiffuse(DevicePtr, L"resources/SuperSimpleDiffuse.fx");
+
+    auto shadowMesh2 = new ShadowMesh(DevicePtr, vertices, indices, material, shadowEffect, otherEffect);
+
+    shadowMesh2->SetWorldMatrix(Matrix::CreateTranslation(Vector3(0, -5, 40)));
+    m_tuktukMesh = shadowMesh2;
+    m_shadowMeshes.push_back(shadowMesh2);
+//
+
+//      std::vector<std::unique_ptr<Utils::MaterialMesh>> materialMeshes;
+//    Utils::LoadObjWithMaterials("resources/scene.obj", materialMeshes, true, DevicePtr);
+//    for (const auto &mesh: materialMeshes) {
+//        if (mesh->vertices.size() > 0) {
+//            std::shared_ptr<Material> material = std::make_shared<Material>();
+//            auto* effect = new ShadowDiffuse(DevicePtr, L"resources/SuperSimpleDiffuse.fx");
+//            ShadowEffect* shadowEffect = new ShadowEffect(DevicePtr, L"resources/shadowEffect.fx");
+//            material->diffuseTexturePtr = Texture::LoadFromFile("./resources/diorama/" + mesh->diffuse_texture, DevicePtr);
+//
+//            if (mesh->opacity_map != "") {
+////                continue;
+////                effect = new FireEffect(DevicePtr, L"resources/Fire.fx");
+////                material->diffuseTexturePtr = Texture::LoadFromFile("./resources/diorama/" + mesh->diffuse_texture, DevicePtr);
+//            } else {
+//            }
+//
+//            m_shadowMeshes.push_back(new ShadowMesh(DevicePtr, mesh->vertices, mesh->indices, material, shadowEffect, effect));
+//
+//            Matrix worldMatrix = m_shadowMeshes.back()->GetWorldMatrix();
+//            worldMatrix *= Matrix::CreateScale(2.f, 2.f, 2.f);
+//            worldMatrix *= Matrix::CreateScale(-1.f, 1.f, 1.f); // Mirror the model (Possible loading fault)
+//            m_shadowMeshes.back()->SetWorldMatrix(worldMatrix);
+//        }
+//    }
+
+
+    //Move forward 100
+    shadowMesh->SetWorldMatrix(Matrix::CreateTranslation(Vector3(0, -5, 40)));
+//
+    m_shadowMeshes.push_back(shadowMesh);
+//    m_shadowMaterials.push_back(material);
+}
+
+void ShadowTestScene::Update() {
+//    m_Light.SetTarget(lightTarget);
+    Vector3 pos = m_Light.GetPosition();
+    pos.y = sin(SDL_GetTicks() / 1000.f) * 10.f + 10.f;
+    m_Light.SetPosition(pos);
+    m_Light.Update();
+
+
+    //rotate tutkuk
+
+    Matrix newOne;
+    newOne *= Matrix::CreateRotationY(0.001f * SDL_GetTicks());
+    newOne *= Matrix::CreateTranslation(Vector3(20, -5, 40));
+    m_tuktukMesh->SetWorldMatrix(newOne);
+
+}
+
+void ShadowTestScene::Render(ID3D11DeviceContext *devicePtr, ID3D11RenderTargetView *renderTargetViewPtr,
+                             ID3D11DepthStencilView *depthStencilViewPtr, const Camera &camera) {
+// Shadow map pass
+
+    // Set the viewport to match the shadow map size
+    DX11Viewport ShadowViewport(1024 * 4, 1024 * 4);
+    ShadowViewport.Apply(devicePtr);
+
+    devicePtr->OMSetRenderTargets(0, nullptr, m_ShadowMapBuffer->GetDepthStencilView()); // Set the shadow map as the render target
+    devicePtr->ClearDepthStencilView(m_ShadowMapBuffer->GetDepthStencilView(), D3D11_CLEAR_DEPTH, 1.0f, 0); // Clear the shadow map
+    ID3D11ShaderResourceView* shadowMap = m_ShadowMapBuffer->GetShaderResourceView(); // Get the shadow map shader resource view
+    devicePtr->PSSetShaderResources(0, 1, &shadowMap); // Set the shadow map as a shader resource
+
+    devicePtr->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+
+    ID3D11SamplerState* shadowSampler = m_ShadowMapBuffer->GetSamplerState();
+    devicePtr->PSSetSamplers(0, 1, &shadowSampler);
+
+    auto lightViewProjection = m_Light.GetViewProjectionMatrix();
+
+    for (auto* mesh : m_shadowMeshes) {
+        Matrix lightWorldViewProj = mesh->GetWorldMatrix() * lightViewProjection;
+        dynamic_cast<ShadowMesh*>(mesh)->RenderShadow(devicePtr, lightWorldViewProj);
+    }
+
+    ID3D11DepthStencilView* nullDepthStencilView = nullptr;
+    devicePtr->OMSetRenderTargets(1, &renderTargetViewPtr, nullDepthStencilView);
+
+//     Set the depthmap correctly
+
+    DX11Viewport ColorViewport(RenderSettings::GetInstance().getWidth(), RenderSettings::GetInstance().getHeight());
+    ColorViewport.Apply(devicePtr);
+
+
+    devicePtr->OMSetRenderTargets(1, &renderTargetViewPtr, depthStencilViewPtr);
+    ColorRGB DirectXClearColor{ .39f * 255.f, .59f * 255.f, .93f * 255.f };
+
+    const float clearColor[] = {
+            static_cast<float>(DirectXClearColor.r) / 255.f,
+            static_cast<float>(DirectXClearColor.g) / 255.f,
+            static_cast<float>(DirectXClearColor.b) / 255.f,
+            1.0f
+    };
+    devicePtr->ClearRenderTargetView(renderTargetViewPtr, clearColor);
+    devicePtr->ClearDepthStencilView(depthStencilViewPtr, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
+    for (auto* mesh : m_shadowMeshes) {
+        Matrix worldViewProj = mesh->GetWorldMatrix() * camera.GetViewProjectionMatrix();
+        Matrix lightWorldViewProj = mesh->GetWorldMatrix() * lightViewProjection;
+
+        auto* effect = dynamic_cast<ShadowMesh*>(mesh)->GetColorEffectPtr() ;
+
+        effect->SetWorldViewProjMatrix(worldViewProj);
+        effect->SetWorldMatrix(mesh->GetWorldMatrix());
+        effect->SetShadowMap(shadowMap);
+        effect->SetLightViewProjMatrix(lightWorldViewProj);
+        effect->SetLightDirection(m_Light.GetDirection());
+        effect->SetLightColor(m_Light.GetColor());
+        dynamic_cast<ShadowMesh*>(mesh)->RenderFinal(devicePtr, worldViewProj);
+    }
+}
+
+void ShadowTestScene::Cleanup() {
+
+
+    for (auto *mesh : m_shadowMeshes) {
+        delete mesh;
+    }
+
+    m_shadowMeshes.clear();
+
+    delete m_ShadowMapBuffer;
+
+}
+
+std::vector<std::unique_ptr<Mesh>> & ShadowTestScene::GetMeshes() {
+    return m_Meshes;
+}
+
+std::vector<std::shared_ptr<Material>> &ShadowTestScene::GetMaterials() {
+    return m_Materials;
+}

project/src/Scenes/ShadowTestScene.h

@@ -0,0 +1,43 @@
+#ifndef GP1_DIRECTX_SHADOWTESTSCENE_H
+#define GP1_DIRECTX_SHADOWTESTSCENE_H
+
+#include "BaseScene.h"
+#include "../Buffers/ShadowMapBuffer.h"
+#include "../DirectionalLight.h"
+#include "../ShadowMesh.h"
+
+class ShadowTestScene: public BaseScene {
+public:
+    void Initialize(ID3D11Device *DevicePtr, ID3D11DeviceContext *DeviceContextPtr, Camera *camera) override;
+
+    void Update() override;
+
+    void Render(ID3D11DeviceContext *devicePtr, ID3D11RenderTargetView *renderTargetViewPtr, ID3D11DepthStencilView *depthStencilViewPtr,
+                const Camera &camera) override;
+
+    void Cleanup() override;
+
+    std::vector<std::unique_ptr<Mesh>>& GetMeshes() override;
+
+    std::vector<std::shared_ptr<Material>> &GetMaterials() override;
+
+private:
+
+    std::vector<std::unique_ptr<Mesh>> m_Meshes;
+    std::vector<std::shared_ptr<Material>> m_Materials;
+
+    std::vector<ShadowMesh *> m_shadowMeshes;
+    std::vector<std::shared_ptr<Material>> m_shadowMaterials;
+
+    ShadowMapBuffer *m_ShadowMapBuffer{nullptr};
+    DirectionalLight m_Light;
+
+    float angle = 0.0f;
+
+    ShadowMesh* m_tuktukMesh;
+
+    void RenderShadowMapToScreen(ID3D11DeviceContext *devicePtr, ID3D11RenderTargetView *renderTargetViewPtr);
+};
+
+
+#endif //GP1_DIRECTX_SHADOWTESTSCENE_H

project/src/ShadowMesh.cpp

@@ -0,0 +1,118 @@
+#include "ShadowMesh.h"
+#include <d3d11.h>
+#include <d3dx11effect.h>
+#include <cassert>
+
+ShadowMesh::ShadowMesh(ID3D11Device* devicePtr,
+                       const std::vector<VertexIn>& verticesIn,
+                       const std::vector<Uint32>& indices,
+                       std::shared_ptr<Material> material,
+                       ShadowEffect* shadowEffectPtr,
+                       ShadowDiffuse* colorEffectPtr)
+        : m_ShadowEffectPtr(shadowEffectPtr),
+          m_ColorEffectPtr(colorEffectPtr),
+          m_VerticesIn(verticesIn),
+          m_Indices(indices),
+          m_IndicesCount(static_cast<UINT>(indices.size())) {
+
+    HRESULT result;
+
+    m_Material = material;
+
+    m_ColorEffectPtr->SetMaterial(material.get());
+
+
+    // Create input layout
+    D3D11_INPUT_ELEMENT_DESC vertexDesc[] = {
+            {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
+            {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, static_cast<UINT>(offsetof(VertexIn, uv)), D3D11_INPUT_PER_VERTEX_DATA, 0},
+            {"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, static_cast<UINT>(offsetof(VertexIn, normal)), D3D11_INPUT_PER_VERTEX_DATA, 0},
+            {"TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, static_cast<UINT>(offsetof(VertexIn, tangent)), D3D11_INPUT_PER_VERTEX_DATA, 0},
+    };
+
+    D3DX11_PASS_DESC passDesc;
+    ID3DX11EffectTechnique* techniquePtr = m_ColorEffectPtr->GetTechniquePtr();
+    techniquePtr->GetPassByIndex(0)->GetDesc(&passDesc);
+
+    result = devicePtr->CreateInputLayout(vertexDesc, ARRAYSIZE(vertexDesc),
+                                          passDesc.pIAInputSignature, passDesc.IAInputSignatureSize,
+                                          &m_InputLayoutPtr);
+    assert(result == S_OK && "Creating input layout failed");
+
+
+    // Create vertex buffer
+    D3D11_BUFFER_DESC bufferDesc = {};
+    bufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
+    bufferDesc.ByteWidth = sizeof(VertexIn) * static_cast<UINT>(verticesIn.size());
+    bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+    bufferDesc.CPUAccessFlags = 0;
+
+    D3D11_SUBRESOURCE_DATA subresourceData = {};
+    subresourceData.pSysMem = verticesIn.data();
+
+    result = devicePtr->CreateBuffer(&bufferDesc, &subresourceData, &m_VertexBufferPtr);
+    assert(result == S_OK && "Creating vertex buffer failed");
+
+    // Create index buffer
+    bufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
+    bufferDesc.ByteWidth = sizeof(Uint32) * m_IndicesCount;
+    bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
+
+    subresourceData.pSysMem = m_Indices.data();
+
+    result = devicePtr->CreateBuffer(&bufferDesc, &subresourceData, &m_IndexBufferPtr);
+    assert(result == S_OK && "Creating index buffer failed");
+}
+
+ShadowMesh::~ShadowMesh() {
+    if (m_InputLayoutPtr) m_InputLayoutPtr->Release();
+    if (m_VertexBufferPtr) m_VertexBufferPtr->Release();
+    if (m_IndexBufferPtr) m_IndexBufferPtr->Release();
+
+    delete m_ShadowEffectPtr;
+    delete m_ColorEffectPtr;
+}
+
+void ShadowMesh::RenderShadow(ID3D11DeviceContext* deviceContextPtr, const Matrix& lightWorldViewProj) {
+    m_ShadowEffectPtr->SetLightWorldViewProjMatrix(lightWorldViewProj);
+    deviceContextPtr->IASetInputLayout(m_InputLayoutPtr);
+
+    const UINT stride = sizeof(VertexIn);
+    const UINT offset = 0;
+    deviceContextPtr->IASetVertexBuffers(0, 1, &m_VertexBufferPtr, &stride, &offset);
+    deviceContextPtr->IASetIndexBuffer(m_IndexBufferPtr, DXGI_FORMAT_R32_UINT, 0);
+
+    D3DX11_TECHNIQUE_DESC techniqueDesc;
+    m_ShadowEffectPtr->GetTechniquePtr()->GetDesc(&techniqueDesc);
+
+    for (UINT p = 0; p < techniqueDesc.Passes; ++p) {
+        m_ShadowEffectPtr->GetTechniquePtr()->GetPassByIndex(p)->Apply(0, deviceContextPtr);
+        deviceContextPtr->DrawIndexed(m_IndicesCount, 0, 0);
+    }
+}
+
+void ShadowMesh::RenderFinal(ID3D11DeviceContext* deviceContextPtr, const Matrix& worldViewProj) {
+    m_ColorEffectPtr->SetWorldViewProjMatrix(worldViewProj);
+    deviceContextPtr->IASetInputLayout(m_InputLayoutPtr);
+
+    const UINT stride = sizeof(VertexIn);
+    const UINT offset = 0;
+    deviceContextPtr->IASetVertexBuffers(0, 1, &m_VertexBufferPtr, &stride, &offset);
+    deviceContextPtr->IASetIndexBuffer(m_IndexBufferPtr, DXGI_FORMAT_R32_UINT, 0);
+
+    D3DX11_TECHNIQUE_DESC techniqueDesc;
+    m_ColorEffectPtr->GetTechniquePtr()->GetDesc(&techniqueDesc);
+    for (UINT p = 0; p < techniqueDesc.Passes; ++p) {
+        m_ColorEffectPtr->GetTechniquePtr()->GetPassByIndex(p)->Apply(0, deviceContextPtr);
+        deviceContextPtr->DrawIndexed(m_IndicesCount, 0, 0);
+    }
+
+}
+
+void ShadowMesh::SetWorldMatrix(const Matrix& matrix) {
+    m_WorldMatrix = matrix;
+}
+
+Matrix ShadowMesh::GetWorldMatrix() const {
+    return m_WorldMatrix;
+}

project/src/ShadowMesh.h

@@ -0,0 +1,64 @@
+#ifndef SHADOW_MESH_H
+#define SHADOW_MESH_H
+
+#include <cassert>
+#include <vector>
+#include <d3d11.h>
+#include "Effects/ShadowEffect.h"
+#include "Material.h"
+#include "Mesh.h"
+#include "Effects/ShadowDiffuse.h"
+
+class ShadowMesh {
+public:
+    ShadowMesh(ID3D11Device* devicePtr,
+               const std::vector<VertexIn>& verticesIn,
+               const std::vector<Uint32>& indices,
+               std::shared_ptr<Material> material,
+               ShadowEffect* shadowEffectPtr,
+               ShadowDiffuse* colorEffectPtr);
+
+    ~ShadowMesh();
+
+    void RenderShadow(ID3D11DeviceContext* deviceContextPtr, const Matrix& lightWorldViewProj);
+    void RenderFinal(ID3D11DeviceContext* deviceContextPtr, const Matrix& worldViewProj);
+
+    void SetWorldMatrix(const Matrix& matrix);
+    Matrix GetWorldMatrix() const;
+
+    ShadowEffect* GetShadowEffectPtr(){ return m_ShadowEffectPtr; }
+    ShadowDiffuse* GetColorEffectPtr(){ return m_ColorEffectPtr; }
+
+
+private:
+    // Shadow effect
+    ShadowEffect* m_ShadowEffectPtr;
+
+    // Color effect for final render
+    ShadowDiffuse* m_ColorEffectPtr;
+
+    // Buffers
+    ID3D11InputLayout* m_InputLayoutPtr;
+    ID3D11Buffer* m_VertexBufferPtr;
+    ID3D11Buffer* m_IndexBufferPtr;
+
+
+    //Shadow buffers
+    ID3D11InputLayout* m_ShadowInputLayoutPtr;
+    ID3D11Buffer* m_ShadowVertexBufferPtr;
+    ID3D11Buffer* m_ShadowIndexBufferPtr;
+
+
+    // Material and mesh data
+    std::shared_ptr<Material> m_Material;
+    std::vector<VertexIn> m_VerticesIn;
+    std::vector<Uint32> m_Indices;
+
+    // Matrix transformations
+    Matrix m_WorldMatrix;
+
+    // Indices count
+    UINT m_IndicesCount;
+};
+
+#endif // SHADOW_MESH_H

project/src/Singleton.h

@@ -0,0 +1,30 @@
+//
+// Created by Bram on 16/01/2025.
+//
+
+#ifndef GP1_DIRECTX_SINGLETON_H
+#define GP1_DIRECTX_SINGLETON_H
+
+template<typename T>
+class Singleton {
+public:
+    static T &GetInstance() {
+        static T instance{};
+        return instance;
+    }
+
+    virtual ~Singleton() = default;
+
+    Singleton(Singleton &&other) = delete;
+
+    Singleton(const Singleton &other) = delete;
+
+    Singleton &operator=(Singleton &&other) = delete;
+
+    Singleton &operator=(const Singleton &other) = delete;
+
+protected:
+    Singleton() = default;
+};
+
+#endif //GP1_DIRECTX_SINGLETON_H

project/src/Texture.h

@@ -12,7 +12,7 @@
 
 using namespace dae;
 
-class Texture {
+class Texture final {
 public:
     ~Texture();
 
@@ -28,7 +28,7 @@ private:
     ID3D11ShaderResourceView* m_TextureResourceViewPtr{};
     ID3D11Texture2D* m_TexturePtr{};
 
-    SDL_Surface* m_SurfacePtr{ nullptr };
+    const SDL_Surface* m_SurfacePtr{ nullptr };
     uint32_t* m_pSurfacePixels{ nullptr };
 };
 

project/src/Timer.h

@@ -5,7 +5,7 @@
 
 namespace dae
 {
-	class Timer
+	class Timer final
 	{
 	public:
 		Timer();

project/src/Utils.h

@@ -395,4 +395,14 @@ namespace dae {
         }
 
     }
-}
+}
+
+template<typename T>
+class DirectXDeleter
+{
+public:
+    void operator()(T* p)
+    {
+        p->Release();
+    }
+};

project/src/main.cpp

@@ -11,6 +11,7 @@
 #include "Renderer.h"
 #include "GamePadController.h"
 #include "Utils.h"
+#include "RenderSettings.h"
 
 using namespace dae;
 
@@ -119,6 +120,7 @@ void CheckController(Renderer* pRenderer, bool& printFPS){
     }
 }
 
+
 int main(int argc, char *args[]) {
     //Unreferenced parameters
     (void) argc;
@@ -128,9 +130,19 @@ int main(int argc, char *args[]) {
 
     //Create window + surfaces
     SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK);
+//
+//    const uint32_t width = 640;
+//    const uint32_t height = 480;
 
-    const uint32_t width = 640;
-    const uint32_t height = 480;
+
+    const uint32_t width = 900;
+    const uint32_t height = 600;
+
+    RenderSettings::GetInstance().setHeight(height);
+    RenderSettings::GetInstance().setWidth(width);
+
+////    const uint32_t width = 640;
+////    const uint32_t height = 480;
 
 
     SDL_Window *pWindow = SDL_CreateWindow(