Rewritten. Works as a charm now.

include/Engine/Rendering/DirectionalLightJob.h

@@ -15,17 +15,16 @@ struct DirectionalLightJob : RenderJob
     DirectionalLightJob(ComponentWrapper transformComponent, ComponentWrapper directionalLightComponent, World* m_World)
         : RenderJob()
     {
-        Orientation = Transform::AbsoluteOrientation(m_World, transformComponent.EntityID);
-        Direction = glm::vec4(0,0,-1,0) * glm::inverse(Orientation);
+
+        Direction = glm::vec4(0,0,-1,0) * glm::inverse(Transform::AbsoluteOrientation(m_World, transformComponent.EntityID));
+        //Direction = glm::vec4((glm::vec3)directionalLightComponent["Direction"], 0.f);
         Color = (glm::vec4)directionalLightComponent["Color"];
         Intensity = (double)directionalLightComponent["Intensity"];
     };
 
-    glm::quat Orientation;
     glm::vec4 Direction;
     glm::vec4 Color;
     float Intensity;
-	bool TextureAlphaShadows = false;
 
     void CalculateHash() override
     {

include/Engine/Rendering/DrawFinalPass.h

@@ -64,9 +64,9 @@ private:
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
-    const ShadowPass* m_ShadowPass;
     const CubeMapPass* m_CubeMapPass;
 	const SSAOPass* m_SSAOPass;
+	const ShadowPass* m_ShadowPass;
 
     ShaderProgram* m_ForwardPlusProgram;
     ShaderProgram* m_ExplosionEffectProgram;

include/Engine/Rendering/Renderer.h

@@ -24,9 +24,9 @@
 #include "../Core/Transform.h"
 #include "imgui/imgui.h"
 #include "TextPass.h"
-#include "ShadowPass.h"
 #include "Util/CommonFunctions.h"
 #include "Core/PerformanceTimer.h"
+#include "ShadowPass.h"
 
 class Renderer : public IRenderer
 {
@@ -74,9 +74,9 @@ private:
     DrawScreenQuadPass* m_DrawScreenQuadPass;
     DrawBloomPass* m_DrawBloomPass;
     DrawColorCorrectionPass* m_DrawColorCorrectionPass;
-    ShadowPass* m_ShadowPass;
 	SSAOPass* m_SSAOPass;
     CubeMapPass* m_CubeMapPass;
+	ShadowPass* m_ShadowPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();

include/Engine/Rendering/ShadowPass.h

@@ -1,5 +1,5 @@
-#ifndef ShadowPass_h_
-#define ShadowPass_h_
+#ifndef ShadowPass_h__
+#define ShadowPass_h__
 
 #include "IRenderer.h"
 #include "FrameBuffer.h"
@@ -38,6 +38,8 @@ public:
 	void ClearBuffer();
 	void Draw(RenderScene& scene);
 
+	void DebugGUI();
+
 	GLuint DepthMap() const { return m_DepthMap; }
 	std::array<glm::mat4, MAX_SPLITS> LightP() const { return m_LightProjection; }
 	std::array<glm::mat4, MAX_SPLITS> LightV() const { return m_LightView; }
@@ -62,7 +64,6 @@ private:
 	GLuint m_DepthMap;
 	FrameBuffer m_DepthBuffer;
 	ShaderProgram* m_ShadowProgram;
-	//ShaderProgram* m_TransparentShadowProgram;
 
 	std::array<glm::mat4, MAX_SPLITS> m_LightProjection;
 	std::array<glm::mat4, MAX_SPLITS> m_LightView;
@@ -71,8 +72,12 @@ private:
 	GLuint m_ResolutionSizeWidth = 1024 * 2;
 	GLuint m_ResolutionSizeHeight = 1024 * 2;
 
+	bool m_TransparentObjects = false;
+	bool m_TexturedShadows = false;
+	bool m_EnableShadows = true;
+
 	int m_CurrentNrOfSplits = 4;
-	float m_SplitWeight = 0.91f;
+	float m_SplitWeight = 0.962f;
 
 	std::array<ShadowFrustum, MAX_SPLITS> m_shadowFrusta;
 

include/Engine/Rendering/ShadowPassState.h

@@ -6,8 +6,8 @@
 class ShadowPassState : public RenderState
 {
 public:
-    ShadowPassState(GLuint frameBuffer);
-    ~ShadowPassState();
+	ShadowPassState(GLuint frameBuffer);
+	~ShadowPassState();
 
 private:
 };

resources/Shaders/ForwardPlus.frag.glsl

@@ -1,7 +1,7 @@
 #version 430
 
-#define MAX_SPLITS 4
 #define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4
 
 uniform mat4 M;
 uniform mat4 V;
@@ -12,22 +12,22 @@ uniform vec2 ScreenDimensions;
 uniform vec4 FillColor;
 uniform vec4 AmbientColor;
 uniform float FillPercentage;
-uniform float FarDistance[MAX_SPLITS];
 uniform float GlowIntensity = 10;
 uniform vec3 CameraPosition;
 uniform int SSAOQuality;
+uniform float FarDistance[MAX_SPLITS];
 
 uniform vec2 DiffuseUVRepeat;
 uniform vec2 NormalUVRepeat;
 uniform vec2 SpecularUVRepeat;
 uniform vec2 GlowUVRepeat;
 layout (binding = 0) uniform sampler2D AOTexture;
-layout (binding = 6) uniform sampler2DArrayShadow DepthMap;
 layout (binding = 1) uniform sampler2D DiffuseTexture;
 layout (binding = 2) uniform sampler2D NormalMapTexture;
 layout (binding = 3) uniform sampler2D SpecularMapTexture;
 layout (binding = 4) uniform sampler2D GlowMapTexture;
 layout (binding = 5) uniform samplerCube CubeMap;
+layout (binding = 13) uniform sampler2DArrayShadow DepthMap;
 
 #define TILE_SIZE 16
 
@@ -62,7 +62,6 @@ layout (std430, binding = 4) buffer LightIndexBuffer
 	float LightIndex[];
 };
 
-
 in VertexData{
 	vec3 Position;
 	vec3 Normal;
@@ -155,6 +154,62 @@ float Random(vec3 seed, int i)
 	return fract(sin(dot_product) * 43758.5453);
 }
 
+int getShadowIndex(float far_distance[1])
+{
+	return 0;
+}
+
+int getShadowIndex(float far_distance[2])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 1;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+
+	return index;
+}
+
+int getShadowIndex(float far_distance[3])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 2;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+	else if ( depth < far_distance[1] && depth > far_distance[0] )
+	{
+		index = 1;
+	}
+
+	return index;
+}
+
+int getShadowIndex(float far_distance[4])
+{
+	float depth = gl_FragCoord.z / gl_FragCoord.w;
+	
+	int index = 3;
+	if ( depth < far_distance[0] )
+	{
+		index = 0;
+	}
+	else if ( depth < far_distance[1] && depth > far_distance[0] )
+	{
+		index = 1;
+	}
+	else if ( depth < far_distance[2] && depth > far_distance[1] )
+	{
+		index = 2;
+	}
+
+	return index;
+}
+
 // Standard hardware-calculated PCF method
 float PCFShadow(sampler2DArrayShadow depth_texture_array, vec3 projection_coords, int layer_index)
 {
@@ -237,62 +292,6 @@ float CalcShadowValue(vec4 light_space_pos, vec3 normal, vec3 light_dir, sampler
 	shadowMapDepth = SoftwarePCF(depth_texture_array, projCoords, layer_index, bias);
 
     return shadowMapDepth;
-} 
-
-int getShadowIndex(float far_distance[1])
-{
-	return 0;
-}
-
-int getShadowIndex(float far_distance[2])
-{
-	float depth = gl_FragCoord.z / gl_FragCoord.w;
-	
-	int index = 1;
-	if ( depth < far_distance[0] )
-	{
-		index = 0;
-	}
-
-	return index;
-}
-
-int getShadowIndex(float far_distance[3])
-{
-	float depth = gl_FragCoord.z / gl_FragCoord.w;
-	
-	int index = 2;
-	if ( depth < far_distance[0] )
-	{
-		index = 0;
-	}
-	else if ( depth < far_distance[1] && depth > far_distance[0] )
-	{
-		index = 1;
-	}
-
-	return index;
-}
-
-int getShadowIndex(float far_distance[4])
-{
-	float depth = gl_FragCoord.z / gl_FragCoord.w;
-	
-	int index = 3;
-	if ( depth < far_distance[0] )
-	{
-		index = 0;
-	}
-	else if ( depth < far_distance[1] && depth > far_distance[0] )
-	{
-		index = 1;
-	}
-	else if ( depth < far_distance[2] && depth > far_distance[1] )
-	{
-		index = 2;
-	}
-
-	return index;
 }
 
 void main()
@@ -322,14 +321,14 @@ void main()
 
 	int start = int(LightGrids.Data[currentTile].Start);
 	int amount = int(LightGrids.Data[currentTile].Amount);
-
-	float shadowFactor = 0.0;
 	
+	float shadowFactor = 0.0;
+
 	for(int i = start; i < start + amount; i++) {
 
 		int l = int(LightIndex[i]);
 		LightSource light = LightSources.List[l];
-		
+
 		LightResult light_result;
 		//These if statements should be removed.
 		if(light.Type == 1) { // point
@@ -342,17 +341,17 @@ void main()
 		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
 		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
 	}
-
+	
 	totalLighting.Diffuse *= vec4(min(vec3(shadowFactor) + AmbientColor.xyz, vec3(1.0)), 1.0);
 	totalLighting.Specular *= vec4(min(vec3(shadowFactor) + AmbientColor.xyz, vec3(1.0)), 1.0);
-	
-	//LightResult getInformation;
-	
+
 	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
-	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));	
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
 	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
 	vec4 reflectionTotal = reflectionColor * (1-specularTexel.a) * color_result.a;
 	color_result = color_result * clamp(1/specularTexel.a, 0, 1) + reflectionTotal;
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	
 
 	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
 

