More WIP

Switching between levels seem to work, but I borked all matrices

include/Engine/Rendering/ShadowPass.h

@@ -11,8 +11,6 @@
 
 #define MAX_SPLITS 5
 
-//#include "ShadowPassState.h" // not created yet
-
 enum NearFar { Near = 0, Far = 1 };
 enum LRBT { Left = 0, Right = 1, Bottom = 2, Top = 3 };
 
@@ -34,41 +32,30 @@ public:
     void Draw(RenderScene& scene);
 
     GLuint DepthMap() const { return m_DepthMap[m_ShadowLevel]; }
-    glm::mat4 lightSpaceMatrix() const { return m_LightSpaceMatrix; }
+    glm::mat4 lightP() const { return m_LightProjection[m_ShadowLevel]; }
-    glm::mat4 lightP() const { return m_LightProjection; }
+    glm::mat4 lightV() const { return m_LightView[m_ShadowLevel]; }
-    glm::mat4 lightV() const { return m_LightView; }
-
-    void setResolution(GLuint width, GLuint height) { resolutionSizeWidth = width; resolutionSizeHeigth = height; }
-
 private:
 
 	glm::mat4 CalculateFrustum(RenderScene & scene, std::shared_ptr<DirectionalLightJob> directionalLightJob, glm::mat4& p, glm::mat4& v, ShadowCamera shad_cam);
-	glm::vec3 LightDirectionToPoint(glm::vec4 direction);
 	std::array<glm::vec3, 8> UpdateFrustumPoints(Camera* cam, glm::vec3 center, glm::vec3 view_dir);
 	void UpdateSplitDist(std::array<ShadowCamera, MAX_SPLITS> shadow_cams, float far_distance, float near_distance);
-	void InitializeLightCameras();
-	glm::mat4 ApplyCropMatrix(ShadowCamera& shadow_cam, glm::mat4 m, glm::mat4 v);
 	glm::mat4 FindNewFrustum(ShadowCamera shadow_cam);
 
     EventBroker* m_EventBroker;
-
+	const IRenderer* m_Renderer;
-    const IRenderer* m_Renderer;
 
 	std::array<GLuint, MAX_SPLITS> m_DepthMap;
 	std::array<FrameBuffer, MAX_SPLITS> m_DepthBuffer;
 
-    ShaderProgram* m_ShadowProgram;
+	std::array<glm::mat4, MAX_SPLITS> m_LightProjection;
+	std::array<glm::mat4, MAX_SPLITS> m_LightView;
 
-    GLuint m_DepthFBO;
+    ShaderProgram* m_ShadowProgram;
+	GLuint m_DepthFBO;
 
     GLfloat m_NearFarPlane[2] = { -34.f, 27.f };
-    //GLfloat m_LRBT[4] = { -77.f, 75.f, -89.f, 89.f };
 	GLfloat m_LRBT[4] = { -10.f, 10.f, -10.f, 10.f };
 
-    glm::mat4 m_LightProjection;
-    glm::mat4 m_LightView;
-    glm::mat4 m_LightSpaceMatrix;
-
     GLuint resolutionSizeWidth = 1024 * 2;
     GLuint resolutionSizeHeigth = 1024 * 2;
 
@@ -76,7 +63,7 @@ private:
 	int m_ShadowLevel = 0;
 
 	int m_CurrentNrOfSplits = 3;
-	float m_SplitWeight = 0.75f;
+	float m_SplitWeight = 0.5f;
 
 	std::array<ShadowCamera, MAX_SPLITS> m_shadCams;
 };

resources/Shaders/ForwardPlus.vert.glsl

@@ -3,7 +3,6 @@
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
-uniform mat4 lightSpaceMatrix; // Shadow map PV
 uniform mat4 LightV;
 uniform mat4 LightP;
 uniform mat4 Bones[100];
@@ -61,5 +60,5 @@ void main()
 	Output.ExplosionPercentageElapsed = 0.0;
 	
 	//Output.PositionLightSpace = lightPos; // N
-	Output.PositionLightSpace = lightSpaceMatrix * M * vec4(Position, 1.0);
+	Output.PositionLightSpace = LightP * LightV * M * vec4(Position, 1.0);
 }

src/Engine/Editor/EditorSystem.cpp

