Transparent objects working.

src/Components/Model.h

@@ -11,11 +11,12 @@ namespace Components
 
 struct Model : Component
 {
-	Model() : Visible(true), ShadowCaster(true) { }
+	Model() : Visible(true), ShadowCaster(true), Transparent(false) { }
 	std::string ModelFile;
 	Color Color;
 	bool Visible;
 	bool ShadowCaster;
+	bool Transparent;
 
 	virtual Model* Clone() const override { return new Model(*this); }
 };

src/GUI/Frame.h

@@ -40,7 +40,7 @@ public:
 		, m_Layer(0)
 	{ SetParent(std::shared_ptr<Frame>(parent)); }
 
-	::RenderQueue RenderQueue;
+	::RenderQueuePair RenderQueue;
 
 	std::shared_ptr<Frame> Parent() const { return m_Parent; }
 	void SetParent(std::shared_ptr<Frame> parent) 

src/GUI/TextureFrame.h

@@ -26,7 +26,7 @@ public:
 		job.TextureID = m_Texture->ResourceID;
 		job.Texture = *m_Texture;
 		job.Color = m_Color;
-		RenderQueue.Add(job);
+		RenderQueue.Forward.Add(job);
 
 		renderer->SetCamera(nullptr);
 		renderer->DrawFrame(RenderQueue);

src/GUI/WorldFrame.h

@@ -69,7 +69,8 @@ public:
 					}
 					else
 					{
-						EnqueueModel(modelAsset, modelMatrix);
+						float transparent = modelComponent->Transparent;
+						EnqueueModel(modelAsset, modelMatrix, transparent);
 					}
 
 				}
@@ -131,7 +132,7 @@ private:
 
 	std::shared_ptr<Systems::TransformSystem> m_TransformSystem;
 
-	void EnqueueModel(Model* model, glm::mat4 modelMatrix)
+	void EnqueueModel(Model* model, glm::mat4 modelMatrix, float transparent)
 	{
 		for (auto texGroup : model->TextureGroups)
 		{
@@ -144,8 +145,15 @@ private:
 			job.StartIndex = texGroup.StartIndex;
 			job.EndIndex = texGroup.EndIndex;
 			job.ModelMatrix = modelMatrix;
-					
+			job.Transparent = transparent;
-			RenderQueue.Add(job);
+			if(job.Transparent)
+			{
+				RenderQueue.Forward.Add(job);
+			}
+			else
+			{
+				RenderQueue.Deferred.Add(job);
+			}
 		}
 	}
 
@@ -167,7 +175,7 @@ private:
 			job.EndIndex = texGroup.EndIndex;
 			job.ModelMatrix = modelMatrix;
 
-			RenderQueue.Add(job);
+			RenderQueue.Deferred.Add(job);
 		}
 	}
 
@@ -178,7 +186,7 @@ private:
 		job.Texture = *texture;
 		job.ModelMatrix = modelMatrix;
 
-		RenderQueue.Add(job);
+		RenderQueue.Forward.Add(job);
 	}
 };
 

src/GameWorld.cpp

@@ -98,7 +98,6 @@ void GameWorld::Initialize()
 	//	CommitEntity(ground);
 	//}
 
-
 	{
 		auto ground_middle = CreateEntity();
 		auto transform = AddComponent<Components::Transform>(ground_middle);
@@ -109,7 +108,7 @@ void GameWorld::Initialize()
 		auto blendmap = AddComponent<Components::BlendMap>(ground_middle);
 		blendmap->TextureRed = "Textures/Ground/Sand.png";
 		blendmap->TextureGreen = "Textures/Ground/Grass.png";
-		blendmap->TextureBlue = "Textures/Ground/Asphalt.png";
+		blendmap->TextureBlue = "Textures/Ground/Rock.png";
 		blendmap->TextureRepeats = 30.f;
 
 		auto physics = AddComponent<Components::Physics>(ground_middle);
@@ -239,6 +238,17 @@ void GameWorld::Initialize()
 		CommitEntity(ground_base_mirrored);
 	}
 