resources/Shaders/ForwardPlusShieldCheck.frag.glsl

@@ -1,6 +1,7 @@
 #version 430
 
 #define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4
 
 uniform mat4 M;
 uniform mat4 V;
@@ -69,6 +70,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input;
 
 out vec4 sceneColor;

resources/Shaders/ForwardPlusSkinned.vert.glsl

@@ -1,9 +1,13 @@
 #version 430
 
+#define MAX_SPLITS 4
+
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
 uniform mat4 Bones[100];
+uniform mat4 LightV[MAX_SPLITS];
+uniform mat4 LightP[MAX_SPLITS];
 
 layout(location = 0) in vec3 Position;
 layout(location = 1) in vec3 Normal;
@@ -44,5 +48,9 @@ void main()
  	Output.BiTangent = vec3(M * vec4(BiTangent, 0.0));
 	Output.ExplosionColor = vec4(1.0);
 	Output.ExplosionPercentageElapsed = 0.0;
-	Output.PositionLightSpace = boneTransform * vec4(Position, 1.0);
+	
+	for(int i = 0; i < MAX_SPLITS; i++)
+	{
+		Output.PositionLightSpace[i] = LightP[i] * LightV[i] * M * boneTransform * vec4(Position, 1.0);
+	}
 }

resources/Shaders/ForwardPlusSplatMap.frag.glsl