@@ -18,7 +18,7 @@ EditorSystem::EditorSystem(World* world, EventBroker* eventBroker, IRenderer* re
     m_ActualCamera = m_EditorCamera;
     m_EditorWorld->AttachComponent(m_EditorCamera.ID, "Transform");
 	auto cCamera = m_EditorWorld->AttachComponent(m_EditorCamera.ID, "Camera");
-	(double&)cCamera["FarClip"] = 30.0;
+	(double&)cCamera["FarClip"] = 60.0;
 
     m_EditorCameraInputController = new EditorCameraInputController<EditorSystem>(m_EventBroker, -1);
 

src/Engine/Rendering/DrawFinalPass.cpp

@@ -244,7 +244,6 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
     glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
 
     //Shadow
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "lightSpaceMatrix"), 1, GL_FALSE, glm::value_ptr(m_ShadowPass->lightSpaceMatrix()));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightP"), 1, GL_FALSE, glm::value_ptr(m_ShadowPass->lightP()));
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightV"), 1, GL_FALSE, glm::value_ptr(m_ShadowPass->lightV()));
     //GLfloat m_NearFarPlane[2] = { -40.f, 30.f };

src/Engine/Rendering/ShadowPass.cpp

@@ -4,7 +4,6 @@ ShadowPass::ShadowPass(IRenderer * renderer)
 {
     m_Renderer = renderer;
 
-    //InitializeTextures();
     InitializeFrameBuffers();
     InitializeShaderPrograms();
 }
@@ -63,6 +62,7 @@ void ShadowPass::UpdateSplitDist(std::array<ShadowCamera, MAX_SPLITS> shadow_cam
 	shadow_cams[m_CurrentNrOfSplits - 1].camera->SetFarClip(far_distance);
 }
 
+// Create a new light frustum based on the 8 corner points of a view frustum segment
 glm::mat4 ShadowPass::FindNewFrustum(ShadowCamera shadow_cam)
 {
 	float maxX = -1000.0f;
@@ -72,126 +72,35 @@ glm::mat4 ShadowPass::FindNewFrustum(ShadowCamera shadow_cam)
 	float minY = 1000.0f;
 	float minZ;
 
-	glm::vec4 transf = glm::vec4(shadow_cam.frustumCorners[0], 1.f);
+	glm::vec4 transf;
-
-	//if (transf.x > maxX) maxX = transf.x;
-	//if (transf.x < minX) minX = transf.x;
-	//if (transf.y > maxY) maxY = transf.y;
-	//if (transf.y < minY) minY = transf.y;
 
 	for (int i = 0; i < 8; i++)
 	{
 		transf = glm::vec4(shadow_cam.frustumCorners[i], 1.f);
 
-		transf.x /= transf.w;
-		transf.y /= transf.w;
-
 		if (transf.x > maxX) maxX = transf.x;
 		if (transf.x < minX) minX = transf.x;
 		if (transf.y > maxY) maxY = transf.y;
 		if (transf.y < minY) minY = transf.y;
 	}
 
+	//float scaleX = 2.0f / (maxX - minX);
+	//float scaleY = 2.0f / (maxY - minY);
+	//float offsetX = -0.5f * (maxX + minX) * scaleX;
+	//float offsetY = -0.5f * (maxY + minY) * scaleY;
+	//
+	//glm::mat4 nv_mvp = glm::mat4();
+	//nv_mvp[0][0] = scaleX;
+	//nv_mvp[1][1] = scaleY;
+	//nv_mvp[0][3] = offsetX;
+	//nv_mvp[1][3] = offsetY;
+	//glm::transpose(nv_mvp);
+
 	glm::mat4 p = glm::ortho(minX, maxX, minY, maxY, m_NearFarPlane[Near], m_NearFarPlane[Far]);
 
 	return p;
 }
 