+	{
+		auto tree = CreateEntity();
+		auto transform = AddComponent<Components::Transform>(tree);
+		transform->Position = glm::vec3(0, -15, 0);
+		auto model = AddComponent<Components::Model>(tree);
+		model->ModelFile = "Models/Tree/leafs/Leafs.obj";
+		model->Transparent = true;
+
+		CommitEntity(tree);
+	}
+
 	EntityID tank1 = CreateTank(1);
 	{
 		auto transform = GetComponent<Components::Transform>(tank1);

src/RenderQueue.h

@@ -38,6 +38,7 @@ struct ModelJob : RenderJob
 	unsigned int StartIndex;
 	unsigned int EndIndex;
 	glm::mat4 ModelMatrix;
+	float Transparent;
 
 	void CalculateHash() override
 	{
@@ -98,4 +99,16 @@ private:
 	std::forward_list<std::shared_ptr<RenderJob>> m_Jobs;
 };
 
+struct RenderQueuePair
+{
+	RenderQueue Deferred;
+	RenderQueue Forward;
+
+	void Clear()
+	{
+		Deferred.Clear();
+		Forward.Clear();
+	}
+};
+
 #endif // RenderQueue_h__

src/Renderer.cpp

@@ -74,10 +74,6 @@ void Renderer::Initialize()
 	m_Camera->SetPosition(glm::vec3(0.0f, 0.0f, 2.f));
 
 	glfwSwapInterval(m_VSync);
-	glEnable(GL_CULL_FACE);
-	glCullFace(GL_BACK);
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_SCISSOR_TEST);
 
 	LoadContent();
 }
@@ -108,6 +104,11 @@ void Renderer::LoadContent()
 	m_ShaderProgramDebugAABB.Compile();
 	m_ShaderProgramDebugAABB.Link();*/
 
+	m_FinalForwardPassProgram.AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FinalForwardPass.vert.glsl")));
+	m_FinalForwardPassProgram.AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FinalForwardPass.frag.glsl")));
+	m_FinalForwardPassProgram.Compile();
+	m_FinalForwardPassProgram.Link();
+
  	m_BlendMapProgram.AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/BlendMap.vert.glsl")));
  	m_BlendMapProgram.AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/BlendMap.frag.glsl")));
  	m_BlendMapProgram.Compile();
@@ -126,6 +127,7 @@ void Renderer::LoadContent()
 	m_ForwardRendering.AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardRendering.vert.glsl")));
 	m_ForwardRendering.AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardRendering.frag.glsl")));
 	m_ForwardRendering.Compile();
+	glBindFragDataLocation(m_ForwardRendering.GetHandle(), 0, "frag_Diffuse");
 	m_ForwardRendering.Link();
 
 	m_ShaderProgramShadows.AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShadowMap.vert.glsl")));
@@ -261,7 +263,7 @@ void Renderer::Draw(double dt)
 	glfwSwapBuffers(m_Window);
 }
 