@@ -1,5 +1,7 @@
 #version 430
 
+#define MAX_SPLITS 4
+
 uniform mat4 M;
 uniform mat4 V;
 uniform mat4 P;
@@ -95,6 +97,7 @@ in VertexData{
 	vec2 TextureCoordinate;
 	vec4 ExplosionColor;
 	float ExplosionPercentageElapsed;
+	vec4 PositionLightSpace[MAX_SPLITS];
 }Input;
 
 out vec4 sceneColor;

resources/Shaders/ForwardPlusSplatMapRGB.frag.glsl

@@ -1,6 +1,7 @@
 #version 430
 
 #define MIN_AMBIENT_LIGHT 0.3
+#define MAX_SPLITS 4
 
 uniform mat4 M;
 uniform mat4 V;

resources/Shaders/Shadow.frag.glsl

@@ -19,6 +19,4 @@ void main()
 	{
 		discard;
 	}
-}
-
-
+}

src/Engine/Editor/EditorRenderSystem.cpp

@@ -7,7 +7,7 @@ EditorRenderSystem::EditorRenderSystem(SystemParams params, IRenderer* renderer,
 {
     EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &EditorRenderSystem::OnSetCamera);
     auto resolution = Rectangle::Rectangle(1280, 720);
-    m_EditorCamera = new Camera((float)resolution.Width / resolution.Height, glm::radians(45.f), 0.01f, 500.f);
+    m_EditorCamera = new Camera((float)resolution.Width / resolution.Height, glm::radians(45.f), 0.01f, 5000.f);
 }
 
 void EditorRenderSystem::Update(double dt)