-glm::mat4 ShadowPass::ApplyCropMatrix(ShadowCamera& shadow_cam, glm::mat4 m, glm::mat4 v)
-{
-	glm::mat4 shad_modelview;
-	glm::mat4 shad_proj;
-	glm::mat4 shad_crop;
-	glm::mat4 shad_mvp;
-	float maxX = -1000.0f;
-	float maxY = -1000.0f;
-	float maxZ;
-	float minX = 1000.0f;
-	float minY = 1000.0f;
-	float minZ;
-
-	glm::mat4 nv_mvp;
-	glm::vec4 transf;
-
-	shad_modelview = m * v;
-	nv_mvp = shad_modelview;
-
-	transf = nv_mvp * glm::vec4(shadow_cam.frustumCorners[0], 1.f);
-	minZ = transf.z;
-	maxZ = transf.z;
-
-	for (int i = 1; i < 8; i++) {
-		transf = nv_mvp * glm::vec4(shadow_cam.frustumCorners[i], 1.f);
-		if (transf.z > maxZ) {
-			maxZ = transf.z;
-		}
-		if (transf.z < minZ) {
-			minZ = transf.z;
-		}
-	}
-
-	// make sure all relevant shadow casters are included here
-
-	shad_proj = glm::ortho(-1.f, 1.f, -1.f, 1.f, m_NearFarPlane[0], m_NearFarPlane[1]);
-
-	//return shad_proj;
-	
-	shad_mvp = shad_proj * shad_modelview;
-	
-	nv_mvp = shad_mvp;
-
-	for (int i = 0; i < 8; i++)
-	{
-		transf = nv_mvp * glm::vec4(shadow_cam.frustumCorners[i], 1.0f);
-
-		transf.x /= transf.w;
-		transf.y /= transf.w;
-
-		if (transf.x > maxX) maxX = transf.x;
-		if (transf.x < minX) minX = transf.x;
-		if (transf.y > maxY) maxY = transf.y;
-		if (transf.y < minY) minY = transf.y;
-	}
-
-	float scaleX = 2.0f / (maxX - minX);
-	float scaleY = 2.0f / (maxY - minY);
-	float offsetX = -0.5f*(maxX + minX)*scaleX;
-	float offsetY = -0.5f*(maxY + minY)*scaleY;
-
-	nv_mvp = glm::mat4();
-	nv_mvp[0][0] = scaleX;
-	nv_mvp[1][1] = scaleY;
-	nv_mvp[0][3] = offsetX;
-	nv_mvp[1][3] = offsetY;
-	glm::transpose(nv_mvp);
-
-	shad_crop = nv_mvp;
-	shad_crop *= shad_proj;
-
-	//return nv_mvp;
-	//return shad_crop;
-	return glm::mat4();
-}
-
-void MakeShadowMap(glm::mat4 m, glm::mat4 v, glm::mat4 p, glm::vec3 light_dir)
-{
-	//float shad_modelview[16];
-
-	glDisable(GL_TEXTURE_2D);
-
-	glm::mat4 viewMatrix = glm::lookAt(glm::vec3(0.f), light_dir, glm::vec3(-1.f, 0.f, 0.f));
-
-
-
-
-
-
-
-
-
-	glEnable(GL_TEXTURE_2D);
-}
-
 glm::mat4 ShadowPass::CalculateFrustum(RenderScene & scene, std::shared_ptr<DirectionalLightJob> directionalLightJob, glm::mat4& p, glm::mat4& v, ShadowCamera shad_cam)
 {
 	p = glm::ortho(m_LRBT[Left], m_LRBT[Right], m_LRBT[Bottom], m_LRBT[Top], m_NearFarPlane[Near], m_NearFarPlane[Far]);
@@ -234,14 +143,6 @@ void ShadowPass::InitializeShaderPrograms()
     m_ShadowProgram->Link();
 }
 
-void ShadowPass::InitializeLightCameras()
-{
-	//for (int i = 0; i < MAX_SPLITS; i++) {
-	//	m_shadCams[i].camera = new Camera(1.f, );
-	//	Camera.
-	//}
-}
-
 void ShadowPass::ClearBuffer()
 {
 	for (int i = 0; i < m_CurrentNrOfSplits; i++) {
@@ -287,11 +188,11 @@ void ShadowPass::Draw(RenderScene & scene)
 				auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
 
 				if (directionalLightJob) {
-					m_LightSpaceMatrix = CalculateFrustum(scene, directionalLightJob, m_LightProjection, m_LightView, m_shadCams[i]);
+					CalculateFrustum(scene, directionalLightJob, m_LightProjection[i], m_LightView[i], m_shadCams[i]);
-					m_LightProjection = FindNewFrustum(m_shadCams[i]);
+					m_LightProjection[i] = FindNewFrustum(m_shadCams[i]);
 
-					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection));
+					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_LightProjection[i]));
-					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView));
+					glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_LightView[i]));
 
 					GLERROR("ShadowLight ERROR");
 
@@ -321,5 +222,6 @@ void ShadowPass::Draw(RenderScene & scene)
 		glCullFace(GL_BACK);
 
 		m_ShadowProgram->Unbind();
+
 	}
 }