Rendering: Shadows pt 2

PolyEngine/Core/Src/Math/AABox.cpp

@@ -98,6 +98,15 @@ Poly::AABox& Poly::AABox::Expand(const AABox& rhs)
 	return *this;
 }
 
+Poly::AABox& Poly::AABox::Expand(const Vector& rhs)
+{
+	Vector min = Vector::Min(GetMin(), rhs);
+	Vector max = Vector::Max(GetMax(), rhs);
+	Pos = min;
+	Size = max - min;
+	return *this;
+}
+
 //------------------------------------------------------------------------------
 namespace Poly {
 	std::ostream & operator<<(std::ostream& stream, const AABox& rect)

PolyEngine/Core/Src/Math/AABox.hpp

@@ -74,6 +74,8 @@ namespace Poly {
 
 		AABox& Expand(const AABox& rhs);
 
+		AABox& Expand(const Vector& rhs);
+
 		CORE_DLLEXPORT friend std::ostream& operator<< (std::ostream& stream, const AABox& color);
 	private:
 		Vector Pos;

PolyEngine/Engine/Res/Shaders/lightAccumulation.frag.glsl

@@ -85,6 +85,44 @@ layout(location = 1) out vec4 oNormal;
 
 const float PI = 3.14159265359;
 
+// 64 samples of poisson disk at:
+// https://www.geeks3d.com/20100628/3d-programming-ready-to-use-64-sample-poisson-disc/
+// 32 samples produce similar results on shadow PCF
+uniform vec2 poissonDisk[32] = vec2[] (
+	vec2(-0.613392,  0.617481),
+	vec2( 0.170019, -0.040254),
+	vec2(-0.299417,  0.791925),
+	vec2( 0.645680,  0.493210),
+	vec2(-0.651784,  0.717887),
+	vec2( 0.421003,  0.027070),
+	vec2(-0.817194, -0.271096),
+	vec2(-0.705374, -0.668203),
+	vec2( 0.977050, -0.108615),
+	vec2( 0.063326,  0.142369),
+	vec2( 0.203528,  0.214331),
+	vec2(-0.667531,  0.326090),
+	vec2(-0.098422, -0.295755),
+	vec2(-0.885922,  0.215369),
+	vec2( 0.566637,  0.605213),
+	vec2( 0.039766, -0.396100),
+	vec2( 0.751946,  0.453352),
+	vec2( 0.078707, -0.715323),
+	vec2(-0.075838, -0.529344),
+	vec2( 0.724479, -0.580798),
+	vec2( 0.222999, -0.215125),
+	vec2(-0.467574, -0.405438),
+	vec2(-0.248268, -0.814753),
+	vec2( 0.354411, -0.887570),
+	vec2( 0.175817,  0.382366),
+	vec2( 0.487472, -0.063082),
+	vec2(-0.084078,  0.898312),
+	vec2( 0.488876, -0.783441),
+	vec2( 0.470016,  0.217933),
+	vec2(-0.696890, -0.549791),
+	vec2(-0.149693,  0.605762),
+	vec2( 0.034211,  0.979980)
+);
+
 float DistributionGGX(vec3 N, vec3 H, float roughness)
 {
 	float a = roughness*roughness;
@@ -130,6 +168,12 @@ vec3 fresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)
     return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.001, 1.0), 5.0); // clamp to prevent NaNs
 }
 
+float hash(vec4 seed)
+{
+    float dot_product = dot(seed, vec4(12.9898, 78.233, 45.164, 94.673));
+    return fract(sin(dot_product) * 43758.5453);
+}
+
 float calcShadow(vec4 fragPosInDirLight, float NdotL)
 {
 	// perform perspective divide
@@ -150,16 +194,12 @@ float calcShadow(vec4 fragPosInDirLight, float NdotL)
 
     float shadow = 0.0;
     vec2 texelSize = 1.0 / textureSize(uDirShadowMap, 0);
-    for (int x = -1; x <= 1; ++x)
+    for (int i = 0; i <= 5; ++i)
     {
-        for (int y = -1; y <= 1; ++y)
-        {
-            float pcfDepth = texture(uDirShadowMap, projCoords.xy + vec2(x, y) * texelSize).r;
-            shadow += currentDepth - bias > pcfDepth ? 0.0 : 1.0;
-        }
+        int index = int(32.0 * hash(vec4(gl_FragCoord.xyy, i))) % 32;
+        float pcfDepth = texture(uDirShadowMap, projCoords.xy + poissonDisk[index] * texelSize).r;
+        shadow += currentDepth - bias > pcfDepth ? 0.0 : 0.2;
     }
-    shadow /= 9.0;
-
 
     return shadow;
 }