src/Engine/Editor/EditorSystem.cpp

@@ -17,10 +17,7 @@ EditorSystem::EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame
     m_EditorCamera = importEntity(EntityWrapper(m_EditorWorld, EntityID_Invalid), "Schema/Entities/Empty.xml");
     m_ActualCamera = m_EditorCamera;
     m_EditorWorld->AttachComponent(m_EditorCamera.ID, "Transform");
-	auto cCamera = m_EditorWorld->AttachComponent(m_EditorCamera.ID, "Camera");
-	// TOBIAS TVINGADE MIG ATT HÅRDKODA
-	(double&)cCamera["FarClip"] = 400.0;
-
+    m_EditorWorld->AttachComponent(m_EditorCamera.ID, "Camera");
     m_EditorCameraInputController = new EditorCameraInputController<EditorSystem>(m_EventBroker, -1);
 
     m_EditorGUI = new EditorGUI(m_World, m_EventBroker);

src/Engine/Rendering/DrawFinalPass.cpp

@@ -4,10 +4,10 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling
 	, m_LightCullingPass(lightCullingPass)
 	, m_CubeMapPass(cubeMapPass)
 	, m_SSAOPass(ssaoPass)
+	, m_ShadowPass(shadowPass)
 {
     //TODO: Make sure that uniforms are not sent into shader if not needed.
     m_ShieldPixelRate = 8;
-    m_ShadowPass = shadowPass;
     InitializeTextures();
     InitializeShaderPrograms();
     InitializeFrameBuffers();
@@ -343,7 +343,8 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 
 	glActiveTexture(GL_TEXTURE0);
 	glBindTexture(GL_TEXTURE_2D, m_SSAOPass->SSAOTexture());
-	glActiveTexture(GL_TEXTURE6);
+
+	glActiveTexture(GL_TEXTURE13);
 	if (m_ShadowPass->DepthMap() != NULL) {
 		glBindTexture(GL_TEXTURE_2D_ARRAY, m_ShadowPass->DepthMap());
 	}
@@ -1091,10 +1092,10 @@ void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<E
     glUniform4fv(glGetUniformLocation(shaderHandle, "AmbientColor"), 1, glm::value_ptr(scene.AmbientColor));
     GLERROR("Bind 20 uniform");
     glUniform1f(glGetUniformLocation(shaderHandle, "GlowIntensity"), job->GlowIntensity);
+
 	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightP"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightP().data()));
 	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightV"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightV().data()));
 	glUniform1fv(glGetUniformLocation(shaderHandle, "FarDistance"), MAX_SPLITS, m_ShadowPass->FarDistance().data());
-
     GLERROR("END");
 }
 
@@ -1133,12 +1134,10 @@ void DrawFinalPass::BindModelUniforms(GLuint shaderHandle, std::shared_ptr<Model
 
     GLERROR("Bind 10 uniform");
     GLint Location_GlowIntensity = glGetUniformLocation(shaderHandle, "GlowIntensity");
+	glUniform1f(Location_GlowIntensity, job->GlowIntensity);
 
-    glUniform1f(Location_GlowIntensity, job->GlowIntensity);
-
-    //Shadow
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightP"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightP().data()));
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightV"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightV().data()));
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightP"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightP().data()));
+	glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "LightV"), MAX_SPLITS, GL_FALSE, glm::value_ptr(*m_ShadowPass->LightV().data()));
 	glUniform1fv(glGetUniformLocation(shaderHandle, "FarDistance"), MAX_SPLITS, m_ShadowPass->FarDistance().data());
 
 	GLERROR("END");
