Work on shadow rendering, copy testing folder

Author: NicusorN5

.github/workflows/cpp-test-windows-x64.yml

@@ -19,6 +19,10 @@ jobs:
       shell: cmd
       working-directory: ${{ github.workspace }}
       run: xcopy 3DRadSpace\Data\ build\Release\Data\ /s /e /h /y
+    - name: Copy Test folders
+      shell: cmd
+      working-directory: ${{ github.workspace }}
+      run: xcopy 3DRadSpace\Testing\ build\Release\Testing\ /s /e /h /y
     - name: Run tests
       shell: cmd
       working-directory: ${{ github.workspace }}\build\Release\

3DRadSpace/Data/Shaders/ShadowComposite.hlsl

@@ -0,0 +1,91 @@
+// Screen-Space Shadow Application Shader
+// Applied as a fullscreen pass to composite shadows onto the rendered scene
+
+#include "PostProcessBase.hlsl"
+
+cbuffer ShadowData : register(b0)
+{
+    row_major matrix matLightViewProj;     // Light space transformation
+    row_major matrix matInvViewProj;       // Inverse of camera view-projection (for position reconstruction)
+    float3 LightDirection;
+    float ShadowBias;
+    float ShadowIntensity;                  // How dark shadows are (0 = black, 1 = no shadow)
+    float2 padding;
+}
+
+Texture2D colorTexture : register(t0);      // Scene color (backbuffer)
+Texture2D depthTexture : register(t1);      // Scene depth
+Texture2D shadowMap : register(t2);         // Shadow map from light
+
+SamplerState colorSampler : register(s0);
+SamplerState depthSampler : register(s1);
+SamplerState shadowSampler : register(s2);
+
+// Reconstruct world position from depth buffer
+float3 ReconstructWorldPosition(float2 uv, float depth)
+{
+    // Convert UV and depth to NDC coordinates
+    float4 ndc;
+    ndc.x = uv.x * 2.0 - 1.0;
+    ndc.y = (1.0 - uv.y) * 2.0 - 1.0;  // Flip Y
+    ndc.z = depth;
+    ndc.w = 1.0;
+
+    // Transform to world space
+    float4 worldPos = mul(ndc, matInvViewProj);
+    worldPos /= worldPos.w;  // Perspective divide
+
+    return worldPos.xyz;
+}
+
+float CalculateShadow(float3 worldPos)
+{
+    // Transform world position to light space
+    float4 lightSpacePos = mul(float4(worldPos, 1.0), matLightViewProj);
+
+    // Perform perspective divide
+    float3 projCoords = lightSpacePos.xyz / lightSpacePos.w;
+
+    // Transform to [0,1] range for texture sampling
+    projCoords.x = projCoords.x * 0.5 + 0.5;
+    projCoords.y = projCoords.y * -0.5 + 0.5;  // Flip Y for D3D
+
+    // Outside shadow map bounds = not in shadow
+    if (projCoords.x < 0.0 || projCoords.x > 1.0 ||
+        projCoords.y < 0.0 || projCoords.y > 1.0 ||
+        projCoords.z > 1.0)
+        return 1.0;
+
+    // Get closest depth from shadow map
+    float closestDepth = shadowMap.Sample(shadowSampler, projCoords.xy).r;
+
+    // Get current fragment depth
+    float currentDepth = projCoords.z;
+
+    // Compare depths with bias
+    float shadow = (currentDepth - ShadowBias) > closestDepth ? ShadowIntensity : 1.0;
+
+    return shadow;
+}
+
+float4 PS_Main(VertexOut v) : SV_TARGET
+{
+    // Sample scene color
+    float4 color = colorTexture.Sample(colorSampler, v.UV);
+
+    // Sample depth
+    float depth = depthTexture.Sample(depthSampler, v.UV).r;
+
+    // Skip skybox (depth = 1.0 or 0.0 depending on depth configuration)
+    if (depth >= 0.9999)
+        return color;
+
+    // Reconstruct world position from depth
+    float3 worldPos = ReconstructWorldPosition(v.UV, depth);
+
+    // Calculate shadow factor
+    float shadowFactor = CalculateShadow(worldPos);
+
+    // Apply shadow to color
+    return color * shadowFactor;
+}

3DRadSpace/Data/Shaders/ShadowMapDepth.hlsl

@@ -0,0 +1,33 @@
+// Shadow Map Depth Shader
+// Renders depth from light's perspective for shadow mapping
+
+cbuffer ShadowData : register(b0)
+{
+    row_major matrix matLightViewProj; // Light space transformation matrix
+}
+
+struct VertexIn
+{
+    float3 Position : POSITION;
+};
+
+struct VertexOut
+{
+    float4 Position : SV_POSITION;
+    float Depth : TEXCOORD0;
+};
+
+VertexOut VS_Main(VertexIn v)
+{
+    VertexOut r;
+    r.Position = mul(float4(v.Position.xyz, 1), matLightViewProj);
+    r.Depth = r.Position.z / r.Position.w;
+    return r;
+}
+
+// Pixel shader can be empty for depth-only rendering
+// The depth buffer is automatically written by the hardware
+void PS_Main(VertexOut v)
+{
+    // No output needed - depth is written automatically
+}