PolyEngine/Engine/Src/ECS/ComponentBase.hpp

@@ -65,7 +65,7 @@ namespace Poly {
 		const EnumFlags<eComponentBaseFlags>& GetFlags() { return Flags; }
 		bool CheckFlags(const EnumFlags<eComponentBaseFlags>& rhs) const { return (Flags & rhs) == rhs; }
 
-		virtual Optional<AABox> GetBoundingBox(eEntityBoundingChannel channel) { return {}; }
+		virtual Optional<AABox> GetBoundingBox(eEntityBoundingChannel channel) const { return {}; }
 
 	private:
 		Entity* Owner = nullptr;

PolyEngine/Engine/Src/Rendering/MeshRenderingComponent.cpp

@@ -11,7 +11,9 @@ RTTI_DEFINE_COMPONENT(::Poly::MeshRenderingComponent)
 MeshRenderingComponent::MeshRenderingComponent(const String& meshPath, eResourceSource source)
 {
 	Mesh = ResourceManager<MeshResource>::Load(meshPath, source);
-	if (Mesh) {
+
+	if (Mesh)
+	{
 		size_t materialsNum = GetMesh()->GetSubMeshes().GetSize();
 		Materials.Resize(materialsNum);
 		for (size_t i = 0; i < materialsNum; ++i)
@@ -27,7 +29,7 @@ Poly::MeshRenderingComponent::~MeshRenderingComponent()
 		ResourceManager<MeshResource>::Release(Mesh);
 }
 
-Optional<AABox> Poly::MeshRenderingComponent::GetBoundingBox(eEntityBoundingChannel channel)
+Optional<AABox> Poly::MeshRenderingComponent::GetBoundingBox(eEntityBoundingChannel channel) const
 {
 	if (channel != eEntityBoundingChannel::RENDERING || !Mesh)
 		return {};

PolyEngine/Engine/Src/Rendering/MeshRenderingComponent.hpp

@@ -59,8 +59,8 @@ namespace Poly {
 		void SetShadingModel(eShadingMode value) { ShadingMode = value; }
 		void SetBlendingMode(eBlendingMode value) { BlendingMode = value; }
 
+		Optional<AABox> GetBoundingBox(eEntityBoundingChannel channel) const override;
 
-		Optional<AABox> GetBoundingBox(eEntityBoundingChannel channel) override;
 	private:
 		MeshResource* Mesh = nullptr;
 		Dynarray<Material> Materials;

PolyEngine/Engine/Src/Resources/MeshResource.cpp

@@ -11,7 +11,8 @@ MeshResource::MeshResource(const String& path)
 	Assimp::Importer importer;
 	const aiScene *scene = importer.ReadFile(path.GetCStr(), aiProcessPreset_TargetRealtime_Fast);
 
-	if (!scene) {
+	if (!scene)
+	{
 		gConsole.LogError("Error Importing Asset: {}", importer.GetErrorString());
 		throw ResourceLoadFailedException();
 	}
@@ -22,14 +23,16 @@ MeshResource::MeshResource(const String& path)
 	Vector min(maxFloat, maxFloat, maxFloat);
 	Vector max(-maxFloat, -maxFloat, -maxFloat);
 
-	for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
+	for (unsigned int i = 0; i < scene->mNumMeshes; ++i)
+	{
 		SubMeshes.PushBack(new SubMesh(path, scene->mMeshes[i], scene->mMaterials[scene->mMeshes[i]->mMaterialIndex]));
 
 		min = Vector::Min(min, SubMeshes[i]->GetAABox().GetMin());
 		max = Vector::Max(max, SubMeshes[i]->GetAABox().GetMax());
 	}
 
-	for (size_t i = 0; i < scene->mNumAnimations; ++i) {
+	for (size_t i = 0; i < scene->mNumAnimations; ++i)
+	{
 		Animations.PushBack(new Animation(scene->mAnimations[i]));
 	}
 

PolyEngine/RenderingDevice/OpenGL/Src/ForwardRenderer.cpp

@@ -36,30 +36,30 @@ void ForwardRenderer::Render(const SceneView& sceneView)
 	switch (renderingMode)
 	{
 		case eRenderingModeType::LIT:
-			RenderLit(sceneView.WorldData, sceneView.Rect, sceneView.CameraCmp);
+			RenderLit(sceneView.SceneData, sceneView.Rect, sceneView.CameraCmp);
 			break;
 
 		case eRenderingModeType::UNLIT:
-			RenderUnlit(sceneView.WorldData, sceneView.Rect, sceneView.CameraCmp);
+			RenderUnlit(sceneView.SceneData, sceneView.Rect, sceneView.CameraCmp);
 			break;
 
 		case eRenderingModeType::WIREFRAME:
-			RenderWireframe(sceneView.WorldData, sceneView.Rect, sceneView.CameraCmp);
+			RenderWireframe(sceneView.SceneData, sceneView.Rect, sceneView.CameraCmp);
 			break;
 
 		case eRenderingModeType::DEBUG_NORMALS:
-			RenderNormals(sceneView.WorldData, sceneView.Rect, sceneView.CameraCmp);
+			RenderNormals(sceneView.SceneData, sceneView.Rect, sceneView.CameraCmp);
 			break;
 
 		case eRenderingModeType::DEBUG_NORMALS_WIREFRAME:
-			RenderNormalsWireframe(sceneView.WorldData, sceneView.Rect, sceneView.CameraCmp);
+			RenderNormalsWireframe(sceneView.SceneData, sceneView.Rect, sceneView.CameraCmp);
 			break;
 
 		default:
 			ASSERTE(false, "Uknown eRenderingModeType");
 	}
 
-	PostRender(sceneView.WorldData, sceneView.CameraCmp, sceneView.Rect);
+	PostRender(sceneView.SceneData, sceneView.CameraCmp, sceneView.Rect);
 }
 
 void ForwardRenderer::PostRender(Scene* world, const CameraComponent* cameraCmp, const AARect& rect)

PolyEngine/RenderingDevice/OpenGL/Src/GLRenderingDevice.hpp

@@ -103,6 +103,7 @@ namespace Poly
 		void CreateUtilityTextures();
 
 		void FillSceneView(SceneView& sceneView);
+		void FillDirLightQueue(SceneView& sceneView, const Dynarray<const MeshRenderingComponent*>& meshCmp);
 		void EndFrame();
 
 		void CleanUpResources();

PolyEngine/RenderingDevice/OpenGL/Src/GLWorldRendering.cpp

@@ -2,14 +2,16 @@
 
 #include "GLRenderingDevice.hpp"
 
+#include <algorithm>    // std::min
+
 #include "Proxy/GLTextFieldBufferDeviceProxy.hpp"
 #include "Proxy/GLTextureDeviceProxy.hpp"
 #include "Pipeline/RenderingPassBase.hpp"
 #include "Proxy/GLMeshDeviceProxy.hpp"
 #include "Common/GLUtils.hpp"
 #include "Common/PrimitiveCube.hpp"
 #include "Common/PrimitiveQuad.hpp"
-
+#include "Debugging//DebugDrawSystem.hpp"
 #include "ForwardRenderer.hpp"
 #include "TiledForwardRenderer.hpp"
 
@@ -69,10 +71,24 @@ void GLRenderingDevice::RenderWorld(Scene* world)
 
 void GLRenderingDevice::FillSceneView(SceneView& sceneView)
 {
-	for (const auto componentsTuple : sceneView.WorldData->IterateComponents<MeshRenderingComponent>())
+	for (const auto componentsTuple : sceneView.SceneData->IterateComponents<DirectionalLightComponent>())
+	{
+		sceneView.DirectionalLights.PushBack(std::get<DirectionalLightComponent*>(componentsTuple));
+	}
+
+	for (const auto componentsTuple : sceneView.SceneData->IterateComponents<PointLightComponent>())
 	{
-		const MeshRenderingComponent* meshCmp = std::get<MeshRenderingComponent*>(componentsTuple);
+		sceneView.PointLights.PushBack(std::get<PointLightComponent*>(componentsTuple));
+	}
+
+	Dynarray<const MeshRenderingComponent*> meshCmps;
+	for (const auto componentsTuple : sceneView.SceneData->IterateComponents<MeshRenderingComponent>())
+	{
+		meshCmps.PushBack(std::get<MeshRenderingComponent*>(componentsTuple));
+	}
 
+	for ( auto meshCmp : meshCmps)
+	{
 		if (sceneView.CameraCmp->IsVisibleToCamera(meshCmp->GetOwner()))
 		{
 			if (meshCmp->GetBlendingMode() == eBlendingMode::OPAUQE)
@@ -84,21 +100,127 @@ void GLRenderingDevice::FillSceneView(SceneView& sceneView)
 				sceneView.TranslucentQueue.PushBack(meshCmp);
 			}
 		}
-		else
+	}
+
+	if (sceneView.DirectionalLights.GetSize() > 0)
+	{
+		FillDirLightQueue(sceneView, meshCmps);
+	}
+}
+
+void GLRenderingDevice::FillDirLightQueue(SceneView& sceneView, const Dynarray<const MeshRenderingComponent*>& meshCmps)
+{
+	// based on:
+	// https://gamedev.stackexchange.com/questions/73851/how-do-i-fit-the-camera-frustum-inside-directional-light-space
+	// https://docs.microsoft.com/pl-pl/windows/desktop/DxTechArts/common-techniques-to-improve-shadow-depth-maps
+
+	ASSERTE(sceneView.DirectionalLights.GetSize() > 0, "Filling Dir light opaque geometry queue when no Dir light is present in the scene!");
+	const DirectionalLightComponent* dirLight = sceneView.DirectionalLights[0];
+
+	// Create AABB in DirLightSpace around camera frustum
+	const Optional<Frustum> frustum = sceneView.CameraCmp->GetCameraFrustum();
+	const EntityTransform& cameraTrans = sceneView.CameraCmp->GetOwner()->GetTransform();	
+	ASSERTE(frustum.HasValue(), "Frustum value of camera is not present at stage of filling opague geometry for shadow rendering!");
+
+	// Transform frustum corners to DirLightSpace
+	Dynarray<Vector> cornersInNDC = Dynarray<Vector>{
+		Vector(-1.0f, -1.0f,  1.0f),
+		Vector(-1.0f,  1.0f,  1.0f),
+		Vector(-1.0f, -1.0f, -1.0f),
+		Vector(-1.0f,  1.0f, -1.0f),
+		Vector( 1.0f, -1.0f,  1.0f),
+		Vector( 1.0f,  1.0f,  1.0f),
+		Vector( 1.0f, -1.0f, -1.0f),
+		Vector( 1.0f,  1.0f, -1.0f)
+	};
+
+	// Transform frustum corners from NDC to World
+	// could be done in one iteration but we need to do perspective division by W
+	Matrix worldFromClip = sceneView.CameraCmp->GetClipFromWorld().GetInversed();
+	Dynarray<Vector> cornersInWorld;
+	for (Vector posInClip : cornersInNDC)
+	{
+		Vector world = worldFromClip * posInClip;
+		world.X /= world.W;
+		world.Y /= world.W;
+		world.Z /= world.W;
+		cornersInWorld.PushBack(world);
+	}
+
+	// Transform frustum corners from World to DirLight
+	Matrix dirLightFromWorld = dirLight->GetTransform().GetWorldFromModel().GetInversed();
+
+	// find min and max corners and create AABB in DirLightSpace
+	const float maxFloat = std::numeric_limits<float>::max();
+	Vector min(maxFloat, maxFloat, maxFloat);
+	Vector max(-maxFloat, -maxFloat, -maxFloat);
+
+	Dynarray<Vector> cornersInDirLight;
+	for (Vector posInWorld : cornersInWorld)
+	{
+		Vector posInDirLight = dirLightFromWorld * posInWorld;
+		min = Vector::Min(min, posInDirLight);
+		max = Vector::Max(max, posInDirLight);
+	}
+
+	AABox dirLightAABB(min, max - min);
+	// DebugDrawSystem::DrawBox(sceneView.SceneData, dirLightAABB, Color::BLACK);
+
+	// transform meshes AABB to DirLightSpace
+	Dynarray<std::tuple<AABox, const MeshRenderingComponent*>> meshBoxes;
+	for (auto meshCmp : meshCmps)
+	{
+		const Matrix& dirLightFromModel = dirLightFromWorld * meshCmp->GetTransform().GetWorldFromModel();
+
+		Optional<AABox> boxInLightOptional = meshCmp->GetBoundingBox(eEntityBoundingChannel::RENDERING);
+		if (boxInLightOptional.HasValue())
 		{
-			sceneView.DirShadowOpaqueQueue.PushBack(meshCmp);
+			AABox boxInLight = boxInLightOptional.Value();
+			boxInLight = boxInLight.GetTransformed(dirLightFromModel);
+			meshBoxes.PushBack(std::tuple(boxInLight, meshCmp));
 		}
 	}
 
-	for (const auto componentsTuple : sceneView.WorldData->IterateComponents<DirectionalLightComponent>())
+	// find min Z for near clipping plane and max Z for far clipping plane
+	float minZ = maxFloat;
+	float maxZ = -maxFloat;
+	for (auto kv : meshBoxes)
 	{
-		sceneView.DirectionalLights.PushBack(std::get<DirectionalLightComponent*>(componentsTuple));
+		AABox box = std::get<0>(kv);
+		minZ = std::min(minZ, box.GetMin().Z);
+		maxZ = std::max(maxZ, box.GetMax().Z);
 	}
 
-	for (const auto componentsTuple : sceneView.WorldData->IterateComponents<PointLightComponent>())
+	dirLightAABB.Expand(Vector(0.0f, 0.0f, minZ))
+				.Expand(Vector(0.0f, 0.0f, maxZ));
+
+	// DebugDrawSystem::DrawBox(sceneView.SceneData, dirLightAABB, Color::WHITE);
+
+	// find all meshes that are inside extended DirLights AABB box
+	int shadowCastersCounter = 0;
+	for (auto kv : meshBoxes)
 	{
-		sceneView.PointLights.PushBack(std::get<PointLightComponent*>(componentsTuple));
+		AABox box = std::get<0>(kv);
+		const MeshRenderingComponent* meshCmp = std::get<1>(kv);
+
+		bool isInside = false;
+		for (auto vert : box.GetVertices())
+			isInside |= dirLightAABB.Contains(vert);
+
+		if (isInside || dirLightAABB.Intersects(box))
+		{
+			sceneView.DirShadowOpaqueQueue.PushBack(meshCmp);
+
+			// DebugDrawSystem::DrawBox(sceneView.SceneData, box, Color::GREEN);
+			shadowCastersCounter++;
+		}
 	}
+
+	// remember dir light AABB for orthographic projection size
+	// sceneView.ShadowAABB = dirLightAABB.GetTransformed(dirLight->GetTransform().GetWorldFromModel());
+	sceneView.ShadowAABB = dirLightAABB;
+
+	// gConsole.LogInfo("GLRenderingDevice::FillDirLightQueue shadowCastersCounter: {}", shadowCastersCounter);
 }
 
 void GLRenderingDevice::CreateUtilityTextures()