@@ -1309,7 +1308,6 @@ void DrawFinalPass::BindModelTextures(GLuint shaderHandle, std::shared_ptr<Model
 				glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
 				glUniform2fv(glGetUniformLocation(shaderHandle, "GlowUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
 			}
-
 			break;
 		}
 		case RawModel::MaterialType::SplatMapping:

src/Engine/Rendering/FrameBuffer.cpp

@@ -16,6 +16,7 @@ Texture2D::~Texture2D()
     }
 }
 
+
 RenderBuffer::~RenderBuffer()
 {
     if (m_ResourceHandle != 0) {
@@ -51,7 +52,6 @@ void FrameBuffer::Generate()
 		switch ((*it)->m_ResourceType) {
 		case GL_TEXTURE_2D:
 			glFramebufferTexture2D(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle, 0);
-			attachments.push_back((*it)->m_Attachment);
 			GLERROR("FrameBuffer generate: glFramebufferTexture2D");
 			break;
 		case GL_RENDERBUFFER:
@@ -60,13 +60,13 @@ void FrameBuffer::Generate()
 			break;
 		case GL_TEXTURE_2D_ARRAY:
 			glFramebufferTexture(GL_FRAMEBUFFER, (*it)->m_Attachment, *(*it)->m_ResourceHandle, 0);
-			attachments.push_back((*it)->m_Attachment);
-			GLERROR("FrameBuffer generate: GL_TEXTURE_2D_ARRAY");
+			GLERROR("FrameBuffer generate: glFramebufferTexture2DArray");
 			break;
 		}
 		GLERROR("2");
 
-		if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT && (*it)->m_Attachment != GL_STENCIL_ATTACHMENT && (*it)->m_Attachment != GL_DEPTH_STENCIL_ATTACHMENT) {
+		// Need GL_DEPTH_ATTACHMENT for shadows
+		if (/*(*it)->m_Attachment != GL_DEPTH_ATTACHMENT &&*/ (*it)->m_Attachment != GL_STENCIL_ATTACHMENT && (*it)->m_Attachment != GL_DEPTH_STENCIL_ATTACHMENT) {
 			attachments.push_back((*it)->m_Attachment);
 		}
 		GLERROR("Attachment");
@@ -74,19 +74,19 @@ void FrameBuffer::Generate()
 	}
 	GLERROR("3");
 
-		GLenum* bufferTextures = &attachments[0];
-		glDrawBuffers(attachments.size(), bufferTextures);
-		if (GLERROR("GLBufferAttachement error")) {
-			printf(": AttachmentSize %i", attachments.size());
-		}
+    GLenum* bufferTextures = &attachments[0];
+    glDrawBuffers(attachments.size(), bufferTextures);
+    if (GLERROR("GLBufferAttachement error")) {
+        printf(": AttachmentSize %i", attachments.size());
+    }
+
+    if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
+        GLERROR("Framebuffer incomplete");
+        //LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);
+        exit(EXIT_FAILURE);
+    }
+    GLERROR("END");
 
-		if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-			GLERROR("Framebuffer incomplete");
-			//LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);
-			exit(EXIT_FAILURE);
-		}
-		GLERROR("END");
-	}
 }
 
 void FrameBuffer::Bind()

src/Engine/Rendering/RenderSystem.cpp

@@ -12,7 +12,7 @@ RenderSystem::RenderSystem(SystemParams params, const IRenderer* renderer, Rende
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &RenderSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &RenderSystem::OnPlayerSpawned);
 