-void Renderer::DrawFrame(RenderQueue &rq)
+void Renderer::DrawFrame(RenderQueuePair &rq)
 {
 	glBindFramebuffer(GL_FRAMEBUFFER, 0);
 	glViewport(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
@@ -305,7 +307,7 @@ void Renderer::DrawFrame(RenderQueue &rq)
 	//	}
 	//}
 
-	for (auto &job : rq)
+	for (auto &job : rq.Forward)
 	{
 		//auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 		//if (modelJob)
@@ -358,11 +360,16 @@ void Renderer::DrawFrame(RenderQueue &rq)
 	}
 }
 
-void Renderer::DrawWorld(RenderQueue &rq)
+void Renderer::DrawWorld(RenderQueuePair &rq)
 {
 	glDisable(GL_BLEND);
+	glEnable(GL_CULL_FACE);
+	glCullFace(GL_BACK);
+	glEnable(GL_DEPTH_TEST);
+	glDepthMask(GL_TRUE);
+	glEnable(GL_SCISSOR_TEST);
 
-	DrawShadowMap(rq);
+	//DrawShadowMap(rq.Deferred);
 
 	/*
 	Base pass
@@ -385,12 +392,14 @@ void Renderer::DrawWorld(RenderQueue &rq)
 
 	glCullFace(GL_BACK);
 	glEnable(GL_DEPTH_TEST);
-	DrawFBOScene(rq);
+	DrawFBOScene(rq.Deferred);
 
 	/*
 	Lighting pass
 	*/
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbLightingPass);
+	glViewport(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
+	glScissor(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
 	GLenum lightingPassAttachments[] = { GL_COLOR_ATTACHMENT0 };
 	glDrawBuffers(1, lightingPassAttachments);
 
@@ -406,7 +415,7 @@ void Renderer::DrawWorld(RenderQueue &rq)
 	glBindTexture(GL_TEXTURE_2D, m_fSpecularTexture);
 
 	glCullFace(GL_FRONT);
-	DrawLightScene(rq);
+	DrawLightScene(rq.Deferred);
 	DrawSunLightScene();
 
 	/*
@@ -415,7 +424,9 @@ void Renderer::DrawWorld(RenderQueue &rq)
 	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
 	//glViewport(m_Viewport.X, m_Viewport.Y, m_Viewport.Width, m_Viewport.Height);
 	glViewport(0, 0, m_Width, m_Height);
-	glScissor(0, 0, m_Width, m_Height);
+	//glScissor(0, 0, m_Width, m_Height);
+	glScissor(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
+
 	glClear(GL_DEPTH_BUFFER_BIT);
 
 	m_FinalPassProgram.Bind();
@@ -433,6 +444,126 @@ void Renderer::DrawWorld(RenderQueue &rq)
 	glBindVertexArray(m_ScreenQuad);
 	glEnableVertexAttribArray(0);
 	glDrawArrays(GL_TRIANGLES, 0, 6);
+
+	/*
+		Transparency
+	*/
+	ForwardRendering(rq.Forward);
+}
+
+void Renderer::ForwardRendering(RenderQueue &rq)
+{
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbBasePass);
+
+	glViewport(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
+	glScissor(m_Viewport.X, m_Height - m_Viewport.Y - m_Viewport.Height, m_Viewport.Width, m_Viewport.Height);
+
+	// Clear G-buffer
+	GLenum attachments[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
+	glDrawBuffers(4, attachments);
+	glClearColor(0.f, 0.f, 0.f, 0.f);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glEnable(GL_DEPTH_TEST);
+	glDepthMask(GL_FALSE);
+
+	glEnable(GL_CULL_FACE);
+	glCullFace(GL_BACK);
+
+	glm::mat4 cameraProjection = m_Camera->ProjectionMatrix((float)m_Viewport.Width / m_Viewport.Height);
+	glm::mat4 cameraMatrix = cameraProjection * m_Camera->ViewMatrix();
+	glm::mat4 MVP;
+
+	m_ForwardRendering.Bind();
+	GLuint ShaderProgramHandle = m_ForwardRendering.GetHandle();
+	for (auto &job : rq)
+	{
+		auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+		if (modelJob)
+		{
+			glm::mat4 modelMatrix = modelJob->ModelMatrix;
+			MVP = cameraMatrix * modelMatrix;
+
+			glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
+			glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
+			glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
+			glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "P"), 1, GL_FALSE, glm::value_ptr(cameraProjection));
+
+			glBindVertexArray(modelJob->VAO);
+
+			glActiveTexture(GL_TEXTURE0);
+			glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture);
+			if (modelJob->NormalTexture != 0)
+			{
+				glActiveTexture(GL_TEXTURE2);
+				glBindTexture(GL_TEXTURE_2D, modelJob->NormalTexture);
+			}
+			if (modelJob->SpecularTexture)
+			{
+				glActiveTexture(GL_TEXTURE3);
+				glBindTexture(GL_TEXTURE_2D, modelJob->SpecularTexture);
+			}
+			glDrawArrays(GL_TRIANGLES, modelJob->StartIndex, modelJob->EndIndex - modelJob->StartIndex + 1);
+
+			continue;
+		}
+	}
+	//glDepthMask (GL_TRUE);
+	//glDisable (GL_BLEND);
+
+	/*
+	Final pass
+	*/
+	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+	glViewport(0, 0, m_Width, m_Height);
+	glScissor(0, 0, m_Width, m_Height);
+
+	glDisable(GL_DEPTH_TEST);
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	m_FinalForwardPassProgram.Bind();
+	//ShaderProgramHandle = m_FinalForwardPassProgram.GetHandle();
+
+	// Ambient light
+	//glUniform3fv(glGetUniformLocation(ShaderProgramHandle, "La"), 1, glm::value_ptr(glm::vec3(0.7f)));
+	//glUniform1f(glGetUniformLocation(ShaderProgramHandle, "Gamma"), Gamma);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, m_fDiffuseTexture);
+
+	glCullFace(GL_BACK);
+	glBindVertexArray(m_ScreenQuad);
+	glEnableVertexAttribArray(0);
+	glDrawArrays(GL_TRIANGLES, 0, 6);
+
+
+
+	//for (auto tuple : ModelsToRender) //// Todo: Add so it's TransparentModelsToRender
+	//{
+	//	Model* model;
+	//	glm::mat4 modelMatrix;
+	//	bool visible;
+	//	std::tie(model, modelMatrix, visible, std::ignore) = tuple;
+	//	if (!visible)
+	//		continue;
+
+	//	MVP = cameraMatrix * modelMatrix;
+	//	glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
+	//	glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
+	//	glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
+	//	glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Camera->ProjectionMatrix((float)m_Width / m_Height)));
+
+	//	glBindVertexArray(model->VAO);
+	//	for (auto texGroup : model->TextureGroups)
+	//	{
+	//		glActiveTexture(GL_TEXTURE0);
+	//		glBindTexture(GL_TEXTURE_2D, *texGroup.Texture);
+	//		glDrawArrays(GL_TRIANGLES, texGroup.StartIndex, texGroup.EndIndex - texGroup.StartIndex + 1);
+	//	}
+	//}
 }
 
 void Renderer::Swap()