3DRadSpace/Engine3DRadSpace/Core/IService.cpp

@@ -0,0 +1,14 @@
+#include "IService.hpp"
+#include "IGame.hpp"
+
+using namespace Engine3DRadSpace;
+
+void IService::SetOwner(IGame* owner) noexcept
+{
+	_owner = owner;
+}
+
+IGame* IService::GetOwner() const noexcept
+{
+	return _owner;
+}

3DRadSpace/Engine3DRadSpace/Core/IService.hpp

@@ -3,12 +3,19 @@
 
 namespace Engine3DRadSpace
 {
+	class IGame;
+
 	/// <summary>
 	/// Polymorphic base for all services used by the engine.
 	/// </summary>
 	class E3DRSP_CORE_EXPORT IService
 	{
+	protected:
+		IGame* _owner = nullptr;
 	public:
+		void SetOwner(IGame* owner) noexcept;
+		IGame* GetOwner() const noexcept;
+
 		virtual ~IService() = default;
 	};
 }

3DRadSpace/Engine3DRadSpace/Graphics/Rendering/IRenderer.cpp

@@ -1,6 +1,8 @@
 #include "IRenderer.hpp"
 #include "../Effect.hpp"
+#include "../../Core/IGame.hpp"
 
+using namespace Engine3DRadSpace;
 using namespace Engine3DRadSpace::Graphics;
 using namespace Engine3DRadSpace::Graphics::Rendering;
 
@@ -23,4 +25,14 @@ void IRenderer::Draw(IVertexBuffer* vertices, IIndexBuffer* indices, Effect* eff
 IGraphicsDevice* IRenderer::GetDevice() const noexcept
 {
 	return _device;
+}
+
+void IRenderer::SetOwner(IGame* owner) noexcept
+{
+	_owner = owner;
+}
+
+IGame* IRenderer::GetOwner() const noexcept
+{
+	return _owner;
 }

3DRadSpace/Engine3DRadSpace/Graphics/Rendering/IRenderer.hpp

@@ -1,6 +1,11 @@
 #pragma once
 #include "../ModelMeshPart.hpp"
 
+namespace Engine3DRadSpace
+{
+	class IGame;
+}
+
 namespace Engine3DRadSpace::Graphics::Rendering
 {
 	/// <summary>
@@ -10,6 +15,7 @@ namespace Engine3DRadSpace::Graphics::Rendering
 	{
 	protected:
 		IGraphicsDevice* _device;
+		IGame* _owner = nullptr;
 
 		IRenderer(IGraphicsDevice* device);
 	public:
@@ -19,6 +25,9 @@ namespace Engine3DRadSpace::Graphics::Rendering
 		IRenderer(IRenderer&&) noexcept = default;
 		IRenderer& operator=(IRenderer&&) noexcept = default;
 
+		void SetOwner(IGame* owner) noexcept;
+		IGame* GetOwner() const noexcept;
+
 		/// <summary>
 		/// Prepares the graphics pipeline for this effect.
 		/// </summary>

3DRadSpace/Engine3DRadSpace/Graphics/Rendering/RenderingManager.cpp

@@ -5,13 +5,15 @@ using namespace Engine3DRadSpace;
 using namespace Engine3DRadSpace::Graphics;
 using namespace Engine3DRadSpace::Graphics::Rendering;
 
-RenderingManager::RenderingManager(IGraphicsDevice* device)
+RenderingManager::RenderingManager(IGraphicsDevice* device) : 
+	_device(device)
 {
 	_renderers.push_back(std::make_unique<ForwardRenderer>(device));
 }
 
 void RenderingManager::Add(std::unique_ptr<IRenderer>&& renderPass)
 {
+	renderPass->SetOwner(_owner);
 	_renderers.push_back(std::move(renderPass));
 }
 

3DRadSpace/Engine3DRadSpace/Graphics/Rendering/RenderingManager.hpp

@@ -15,11 +15,13 @@ namespace Engine3DRadSpace::Graphics::Rendering
 		std::vector<std::unique_ptr<IRenderer>> _renderers;
 	public:
 		RenderingManager(IGraphicsDevice* device);
-		
+
 		template<typename R, typename... Args>
 		void Add(Args&&... args)
 		{
-			_renderers.push_back(std::make_unique<R>(_device, std::forward<Args>(args)...));
+			auto renderer = std::make_unique<R>(_device, std::forward<Args>(args)...);
+			renderer->SetOwner(_owner);
+			_renderers.push_back(std::move(renderer));
 		}
 
 		void Add(std::unique_ptr<IRenderer>&& renderPass);