-    m_Camera = new Camera((float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, glm::radians(45.f), 0.01f, 300.f);
+    m_Camera = new Camera((float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, glm::radians(45.f), 0.01f, 5000.f);
 }
 
 RenderSystem::~RenderSystem()

src/Engine/Rendering/Renderer.cpp

@@ -86,6 +86,11 @@ void Renderer::InitializeShaders()
 {
     m_BasicForwardProgram = ResourceManager::Load<ShaderProgram>("#m_BasicForwardProgram");
     m_ExplosionEffectProgram = ResourceManager::Load<ShaderProgram>("#ExplosionEffectProgram");
+    //m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ExplosionEffect.vert.glsl")));
+    //m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new GeometryShader("Shaders/ExplosionEffect.geom.glsl")));
+    //m_ExplosionEffectProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ExplosionEffect.frag.glsl")));
+    //m_ExplosionEffectProgram->Compile();
+    //m_ExplosionEffectProgram->Link();
 }
 
 void Renderer::InputUpdate(double dt)
@@ -127,8 +132,9 @@ void Renderer::Draw(RenderFrame& frame)
     m_PickingPass->ClearPicking();
     m_DrawFinalPass->ClearBuffer();
     m_DrawBloomPass->ClearBuffer();
-    m_ShadowPass->ClearBuffer();
 	m_SSAOPass->ClearBuffer();
+	m_ShadowPass->ClearBuffer();
+	m_ShadowPass->DebugGUI();
     PerformanceTimer::StopTimer("Renderer-ClearBuffers");
     GLERROR("ClearBuffers");
 	for (auto scene : frame.RenderScenes) {
@@ -144,7 +150,9 @@ void Renderer::Draw(RenderFrame& frame)
         PerformanceTimer::StartTimer("Renderer-Depth");
         SortRenderJobsByDepth(*scene);
         GLERROR("SortByDepth");
-        m_ShadowPass->Draw(*scene);
+		PerformanceTimer::StartTimerAndStopPrevious("Draw shadow maps");
+		m_ShadowPass->Draw(*scene);
+		GLERROR("Draw shadow maps");
         PerformanceTimer::StartTimerAndStopPrevious("Renderer-Generate Frustrums");
         m_LightCullingPass->GenerateNewFrustum(*scene);
         GLERROR("Generate frustums");
@@ -187,7 +195,7 @@ void Renderer::Draw(RenderFrame& frame)
     }
     if (m_DebugTextureToDraw == 4) {
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
-    } 
+    }
 	if (m_DebugTextureToDraw == 5) {
 		m_DrawScreenQuadPass->Draw(m_SSAOPass->SSAOTexture());
 	}
@@ -239,9 +247,9 @@ void Renderer::InitializeRenderPasses()
 {
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
-    m_ShadowPass = new ShadowPass(this);
     m_CubeMapPass = new CubeMapPass(this);
 	m_SSAOPass = new SSAOPass(this, m_Config);
+	m_ShadowPass = new ShadowPass(this);
     m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass, m_CubeMapPass, m_SSAOPass, m_ShadowPass);
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
     m_DrawBloomPass = new DrawBloomPass(this, m_Config);

src/Engine/Rendering/ShadowPass.cpp

@@ -1,6 +1,5 @@
 #include "Rendering/ShadowPass.h"
 
-
 ShadowPass::ShadowPass(IRenderer * renderer, int shadow_res_x, int shadow_res_y)
 {
 	m_Renderer = renderer;
@@ -24,6 +23,15 @@ ShadowPass::~ShadowPass()
 
 }
 