@@ -855,9 +986,6 @@ void Renderer::FrameBufferTextures()
 		LOG_ERROR("DeferredLighting:Init: m_fbLightingPass incomplete: 0x%x\n", fbStatus);
 		//exit(1);
 	}
-
-
-
 }
 
 void Renderer::DrawFBO()
@@ -943,9 +1071,8 @@ void Renderer::DrawFBO()
 	//}
 }
 
-void Renderer::DrawFBO2()
+void Renderer::DrawFBO2(RenderQueue &rq)
 {
-	ForwardRendering();
 }
 
 void Renderer::DrawFBOScene(RenderQueue &rq)
@@ -1137,7 +1264,7 @@ void Renderer::DrawSunLightScene()
 	glCullFace(GL_BACK);
 
 	glEnable(GL_BLEND);
-	glBlendEquation (GL_FUNC_ADD);
+	glBlendEquation(GL_FUNC_ADD);
 	glBlendFunc(GL_ONE,GL_ONE);
 
 	glDisable (GL_DEPTH_TEST);
@@ -1216,49 +1343,6 @@ void Renderer::UpdateSunProjection()
 	//Pass the bounding box's extents to glOrtho or similar to set up the orthographic projection matrix for the shadow map.
 }
 
-void Renderer::ForwardRendering()
-{
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	glViewport(0, 0, m_Width, m_Height);
-
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	glClearColor(0.0f, 0.5f, 0.0f, 1.0f);
-
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_CULL_FACE);
-	glCullFace(GL_BACK);
-
-	glm::mat4 cameraMatrix = m_Camera->ProjectionMatrix((float)m_Width / m_Height) * m_Camera->ViewMatrix();
-	glm::mat4 MVP;
-
-	m_ForwardRendering.Bind();
-	GLuint ShaderProgramHandle = m_ForwardRendering.GetHandle();
-
-	for (auto tuple : ModelsToRender) //// Todo: Add so it's TransparentModelsToRender
-	{
-		Model* model;
-		glm::mat4 modelMatrix;
-		bool visible;
-		std::tie(model, modelMatrix, visible, std::ignore) = tuple;
-		if (!visible)
-			continue;
-
-		MVP = cameraMatrix * modelMatrix;
-		glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "MVP"), 1, GL_FALSE, glm::value_ptr(MVP));
-		glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
-		glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Camera->ViewMatrix()));
-		glUniformMatrix4fv(glGetUniformLocation(ShaderProgramHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Camera->ProjectionMatrix((float)m_Width / m_Height)));
-
-		glBindVertexArray(model->VAO);
-		for (auto texGroup : model->TextureGroups)
-		{
-			glActiveTexture(GL_TEXTURE0);
-			glBindTexture(GL_TEXTURE_2D, *texGroup.Texture);
-			glDrawArrays(GL_TRIANGLES, texGroup.StartIndex, texGroup.EndIndex - texGroup.StartIndex + 1);
-		}
-	}
-}
-
 void Renderer::RegisterCamera(int identifier, float FOV, float nearClip, float farClip)
 {
 	m_Cameras[identifier] = std::make_shared<Camera>(FOV, nearClip, farClip);

src/Renderer.h

@@ -53,8 +53,8 @@ public:
 		m_Camera = camera;
 	}
 