+void ShadowPass::DebugGUI()
+{
+	ImGui::Checkbox("EnableShadows", &m_EnableShadows);
+	ImGui::DragFloat2("ShadowMapNearFar", m_NearFarPlane, 1.f, -1000.f, 1000.f);
+	ImGui::DragFloat("ShadowClippingWeight", &m_SplitWeight, 0.001f, 0.f, 1.f);
+	ImGui::Checkbox("ShadowTransparentObjects", &m_TransparentObjects);
+	ImGui::Checkbox("ShadowOnTextureAlphas", &m_TexturedShadows);
+}
+
 void ShadowPass::InitializeCameras(RenderScene & scene)
 {
 	for (int i = 0; i < m_CurrentNrOfSplits; i++) {
@@ -198,101 +206,100 @@ void ShadowPass::RadiusToLightspace(ShadowFrustum& frustum)
 
 void ShadowPass::Draw(RenderScene & scene)
 {
-	ImGui::DragFloat2("ShadowMapNearFar", m_NearFarPlane, 1.f, -1000.f, 1000.f);
-	ImGui::DragFloat("ShadowClippingWeight", &m_SplitWeight, 0.001f, 0.f, 1.f);
+	if (m_EnableShadows) {
+		InitializeCameras(scene);
+		UpdateSplitDist(m_shadowFrusta, scene.Camera->NearClip(), scene.Camera->FarClip());
 
-	InitializeCameras(scene);
-	UpdateSplitDist(m_shadowFrusta, scene.Camera->NearClip(), scene.Camera->FarClip());
+		ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle());
 
-	ShadowPassState* state = new ShadowPassState(m_DepthBuffer.GetHandle());
+		m_ShadowProgram->Bind();
+		GLuint shaderHandle = m_ShadowProgram->GetHandle();
+		glViewport(0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight);
 
-	m_ShadowProgram->Bind();
-	GLuint shaderHandle = m_ShadowProgram->GetHandle();
-	glViewport(0, 0, m_ResolutionSizeWidth, m_ResolutionSizeHeight);
+		for (int i = 0; i < m_CurrentNrOfSplits; i++) {
+			UpdateFrustumPoints(m_shadowFrusta[i], scene.Camera->Position(), scene.Camera->Forward());
 
-	for (int i = 0; i < m_CurrentNrOfSplits; i++) {
-		UpdateFrustumPoints(m_shadowFrusta[i], scene.Camera->Position(), scene.Camera->Forward());
+			glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i);
 
-		glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthMap, 0, i);
+			for (auto &job : scene.Jobs.DirectionalLight) {
+				auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
 
-		for (auto &job : scene.Jobs.DirectionalLight) {
-			auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
+				if (directionalLightJob) {
+					m_LightView[i] = glm::lookAt(glm::vec3(-directionalLightJob->Direction) + m_shadowFrusta[i].MiddlePoint, m_shadowFrusta[i].MiddlePoint, glm::vec3(0.f, 1.f, 0.f));
 
-			if (directionalLightJob) {
-				m_LightView[i] = glm::lookAt(glm::vec3(-directionalLightJob->Direction) + m_shadowFrusta[i].MiddlePoint, m_shadowFrusta[i].MiddlePoint, glm::vec3(0.f, 1.f, 0.f));
+					PointsToLightspace(m_shadowFrusta[i], m_LightView[i]);
+					//FindRadius(m_shadowFrusta[i]);
+					//RadiusToLightspace(m_shadowFrusta[i]);
+					m_LightProjection[i] = glm::ortho(m_shadowFrusta[i].LRBT[LEFT], m_shadowFrusta[i].LRBT[RIGHT], m_shadowFrusta[i].LRBT[BOTTOM], m_shadowFrusta[i].LRBT[TOP], m_NearFarPlane[NEAR], m_NearFarPlane[FAR]);
 
-				PointsToLightspace(m_shadowFrusta[i], m_LightView[i]);
-				//FindRadius(m_shadowFrusta[i]);
-				//RadiusToLightspace(m_shadowFrusta[i]);
-				m_LightProjection[i] = glm::ortho(m_shadowFrusta[i].LRBT[LEFT], m_shadowFrusta[i].LRBT[RIGHT], m_shadowFrusta[i].LRBT[BOTTOM], m_shadowFrusta[i].LRBT[TOP], m_NearFarPlane[NEAR], m_NearFarPlane[FAR]);
+					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[i]));
 
-				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[i]));
+					GLERROR("ShadowLight ERROR");
 
-				GLERROR("ShadowLight ERROR");
+					for (auto &objectJob : scene.Jobs.OpaqueObjects) {
+						if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob)) {
+							auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
 
-				for (auto &objectJob : scene.Jobs.OpaqueObjects) {
-					if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob))
-					{
-						auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
+							glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+							glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), 1.f);
 
-						glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+							glBindVertexArray(modelJob->Model->VAO);
+							glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+							glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
 
-						glBindVertexArray(modelJob->Model->VAO);
-						glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-						glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
-
-						GLERROR("Shadow Draw ERROR");
+							GLERROR("Shadow Draw ERROR");
+						}
 					}
-				}
+					if (m_TransparentObjects) {
+						state->CullFace(GL_BACK);
+						for (auto &objectJob : scene.Jobs.TransparentObjects) {
+							if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob)) {
+								auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
 
-				state->CullFace(GL_BACK);
-				for (auto &objectJob : scene.Jobs.TransparentObjects) {
-					if (!std::dynamic_pointer_cast<ExplosionEffectJob>(objectJob))
-					{
-						auto modelJob = std::dynamic_pointer_cast<ModelJob>(objectJob);
+								glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+								glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), modelJob->Color.a);
 
-						glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-						glUniform1f(glGetUniformLocation(shaderHandle, "Alpha"), modelJob->Color.a);
-
-						if (directionalLightJob->TextureAlphaShadows) {
-							switch (modelJob->Type) {
-							case RawModel::MaterialType::SingleTextures:
-							case RawModel::MaterialType::Basic:
-							{
-								glActiveTexture(GL_TEXTURE24);
-								if (modelJob->DiffuseTexture.size() > 0 && modelJob->DiffuseTexture[0]->Texture != nullptr) {
-									glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture[0]->Texture->m_Texture);
-									glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(modelJob->DiffuseTexture[0]->UVRepeat));
+								if (m_TexturedShadows) {
+									switch (modelJob->Type) {
+									case RawModel::MaterialType::SingleTextures:
+									case RawModel::MaterialType::Basic:
+									{
+										glActiveTexture(GL_TEXTURE24);
+										if (modelJob->DiffuseTexture.size() > 0 && modelJob->DiffuseTexture[0]->Texture != nullptr) {
+											glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture[0]->Texture->m_Texture);
+											glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(modelJob->DiffuseTexture[0]->UVRepeat));
+										}
+										else {
+											glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+											glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+										}
+										break;
+									}
+									case RawModel::MaterialType::SplatMapping:
+									{
+										glActiveTexture(GL_TEXTURE24);
+										glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+										glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
+										break;
+									}
+									}
 								}
-								else {
-									glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
-									glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
-								}
-								break;
-							}
-							case RawModel::MaterialType::SplatMapping:
-							{
-								glActiveTexture(GL_TEXTURE24);
-								glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
-								glUniform2fv(glGetUniformLocation(shaderHandle, "DiffuseUVRepeat"), 1, glm::value_ptr(glm::vec2(1.0f, 1.0f)));
-								break;
-							}
+
+								glBindVertexArray(modelJob->Model->VAO);
+								glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+								glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
+
+								GLERROR("Shadow Draw ERROR");
 							}
 						}
-
-						glBindVertexArray(modelJob->Model->VAO);
-						glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-						glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
-
-						GLERROR("Shadow Draw ERROR");
+						state->CullFace(GL_FRONT);
 					}
 				}
-				state->CullFace(GL_FRONT);
 			}
 		}
+		glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+		m_DepthBuffer.Unbind();
+		delete state;
 	}
-	glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
-	m_DepthBuffer.Unbind();
-	delete state;
-}
+}

src/Engine/Rendering/ShadowPassState.cpp

@@ -2,10 +2,10 @@
 
 ShadowPassState::ShadowPassState(GLuint frameBuffer)
 {
-    BindFramebuffer(frameBuffer);
-    Enable(GL_DEPTH_TEST);
-    Enable(GL_CULL_FACE);
-    Disable(GL_BLEND);
+	BindFramebuffer(frameBuffer);
+	Enable(GL_DEPTH_TEST);
+	Enable(GL_CULL_FACE);
+	Disable(GL_BLEND);
 	Disable(GL_TEXTURE_2D);
 	CullFace(GL_FRONT);
 	ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));