-	void DrawFrame(RenderQueue &rq);
+	void DrawFrame(RenderQueuePair &rq);
-	void DrawWorld(RenderQueue &rq);
+	void DrawWorld(RenderQueuePair &rq);
 	void Swap();
 
 #pragma endregion
@@ -174,6 +174,7 @@ private:
 	ShaderProgram m_SunPassProgram;
 	ShaderProgram m_ForwardRendering;
 	ShaderProgram m_BlendMapProgram;
+	ShaderProgram m_FinalForwardPassProgram;
 
 	ShaderProgram m_ShaderProgramNormals;
 	ShaderProgram m_ShaderProgramShadows;
@@ -190,7 +191,7 @@ private:
 	void CreateShadowMap(int resolution);
 	void FrameBufferTextures();
 	void DrawFBO();
-	void DrawFBO2();
+	void DrawFBO2(RenderQueue &rq);
 	void DrawFBOScene(RenderQueue &rq);
 	void DrawLightScene(RenderQueue &rq);
 	void DrawSunLightScene();
@@ -198,7 +199,7 @@ private:
 	glm::mat4 CreateLightMatrix(Light &_light);
 	void UpdateSunProjection();
 	void CreateNormalMapTangent();
-	void ForwardRendering();
+	void ForwardRendering(RenderQueue &rq);
 
 	
 	GLuint CreateQuad();

src/Shaders/FinalForwardPass.frag.glsl

@@ -0,0 +1,25 @@
+#version 430
+
+//uniform vec3 La;
+
+layout (binding=0) uniform sampler2D DiffuseTexture;
+
+in VertexData
+{
+	vec3 Position;
+	vec2 TextureCoord;
+} Input;
+
+out vec4 FragmentColor;
+
+void main()
+{
+	vec4 DiffuseTexel = texture(DiffuseTexture, Input.TextureCoord);
+	//vec4 LightingTexel = texture(LightingTexture, Input.TextureCoord);
+
+	//FragmentColor = LightingTexel + vec4(LightingTexel.a, LightingTexel.a, LightingTexel.a, 0.0);
+	//FragmentColor = DiffuseTexel;
+
+	FragmentColor = DiffuseTexel;
+	//FragmentColor = vec4(pow(_FragmentColor.rgb, vec3(1.0 / Gamma)), _FragmentColor.a);
+}

src/Shaders/FinalForwardPass.vert.glsl

@@ -0,0 +1,16 @@
+#version 430
+
+layout(location = 0) in vec3 Position;
+
+out VertexData
+{
+	vec3 Position;
+	vec2 TextureCoord;
+} Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+	Output.Position = Position;
+	Output.TextureCoord = (vec2(Position) + 1) / 2;
+}

src/Shaders/FinalPass.frag.glsl

@@ -5,7 +5,6 @@ uniform float Gamma;
 
 layout (binding=0) uniform sampler2D DiffuseTexture;
 layout (binding=1) uniform sampler2D LightingTexture;
-layout (binding=2) uniform sampler2D ShadowTexture;
 
 in VertexData
 {
@@ -19,12 +18,10 @@ void main()
 {
 	vec4 DiffuseTexel = texture(DiffuseTexture, Input.TextureCoord);
 	vec4 LightingTexel = texture(LightingTexture, Input.TextureCoord);
-	vec4 ShadowTexel = texture(ShadowTexture, Input.TextureCoord);
 
 	//FragmentColor = LightingTexel + vec4(LightingTexel.a, LightingTexel.a, LightingTexel.a, 0.0);
 	//FragmentColor = DiffuseTexel;
 
 	FragmentColor = DiffuseTexel * (vec4(La, 0.0) + vec4(LightingTexel.rgb, 0.0)) + vec4(LightingTexel.a, LightingTexel.a, LightingTexel.a, 0.0);
 	//FragmentColor = vec4(pow(_FragmentColor.rgb, vec3(1.0 / Gamma)), _FragmentColor.a);
-	
 }

src/Shaders/ForwardRendering.frag.glsl

@@ -10,11 +10,11 @@ in VertexData {
 	vec2 TextureCoord;
 } Input;
  
-out vec4 fragmentColor;
+out vec4 frag_Diffuse;
 
 void main() {
 	// Texture
 	vec4 texel = texture(texture0, Input.TextureCoord);
 
-	fragmentColor = texel * Color;
+	frag_Diffuse = texel;
 }

vs11/Returngeance/Returngeance.vcxproj

@@ -238,6 +238,8 @@
     <None Include="..\..\src\Shaders\AABB.frag.glsl" />
     <None Include="..\..\src\Shaders\BlendMap.frag.glsl" />
     <None Include="..\..\src\Shaders\BlendMap.vert.glsl" />
+    <None Include="..\..\src\Shaders\FinalForwardPass.frag.glsl" />
+    <None Include="..\..\src\Shaders\FinalForwardPass.vert.glsl" />
     <None Include="..\..\src\Shaders\FinalPass.frag.glsl" />
     <None Include="..\..\src\Shaders\FinalPass.vert.glsl" />
     <None Include="..\..\src\Shaders\ForwardRendering.frag.glsl" />

vs11/Returngeance/Returngeance.vcxproj.filters

@@ -549,5 +549,11 @@
     <None Include="..\..\src\Shaders\BlendMap.vert.glsl">
       <Filter>Shaders</Filter>
     </None>
+    <None Include="..\..\src\Shaders\FinalForwardPass.frag.glsl">
+      <Filter>Shaders</Filter>
+    </None>
+    <None Include="..\..\src\Shaders\FinalForwardPass.vert.glsl">
+      <Filter>Shaders</Filter>
+    </None>
   </ItemGroup>
 </Project>