From 78a10379833104d9423ddc226171602dcf09fec8 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Wed, 20 Jan 2016 13:34:56 +0100
Subject: [PATCH 01/13] WIP

DrawScreenQuad implemented and working.
Started work on HDR coloring.
---
 include/Engine/Rendering/DrawBloomEffect.h    | 38 +++++++++++
 include/Engine/Rendering/DrawFinalPass.h      |  9 +--
 include/Engine/Rendering/DrawScreenQuadPass.h | 28 ++++++++
 .../Rendering/DrawScreenQuadPassState.h       | 15 +++++
 include/Engine/Rendering/Renderer.h           |  7 +-
 resources/Shaders/ForwardPlus.frag.glsl       | 30 ++++++---
 src/Engine/Rendering/DrawBloomEffect.cpp      | 66 +++++++++++++++++++
 src/Engine/Rendering/DrawFinalPass.cpp        | 30 +++++++++
 src/Engine/Rendering/DrawFinalPassState.cpp   |  2 +-
 src/Engine/Rendering/DrawScreenQuadPass.cpp   | 36 ++++++++++
 .../Rendering/DrawScreenQuadPassState.cpp     | 20 ++++++
 src/Engine/Rendering/FrameBuffer.cpp          |  3 +-
 src/Engine/Rendering/PickingPass.cpp          |  5 --
 src/Engine/Rendering/Renderer.cpp             | 30 +--------
 14 files changed, 269 insertions(+), 50 deletions(-)
 create mode 100644 include/Engine/Rendering/DrawBloomEffect.h
 create mode 100644 include/Engine/Rendering/DrawScreenQuadPass.h
 create mode 100644 include/Engine/Rendering/DrawScreenQuadPassState.h
 create mode 100644 src/Engine/Rendering/DrawBloomEffect.cpp
 create mode 100644 src/Engine/Rendering/DrawScreenQuadPass.cpp
 create mode 100644 src/Engine/Rendering/DrawScreenQuadPassState.cpp

diff --git a/include/Engine/Rendering/DrawBloomEffect.h b/include/Engine/Rendering/DrawBloomEffect.h
new file mode 100644
index 00000000..52876592
--- /dev/null
+++ b/include/Engine/Rendering/DrawBloomEffect.h
@@ -0,0 +1,38 @@
+#ifndef DrawFinalPass_h__
+#define DrawFinalPass_h__
+
+#include "IRenderer.h"
+#include "DrawFinalPassState.h"
+#include "LightCullingPass.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawFinalPass
+{
+public:
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass);
+    ~DrawFinalPass() { }
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(RenderScene& scene);
+
+    //Getters
+
+
+private:
+    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+    Texture* m_WhiteTexture;
+
+    const IRenderer* m_Renderer;
+    const LightCullingPass* m_LightCullingPass;
+
+    ShaderProgram* m_ForwardPlusProgram;
+
+};
+
+#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h
index 52876592..407ad58c 100644
--- a/include/Engine/Rendering/DrawFinalPass.h
+++ b/include/Engine/Rendering/DrawFinalPass.h
@@ -17,11 +17,13 @@ public:
     void InitializeTextures();
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
-
     void Draw(RenderScene& scene);
 
-    //Getters
-
+    //Todo: Should not be public
+    FrameBuffer m_BloomFrameBuffer;
+    GLuint m_BloomTexture;
+    GLuint m_SceneTexture;
+    GLuint m_DepthBuffer;
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
@@ -32,7 +34,6 @@ private:
     const LightCullingPass* m_LightCullingPass;
 
     ShaderProgram* m_ForwardPlusProgram;
-
 };
 
 #endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawScreenQuadPass.h b/include/Engine/Rendering/DrawScreenQuadPass.h
new file mode 100644
index 00000000..117e9e1e
--- /dev/null
+++ b/include/Engine/Rendering/DrawScreenQuadPass.h
@@ -0,0 +1,28 @@
+#ifndef DrawScreenQuadPass_h__
+#define DrawScreenQuadPass_h__
+
+#include "IRenderer.h"
+#include "DrawScreenQuadPassState.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+//#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawScreenQuadPass
+{
+public:
+    DrawScreenQuadPass(IRenderer* renderer);
+    ~DrawScreenQuadPass() { }
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(GLuint texture);
+private:
+    const IRenderer* m_Renderer;
+
+    ShaderProgram* m_DrawQuadProgram;
+
+    Model* m_ScreenQuad;
+};
+
+#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawScreenQuadPassState.h b/include/Engine/Rendering/DrawScreenQuadPassState.h
new file mode 100644
index 00000000..63ab4729
--- /dev/null
+++ b/include/Engine/Rendering/DrawScreenQuadPassState.h
@@ -0,0 +1,15 @@
+#ifndef DrawScreenQuadPassState_h__
+#define DrawScreenQuadPassState_h__
+
+#include "Rendering/RenderState.h"
+
+class DrawScreenQuadPassState : public RenderState
+{
+public:
+    DrawScreenQuadPassState();
+    ~DrawScreenQuadPassState();
+private:
+
+};
+
+#endif
\ No newline at end of file
diff --git a/include/Engine/Rendering/Renderer.h b/include/Engine/Rendering/Renderer.h
index 0006cca1..7dcf7e6a 100644
--- a/include/Engine/Rendering/Renderer.h
+++ b/include/Engine/Rendering/Renderer.h
@@ -14,6 +14,7 @@
 #include "DrawScenePass.h"
 #include "LightCullingPass.h"
 #include "DrawFinalPass.h"
+#include "DrawScreenQuadPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
@@ -48,6 +49,7 @@ private:
     LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;
     DrawFinalPass* m_DrawFinalPass;
+    DrawScreenQuadPass* m_DrawScreenQuadPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();
@@ -57,14 +59,13 @@ private:
     //TODO: Renderer: Get InputUpdate out of renderer
     void InputUpdate(double dt);
     //void PickingPass(RenderQueueCollection& rq);
-    void DrawScreenQuad(GLuint textureToDraw);
+    //void DrawScreenQuad(GLuint textureToDraw);
 
     static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
     void SortRenderJobsByDepth(RenderScene &scene);
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
-	ShaderProgram* m_BasicForwardProgram;
-    ShaderProgram* m_DrawScreenQuadProgram;
+    ShaderProgram* m_BasicForwardProgram;
 };
 
 #endif
\ No newline at end of file
diff --git a/resources/Shaders/ForwardPlus.frag.glsl b/resources/Shaders/ForwardPlus.frag.glsl
index 78a2125e..6a810036 100644
--- a/resources/Shaders/ForwardPlus.frag.glsl
+++ b/resources/Shaders/ForwardPlus.frag.glsl
@@ -48,7 +48,8 @@ in VertexData{
 	vec4 DiffuseColor;
 }Input;
 
-out vec4 fragmentColor;
+out vec4 sceneColor;
+out vec4 bloomColor;
 
 vec4 scene_ambient = vec4(0.3,0.3,0.3,1);
 
@@ -121,6 +122,7 @@ void main()
 		LightSource light = LightSources.List[l];
 
 		LightResult result;
+		//These if statements should be removed.
 		if(light.Type == 1) { // point
 			result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
 		} else if (light.Type == 2) { //Directional
@@ -131,19 +133,29 @@ void main()
 	}
 
 
-	//fragmentColor += Input.DiffuseColor;
-	fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color;
-	//fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color;
-	//fragmentColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
-	//fragmentColor = texel * Input.DiffuseColor * Color;
-	//fragmentColor += vec4(currentTile/3600.f, 0, 0, 1);
+	//sceneColor += Input.DiffuseColor;
+	vec4 fragment = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color;
+	bloomColor = vec4(0.3, 0.8, 0.6, 1.0);
+	sceneColor = vec4(fragment.xyz, 1.0);
+	//These if statements should be removed.
+/*
+	if(fragment.x > 0.5 || fragment.y > 0.5 || fragment.z > 0.5) {
+		bloomColor = fragment;
+	} else {
+		bloomColor = vec4(0.3, 0.5, 0.8, 1.0);
+	}*/
+	
+	//sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color;
+	//sceneColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
+	//sceneColor = texel * Input.DiffuseColor * Color;
+	//sceneColor += vec4(currentTile/3600.f, 0, 0, 1);
 
 	//Tiled Debug Code
 	/*
 	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
-		fragmentColor += vec4(0.5, 0, 0, 0);
+		sceneColor += vec4(0.5, 0, 0, 0);
 	} else {
-		fragmentColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
 	}
 	*/
 }
diff --git a/src/Engine/Rendering/DrawBloomEffect.cpp b/src/Engine/Rendering/DrawBloomEffect.cpp
new file mode 100644
index 00000000..b0ca4afe
--- /dev/null
+++ b/src/Engine/Rendering/DrawBloomEffect.cpp
@@ -0,0 +1,66 @@
+#include "Rendering/DrawFinalPass.h"
+
+DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass)
+{
+    m_Renderer = renderer;
+    m_LightCullingPass = lightCullingPass;
+    InitializeTextures();
+    InitializeShaderPrograms();
+}
+
+void DrawFinalPass::InitializeTextures()
+{
+    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+}
+
+void DrawFinalPass::InitializeShaderPrograms()
+{
+    m_ForwardPlusProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram");
+    m_ForwardPlusProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
+    m_ForwardPlusProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlus.frag.glsl")));
+    m_ForwardPlusProgram->Compile();
+    m_ForwardPlusProgram->Link();
+}
+
+void DrawFinalPass::Draw(RenderScene& scene)
+{
+    GLERROR("DrawFinalPass::Draw: Pre");
+
+    DrawFinalPassState state;
+    m_ForwardPlusProgram->Bind();
+    GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
+
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
+    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
+
+    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ViewMatrix()));
+    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ProjectionMatrix()));
+    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+
+    //TODO: Render: Add code for more jobs than modeljobs.
+    for (auto &job : scene.ForwardJobs) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+        if(modelJob) {
+            //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+            glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
+
+            if(modelJob->DiffuseTexture != nullptr) {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
+            } else {
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
+            }
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
+
+            continue;
+        }
+    }
+    GLERROR("DrawFinalPass::Draw: END");
+
+}
diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp
index b0ca4afe..57940971 100644
--- a/src/Engine/Rendering/DrawFinalPass.cpp
+++ b/src/Engine/Rendering/DrawFinalPass.cpp
@@ -6,6 +6,7 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling
     m_LightCullingPass = lightCullingPass;
     InitializeTextures();
     InitializeShaderPrograms();
+    InitializeFrameBuffers();
 }
 
 void DrawFinalPass::InitializeTextures()
@@ -13,6 +14,21 @@ void DrawFinalPass::InitializeTextures()
     m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
 }
 
+void DrawFinalPass::InitializeFrameBuffers()
+{
+    glGenRenderbuffers(1, &m_DepthBuffer);
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
+
+    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    
+    m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
+    m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
+    m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
+    m_BloomFrameBuffer.Generate();
+}
+
 void DrawFinalPass::InitializeShaderPrograms()
 {
     m_ForwardPlusProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram");
@@ -26,6 +42,8 @@ void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("DrawFinalPass::Draw: Pre");
 
+    m_BloomFrameBuffer.Bind(); //in i state
+
     DrawFinalPassState state;
     m_ForwardPlusProgram->Bind();
     GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
@@ -64,3 +82,15 @@ void DrawFinalPass::Draw(RenderScene& scene)
     GLERROR("DrawFinalPass::Draw: END");
 
 }
+
+void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
+{
+    glGenTextures(1, texture);
+    glBindTexture(GL_TEXTURE_2D, *texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    GLERROR("Texture initialization failed");
+}
diff --git a/src/Engine/Rendering/DrawFinalPassState.cpp b/src/Engine/Rendering/DrawFinalPassState.cpp
index 1cb9d7da..5b4bbf3b 100644
--- a/src/Engine/Rendering/DrawFinalPassState.cpp
+++ b/src/Engine/Rendering/DrawFinalPassState.cpp
@@ -3,7 +3,7 @@
 
 DrawFinalPassState::DrawFinalPassState()
 {
-    BindFramebuffer(0);
+    //BindFramebuffer(0);
     Enable(GL_BLEND);
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
diff --git a/src/Engine/Rendering/DrawScreenQuadPass.cpp b/src/Engine/Rendering/DrawScreenQuadPass.cpp
new file mode 100644
index 00000000..4095db04
--- /dev/null
+++ b/src/Engine/Rendering/DrawScreenQuadPass.cpp
@@ -0,0 +1,36 @@
+#include "Rendering/DrawScreenQuadPass.h"
+
+DrawScreenQuadPass::DrawScreenQuadPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+
+    InitializeShaderPrograms();
+}
+
+void DrawScreenQuadPass::InitializeShaderPrograms()
+{
+    m_DrawQuadProgram = ResourceManager::Load<ShaderProgram>("#DrawScreenQuadProgram");
+    m_DrawQuadProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
+    m_DrawQuadProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
+    m_DrawQuadProgram->Compile();
+    m_DrawQuadProgram->Link();
+}
+
+void DrawScreenQuadPass::Draw(GLuint texture)
+{
+    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    GLERROR("DrawScreenQuadPass::Draw: Pre");
+
+    DrawScreenQuadPassState state = DrawScreenQuadPassState();
+    m_DrawQuadProgram->Bind();
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, texture);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+}
diff --git a/src/Engine/Rendering/DrawScreenQuadPassState.cpp b/src/Engine/Rendering/DrawScreenQuadPassState.cpp
new file mode 100644
index 00000000..1ee5d9a7
--- /dev/null
+++ b/src/Engine/Rendering/DrawScreenQuadPassState.cpp
@@ -0,0 +1,20 @@
+#include "Rendering/DrawScreenQuadPassState.h"
+
+
+DrawScreenQuadPassState::DrawScreenQuadPassState()
+{
+    GLERROR("---");
+    BindFramebuffer(0);
+    GLERROR("---");
+    Disable(GL_DEPTH_TEST);
+    Disable(GL_CULL_FACE);
+    Disable(GL_BLEND);
+    glClearColor(0.f, 0.f, 0.f, 1.f);
+   // ClearColor(glm::vec4(255.f / 255, 163.f / 255, 176.f / 255, 0.f));
+    Clear(GL_COLOR_BUFFER_BIT);
+}
+
+DrawScreenQuadPassState::~DrawScreenQuadPassState()
+{
+
+}
diff --git a/src/Engine/Rendering/FrameBuffer.cpp b/src/Engine/Rendering/FrameBuffer.cpp
index b2b29626..79507875 100644
--- a/src/Engine/Rendering/FrameBuffer.cpp
+++ b/src/Engine/Rendering/FrameBuffer.cpp
@@ -55,8 +55,9 @@ void FrameBuffer::Generate()
             glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
             GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
             if ( (*it)->m_Attachment != GL_COLOR_ATTACHMENT0 ||
+                (*it)->m_Attachment != GL_COLOR_ATTACHMENT1 ||
                 (*it)->m_Attachment != GL_DEPTH_ATTACHMENT ||
-                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT)
+                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT) //TODO: Viktor: Fixa detta
             {
                 LOG_ERROR("RenderBuffer Attachment not valid.");
             }
diff --git a/src/Engine/Rendering/PickingPass.cpp b/src/Engine/Rendering/PickingPass.cpp
index 6800df1d..a377fcec 100644
--- a/src/Engine/Rendering/PickingPass.cpp
+++ b/src/Engine/Rendering/PickingPass.cpp
@@ -46,15 +46,12 @@ void PickingPass::InitializeShaderPrograms()
 void PickingPass::Draw(RenderScene& scene)
 {
     PickingPassState* state = new PickingPassState(m_PickingBuffer.GetHandle());
-
     
     //TODO: Render: Add code for more jobs than modeljobs.
 
     GLuint ShaderHandle = m_PickingProgram->GetHandle();
     m_PickingProgram->Bind();
 
-    
-
         m_Camera = scene.Camera;
 
         for (auto &job : scene.ForwardJobs) {
@@ -95,11 +92,9 @@ void PickingPass::Draw(RenderScene& scene)
             }
         }
     
-    
     m_PickingBuffer.Unbind();
     GLERROR("PickingPass Error");
 
-
     delete state;
 }
 
diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index 8c30adfd..f08bfafd 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -69,12 +69,6 @@ void Renderer::InitializeWindow()
 void Renderer::InitializeShaders()
 {
     m_BasicForwardProgram = ResourceManager::Load<ShaderProgram>("#m_BasicForwardProgram");
-
-    m_DrawScreenQuadProgram = ResourceManager::Load<ShaderProgram>("#DrawScreenQuadProgram");
-    m_DrawScreenQuadProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
-    m_DrawScreenQuadProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
-    m_DrawScreenQuadProgram->Compile();
-    m_DrawScreenQuadProgram->Link();
 }
 
 void Renderer::InputUpdate(double dt)
@@ -105,6 +99,8 @@ void Renderer::Draw(RenderFrame& frame)
         m_LightCullingPass->FillLightList(*scene);
         m_LightCullingPass->CullLights(*scene);
         m_DrawFinalPass->Draw(*scene);
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_SceneTexture);
+        //m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_BloomTexture);
         //m_DrawScenePass->Draw(rq);
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
@@ -119,27 +115,6 @@ PickData Renderer::Pick(glm::vec2 screenCoord)
     return m_PickingPass->Pick(screenCoord);
 }
 
-void Renderer::DrawScreenQuad(GLuint textureToDraw)
-{
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_CULL_FACE);
-
-    glClearColor(0.f, 0.f, 0.f, 1.f);
-    glClear(GL_COLOR_BUFFER_BIT);
-
-
-    m_DrawScreenQuadProgram->Bind();
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, textureToDraw);
-
-    glBindVertexArray(m_ScreenQuad->VAO);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-}
-
 void Renderer::InitializeTextures()
 {
     m_ErrorTexture = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
@@ -171,4 +146,5 @@ void Renderer::InitializeRenderPasses()
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
     m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
+    m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
 }
\ No newline at end of file

From 86824f1b1f4fafe29f0d91530171b1bd12f9c929 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Wed, 20 Jan 2016 15:23:49 +0100
Subject: [PATCH 02/13] Colors above value 1 is now added to the bloomtexture,
 and will be used to get a glow effect in later stage.

---
 resources/Shaders/ForwardPlus.frag.glsl     | 13 ++++++-------
 src/Engine/Rendering/DrawFinalPass.cpp      |  3 ++-
 src/Engine/Rendering/DrawFinalPassState.cpp |  2 +-
 src/Engine/Rendering/FrameBuffer.cpp        |  4 +---
 src/Engine/Rendering/Renderer.cpp           |  4 ++--
 5 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/resources/Shaders/ForwardPlus.frag.glsl b/resources/Shaders/ForwardPlus.frag.glsl
index 6a810036..3fae9eb6 100644
--- a/resources/Shaders/ForwardPlus.frag.glsl
+++ b/resources/Shaders/ForwardPlus.frag.glsl
@@ -132,18 +132,17 @@ void main()
 		totalLighting.Specular += result.Specular;
 	}
 
-
 	//sceneColor += Input.DiffuseColor;
 	vec4 fragment = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color;
-	bloomColor = vec4(0.3, 0.8, 0.6, 1.0);
+	//bloomColor = vec4(0.3, 0.8, 0.6, 1.0);
 	sceneColor = vec4(fragment.xyz, 1.0);
 	//These if statements should be removed.
-/*
-	if(fragment.x > 0.5 || fragment.y > 0.5 || fragment.z > 0.5) {
-		bloomColor = fragment;
+
+	if(fragment.x > 1 || fragment.y > 1 || fragment.z > 1) {
+		bloomColor = vec4(fragment.xyz, 1.0);
 	} else {
-		bloomColor = vec4(0.3, 0.5, 0.8, 1.0);
-	}*/
+		bloomColor = vec4(0.0, 0.0, 0.0, 1.0);
+	}
 	
 	//sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color;
 	//sceneColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp
index 57940971..5a9f706e 100644
--- a/src/Engine/Rendering/DrawFinalPass.cpp
+++ b/src/Engine/Rendering/DrawFinalPass.cpp
@@ -27,6 +27,7 @@ void DrawFinalPass::InitializeFrameBuffers()
     m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
     m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
     m_BloomFrameBuffer.Generate();
+
 }
 
 void DrawFinalPass::InitializeShaderPrograms()
@@ -79,8 +80,8 @@ void DrawFinalPass::Draw(RenderScene& scene)
             continue;
         }
     }
+    m_BloomFrameBuffer.Unbind();
     GLERROR("DrawFinalPass::Draw: END");
-
 }
 
 void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
diff --git a/src/Engine/Rendering/DrawFinalPassState.cpp b/src/Engine/Rendering/DrawFinalPassState.cpp
index 5b4bbf3b..43047f05 100644
--- a/src/Engine/Rendering/DrawFinalPassState.cpp
+++ b/src/Engine/Rendering/DrawFinalPassState.cpp
@@ -8,7 +8,7 @@ DrawFinalPassState::DrawFinalPassState()
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
-    ClearColor(glm::vec4(200.f / 255, 0.f / 255, 200.f / 255, 0.f));
+    ClearColor(glm::vec4(155.f / 255, 0.f / 255, 155.f / 255, 0.f));
     Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }
 
diff --git a/src/Engine/Rendering/FrameBuffer.cpp b/src/Engine/Rendering/FrameBuffer.cpp
index 79507875..b7e908cc 100644
--- a/src/Engine/Rendering/FrameBuffer.cpp
+++ b/src/Engine/Rendering/FrameBuffer.cpp
@@ -70,10 +70,8 @@ void FrameBuffer::Generate()
         }
     }
         
-   
-    
     GLenum* bufferTextures = &attachments[0];
-    glDrawBuffers(1, bufferTextures);
+    glDrawBuffers(attachments.size(), bufferTextures);
 
     if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
         LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);
diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index f08bfafd..894f358f 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -99,8 +99,8 @@ void Renderer::Draw(RenderFrame& frame)
         m_LightCullingPass->FillLightList(*scene);
         m_LightCullingPass->CullLights(*scene);
         m_DrawFinalPass->Draw(*scene);
-        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_SceneTexture);
-        //m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_BloomTexture);
+        //m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_SceneTexture);
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_BloomTexture);
         //m_DrawScenePass->Draw(rq);
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");

From 983f90504d54ab0feca4b7b959fd572426799502 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Thu, 21 Jan 2016 12:02:28 +0100
Subject: [PATCH 03/13] Bloom effect added, will have to see if it needs
 improving. Also added HDR colors and gamma correction.

---
 include/Engine/Rendering/DrawBloomEffect.h    |  38 ------
 include/Engine/Rendering/DrawBloomPass.h      |  48 +++++++
 include/Engine/Rendering/DrawBloomPassState.h |  15 +++
 .../Rendering/DrawColorCorrectionPass.h       |  29 +++++
 include/Engine/Rendering/Renderer.h           |   4 +
 .../Shaders/DrawColorCorrection.frag.glsl     |  32 +++++
 .../Shaders/DrawColorCorrection.vert.glsl     |  13 ++
 resources/Shaders/Gaussian_horiz.frag.glsl    |  23 ++++
 resources/Shaders/Gaussian_horiz.vert.glsl    |  13 ++
 resources/Shaders/Gaussian_vert.frag.glsl     |  23 ++++
 resources/Shaders/Gaussian_vert.vert.glsl     |  13 ++
 src/Engine/Rendering/DrawBloomEffect.cpp      |  66 ----------
 src/Engine/Rendering/DrawBloomPass.cpp        | 121 ++++++++++++++++++
 src/Engine/Rendering/DrawBloomPassState.cpp   |  17 +++
 .../Rendering/DrawColorCorrectionPass.cpp     |  41 ++++++
 src/Engine/Rendering/Renderer.cpp             |   7 +-
 16 files changed, 398 insertions(+), 105 deletions(-)
 delete mode 100644 include/Engine/Rendering/DrawBloomEffect.h
 create mode 100644 include/Engine/Rendering/DrawBloomPass.h
 create mode 100644 include/Engine/Rendering/DrawBloomPassState.h
 create mode 100644 include/Engine/Rendering/DrawColorCorrectionPass.h
 create mode 100644 resources/Shaders/DrawColorCorrection.frag.glsl
 create mode 100644 resources/Shaders/DrawColorCorrection.vert.glsl
 create mode 100644 resources/Shaders/Gaussian_horiz.frag.glsl
 create mode 100644 resources/Shaders/Gaussian_horiz.vert.glsl
 create mode 100644 resources/Shaders/Gaussian_vert.frag.glsl
 create mode 100644 resources/Shaders/Gaussian_vert.vert.glsl
 delete mode 100644 src/Engine/Rendering/DrawBloomEffect.cpp
 create mode 100644 src/Engine/Rendering/DrawBloomPass.cpp
 create mode 100644 src/Engine/Rendering/DrawBloomPassState.cpp
 create mode 100644 src/Engine/Rendering/DrawColorCorrectionPass.cpp

diff --git a/include/Engine/Rendering/DrawBloomEffect.h b/include/Engine/Rendering/DrawBloomEffect.h
deleted file mode 100644
index 52876592..00000000
--- a/include/Engine/Rendering/DrawBloomEffect.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef DrawFinalPass_h__
-#define DrawFinalPass_h__
-
-#include "IRenderer.h"
-#include "DrawFinalPassState.h"
-#include "LightCullingPass.h"
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-
-class DrawFinalPass
-{
-public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass);
-    ~DrawFinalPass() { }
-    void InitializeTextures();
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-
-    void Draw(RenderScene& scene);
-
-    //Getters
-
-
-private:
-    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-
-    Texture* m_WhiteTexture;
-
-    const IRenderer* m_Renderer;
-    const LightCullingPass* m_LightCullingPass;
-
-    ShaderProgram* m_ForwardPlusProgram;
-
-};
-
-#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawBloomPass.h b/include/Engine/Rendering/DrawBloomPass.h
new file mode 100644
index 00000000..d192c73a
--- /dev/null
+++ b/include/Engine/Rendering/DrawBloomPass.h
@@ -0,0 +1,48 @@
+#ifndef DrawBloomPass_h__
+#define DrawBloomPass_h__
+
+#include "IRenderer.h"
+#include "DrawBloomPassState.h"
+//#include "LightCullingPass.h" Finalpass om den skall skickas in
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+//#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawBloomPass
+{
+public:
+    DrawBloomPass(IRenderer* renderer /* ,Texture or finalpass*/ );
+    ~DrawBloomPass() { }
+    void InitializeTextures();
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+    void InitializeBuffers();
+
+    void FillGaussianBuffer(FrameBuffer* fb);
+
+    void Draw(GLuint texture);
+
+    //Getters
+    GLuint m_GaussianTexture_horiz;
+    GLuint m_GaussianTexture_vert;
+
+private:
+    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+
+    Texture* m_WhiteTexture;
+    Model* m_ScreenQuad;
+
+    const IRenderer* m_Renderer;
+    //const LightCullingPass* m_LightCullingPass 
+    GLuint m_iterations = 9;
+
+    FrameBuffer m_GaussianFrameBuffer_horiz;
+    FrameBuffer m_GaussianFrameBuffer_vert;
+
+    ShaderProgram* m_GaussianProgram_horiz;
+    ShaderProgram* m_GaussianProgram_vert;
+
+};
+
+#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawBloomPassState.h b/include/Engine/Rendering/DrawBloomPassState.h
new file mode 100644
index 00000000..7f2094cf
--- /dev/null
+++ b/include/Engine/Rendering/DrawBloomPassState.h
@@ -0,0 +1,15 @@
+#ifndef DrawBloomPassState_h__
+#define DrawBloomPassState_h__
+
+#include "Rendering/RenderState.h"
+
+class DrawBloomPassState : public RenderState
+{
+public:
+    DrawBloomPassState();
+    ~DrawBloomPassState();
+private:
+
+};
+
+#endif
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawColorCorrectionPass.h b/include/Engine/Rendering/DrawColorCorrectionPass.h
new file mode 100644
index 00000000..e9a7e281
--- /dev/null
+++ b/include/Engine/Rendering/DrawColorCorrectionPass.h
@@ -0,0 +1,29 @@
+#ifndef DrawColorCorrectionPass_h__
+#define DrawColorCorrectionPass_h__
+
+#include "IRenderer.h"
+#include "DrawScreenQuadPassState.h"
+#include "FrameBuffer.h"
+#include "ShaderProgram.h"
+//#include "Util/UnorderedMapVec2.h"
+#include "Texture.h"
+
+class DrawColorCorrectionPass
+{
+public:
+    DrawColorCorrectionPass(IRenderer* renderer);
+    ~DrawColorCorrectionPass() { }
+    void InitializeFrameBuffers();
+    void InitializeShaderPrograms();
+
+    void Draw(GLuint sceneTexture, GLuint bloomTexture);
+private:
+    const IRenderer* m_Renderer;
+
+    ShaderProgram* m_ColorCorrectionProgram;
+
+    Model* m_ScreenQuad;
+    GLfloat m_Exposure;
+};
+
+#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/Renderer.h b/include/Engine/Rendering/Renderer.h
index 7dcf7e6a..235bda89 100644
--- a/include/Engine/Rendering/Renderer.h
+++ b/include/Engine/Rendering/Renderer.h
@@ -15,6 +15,8 @@
 #include "LightCullingPass.h"
 #include "DrawFinalPass.h"
 #include "DrawScreenQuadPass.h"
+#include "DrawBloomPass.h"
+#include "DrawColorCorrectionPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
@@ -50,6 +52,8 @@ private:
     ImGuiRenderPass* m_ImGuiRenderPass;
     DrawFinalPass* m_DrawFinalPass;
     DrawScreenQuadPass* m_DrawScreenQuadPass;
+    DrawBloomPass* m_DrawBloomPass;
+    DrawColorCorrectionPass* m_DrawColorCorrectionPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();
diff --git a/resources/Shaders/DrawColorCorrection.frag.glsl b/resources/Shaders/DrawColorCorrection.frag.glsl
new file mode 100644
index 00000000..8d13992a
--- /dev/null
+++ b/resources/Shaders/DrawColorCorrection.frag.glsl
@@ -0,0 +1,32 @@
+#version 430
+
+layout (binding = 0) uniform sampler2D SceneTexture;
+layout (binding = 1) uniform sampler2D BloomTexture;
+uniform float Exposure;
+
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
+out vec4 fragmentColor;
+
+void main()
+{
+	const float gamma = 2.2;
+	vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate);
+	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
+	hdrColor += bloomColor;
+
+	//Toon mapping thingy
+	vec3 result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
+
+	//gamme correction
+	result = pow(result, vec3(1.0 / gamma));
+
+	fragmentColor = vec4(result, 1.0);
+	//fragmentColor = hdrColor;
+	//fragmentColor = bloomColor;
+	//fragmentColor = vec4(1,0.5,0.7,1);
+}
+
+
diff --git a/resources/Shaders/DrawColorCorrection.vert.glsl b/resources/Shaders/DrawColorCorrection.vert.glsl
new file mode 100644
index 00000000..346bc141
--- /dev/null
+++ b/resources/Shaders/DrawColorCorrection.vert.glsl
@@ -0,0 +1,13 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
+}
\ No newline at end of file
diff --git a/resources/Shaders/Gaussian_horiz.frag.glsl b/resources/Shaders/Gaussian_horiz.frag.glsl
new file mode 100644
index 00000000..bd48d2d5
--- /dev/null
+++ b/resources/Shaders/Gaussian_horiz.frag.glsl
@@ -0,0 +1,23 @@
+#version 430
+
+layout (binding = 0) uniform sampler2D Texture;
+
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
+out vec4 fragmentColor;
+
+uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+
+void main()
+{
+	vec2 tex_offset = 1.0 / textureSize(Texture, 0);
+	vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0];
+
+	for(int i = 1; i < 5; ++i) {
+	    result += texture(Texture, Input.TextureCoordinate + vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
+	    result += texture(Texture, Input.TextureCoordinate - vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
+	}
+	fragmentColor = vec4(result, 1.0);
+}
\ No newline at end of file
diff --git a/resources/Shaders/Gaussian_horiz.vert.glsl b/resources/Shaders/Gaussian_horiz.vert.glsl
new file mode 100644
index 00000000..346bc141
--- /dev/null
+++ b/resources/Shaders/Gaussian_horiz.vert.glsl
@@ -0,0 +1,13 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
+}
\ No newline at end of file
diff --git a/resources/Shaders/Gaussian_vert.frag.glsl b/resources/Shaders/Gaussian_vert.frag.glsl
new file mode 100644
index 00000000..25b08f9f
--- /dev/null
+++ b/resources/Shaders/Gaussian_vert.frag.glsl
@@ -0,0 +1,23 @@
+#version 430
+
+layout (binding = 0) uniform sampler2D Texture;
+
+in VertexData{
+	vec2 TextureCoordinate;
+}Input;
+
+out vec4 fragmentColor;
+
+uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+
+void main()
+{
+	vec2 tex_offset = 1.0 / textureSize(Texture, 0);
+	vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0];
+
+    for(int i = 1; i < 5; ++i) {
+        result += texture(Texture, Input.TextureCoordinate + vec2(0.0, tex_offset.y * i)).rgb * weight[i];
+        result += texture(Texture, Input.TextureCoordinate - vec2(0.0, tex_offset.y * i)).rgb * weight[i];
+    }
+    fragmentColor = vec4(result, 1.0);
+}
\ No newline at end of file
diff --git a/resources/Shaders/Gaussian_vert.vert.glsl b/resources/Shaders/Gaussian_vert.vert.glsl
new file mode 100644
index 00000000..346bc141
--- /dev/null
+++ b/resources/Shaders/Gaussian_vert.vert.glsl
@@ -0,0 +1,13 @@
+#version 430
+
+layout (location = 0) in vec3 Position;
+
+out VertexData{
+	vec2 TextureCoordinate;
+}Output;
+
+void main()
+{
+	gl_Position = vec4(Position, 1.0);
+	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
+}
\ No newline at end of file
diff --git a/src/Engine/Rendering/DrawBloomEffect.cpp b/src/Engine/Rendering/DrawBloomEffect.cpp
deleted file mode 100644
index b0ca4afe..00000000
--- a/src/Engine/Rendering/DrawBloomEffect.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-#include "Rendering/DrawFinalPass.h"
-
-DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass)
-{
-    m_Renderer = renderer;
-    m_LightCullingPass = lightCullingPass;
-    InitializeTextures();
-    InitializeShaderPrograms();
-}
-
-void DrawFinalPass::InitializeTextures()
-{
-    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
-}
-
-void DrawFinalPass::InitializeShaderPrograms()
-{
-    m_ForwardPlusProgram = ResourceManager::Load<ShaderProgram>("#ForwardPlusProgram");
-    m_ForwardPlusProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ForwardPlus.vert.glsl")));
-    m_ForwardPlusProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ForwardPlus.frag.glsl")));
-    m_ForwardPlusProgram->Compile();
-    m_ForwardPlusProgram->Link();
-}
-
-void DrawFinalPass::Draw(RenderScene& scene)
-{
-    GLERROR("DrawFinalPass::Draw: Pre");
-
-    DrawFinalPassState state;
-    m_ForwardPlusProgram->Bind();
-    GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
-
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, m_LightCullingPass->LightSSBO());
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
-    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
-
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ViewMatrix()));
-    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(m_Renderer->Camera()->ProjectionMatrix()));
-    glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
-
-    //TODO: Render: Add code for more jobs than modeljobs.
-    for (auto &job : scene.ForwardJobs) {
-        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
-        if(modelJob) {
-            //TODO: Kolla upp "header/include/common" shader saken så man slipper skicka in asmycket uniforms
-            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-            glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
-
-            if(modelJob->DiffuseTexture != nullptr) {
-                glActiveTexture(GL_TEXTURE0);
-                glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
-            } else {
-                glActiveTexture(GL_TEXTURE0);
-                glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
-            }
-
-            glBindVertexArray(modelJob->Model->VAO);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, 0, modelJob->StartIndex);
-
-            continue;
-        }
-    }
-    GLERROR("DrawFinalPass::Draw: END");
-
-}
diff --git a/src/Engine/Rendering/DrawBloomPass.cpp b/src/Engine/Rendering/DrawBloomPass.cpp
new file mode 100644
index 00000000..20e5f0c0
--- /dev/null
+++ b/src/Engine/Rendering/DrawBloomPass.cpp
@@ -0,0 +1,121 @@
+#include "Rendering/DrawBloomPass.h"
+
+DrawBloomPass::DrawBloomPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+
+    InitializeTextures();
+    InitializeBuffers();
+    InitializeShaderPrograms();
+}
+
+void DrawBloomPass::InitializeTextures()
+{
+    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+}
+
+void DrawBloomPass::InitializeShaderPrograms()
+{
+    m_GaussianProgram_horiz = ResourceManager::Load<ShaderProgram>("##GaussianProgramHoriz");
+    m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_horiz.vert.glsl")));
+    m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl")));
+    m_GaussianProgram_horiz->Compile();
+    m_GaussianProgram_horiz->Link();
+
+    m_GaussianProgram_vert = ResourceManager::Load<ShaderProgram>("##GaussianProgramVert");
+    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_vert.vert.glsl")));
+    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_vert.frag.glsl")));
+    m_GaussianProgram_vert->Compile();
+    m_GaussianProgram_vert->Link();
+}
+
+
+void DrawBloomPass::InitializeBuffers()
+{
+    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+
+    m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
+    m_GaussianFrameBuffer_horiz.Generate();
+
+    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+
+    m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
+    m_GaussianFrameBuffer_vert.Generate();
+}
+
+void DrawBloomPass::Draw(GLuint texture)
+{
+    GLERROR("DrawBloomPass::Draw: Pre");
+
+    DrawBloomPassState state;
+
+    GLuint shaderHandle_horiz = m_GaussianProgram_horiz->GetHandle();
+    GLuint shaderHandle_vert = m_GaussianProgram_vert->GetHandle();
+
+
+    //Horizontal pass, first use the given texture then save it to the horizontal framebuffer.
+    m_GaussianFrameBuffer_horiz.Bind();
+    m_GaussianProgram_horiz->Bind();
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, texture);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+
+    //Iterate some times to make it more gaussian.
+    for (int i = 1; i < m_iterations; i++) {
+        //Vertical pass
+        m_GaussianFrameBuffer_vert.Bind();
+        m_GaussianProgram_vert->Bind();
+
+        glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
+
+        glBindVertexArray(m_ScreenQuad->VAO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+
+        //horizontal pass
+
+        m_GaussianFrameBuffer_horiz.Bind();
+        m_GaussianProgram_horiz->Bind();
+
+        glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_vert);
+
+        glBindVertexArray(m_ScreenQuad->VAO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+    }
+
+    //final vertical gaussian after the iterations are done
+
+    m_GaussianFrameBuffer_vert.Bind();
+    m_GaussianProgram_vert->Bind();
+
+    glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+
+    GLERROR("DrawBloomPass::Draw: END");
+}
+
+void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
+{
+    glGenTextures(1, texture);
+    glBindTexture(GL_TEXTURE_2D, *texture);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
+    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
+    GLERROR("Texture initialization failed");
+}
diff --git a/src/Engine/Rendering/DrawBloomPassState.cpp b/src/Engine/Rendering/DrawBloomPassState.cpp
new file mode 100644
index 00000000..d4ee4956
--- /dev/null
+++ b/src/Engine/Rendering/DrawBloomPassState.cpp
@@ -0,0 +1,17 @@
+#include "Rendering/DrawBloomPassState.h"
+
+
+DrawBloomPassState::DrawBloomPassState()
+{
+    //BindFramebuffer(0);
+    Disable(GL_BLEND);
+    Disable(GL_DEPTH_TEST);
+    Disable(GL_CULL_FACE);
+    ClearColor(glm::vec4(0.f / 255, 0.f / 255, 0.f / 255, 0.f));
+    Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+DrawBloomPassState::~DrawBloomPassState()
+{
+
+}
diff --git a/src/Engine/Rendering/DrawColorCorrectionPass.cpp b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
new file mode 100644
index 00000000..8f9cd1ed
--- /dev/null
+++ b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
@@ -0,0 +1,41 @@
+#include "Rendering/DrawColorCorrectionPass.h"
+
+DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
+{
+    m_Renderer = renderer;
+
+    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
+    m_Exposure = 3; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
+
+    InitializeShaderPrograms();
+}
+
+void DrawColorCorrectionPass::InitializeShaderPrograms()
+{
+    m_ColorCorrectionProgram = ResourceManager::Load<ShaderProgram>("#ColorCorrectionProgram");
+    m_ColorCorrectionProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawColorCorrection.vert.glsl")));
+    m_ColorCorrectionProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawColorCorrection.frag.glsl")));
+    m_ColorCorrectionProgram->Compile();
+    m_ColorCorrectionProgram->Link();
+}
+
+void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture)
+{
+    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    GLERROR("DrawScreenQuadPass::Draw: Pre");
+
+    DrawScreenQuadPassState state = DrawScreenQuadPassState();
+    m_ColorCorrectionProgram->Bind();
+
+    glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), m_Exposure);
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, sceneTexture);
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, bloomTexture);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+}
diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index 894f358f..546552b7 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -100,7 +100,10 @@ void Renderer::Draw(RenderFrame& frame)
         m_LightCullingPass->CullLights(*scene);
         m_DrawFinalPass->Draw(*scene);
         //m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_SceneTexture);
-        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_BloomTexture);
+        //m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_BloomTexture);
+        m_DrawBloomPass->Draw(m_DrawFinalPass->m_BloomTexture);
+        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->m_SceneTexture, m_DrawBloomPass->m_GaussianTexture_vert);
+        //m_DrawScreenQuadPass->Draw(m_DrawBloomPass->m_GaussianTexture_vert);
         //m_DrawScenePass->Draw(rq);
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
@@ -147,4 +150,6 @@ void Renderer::InitializeRenderPasses()
     m_LightCullingPass = new LightCullingPass(this);
     m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
     m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
+    m_DrawBloomPass = new DrawBloomPass(this);
+    m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
 }
\ No newline at end of file

From 70bbc5ed0a63b79ebb9e868aedf8f8e521321016 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Thu, 21 Jan 2016 13:52:43 +0100
Subject: [PATCH 04/13] Normals scaling with model scale bug fixed.

---
 resources/Shaders/ForwardPlus.frag.glsl          | 2 +-
 src/Engine/Rendering/DrawColorCorrectionPass.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/resources/Shaders/ForwardPlus.frag.glsl b/resources/Shaders/ForwardPlus.frag.glsl
index 3fae9eb6..a3f998b8 100644
--- a/resources/Shaders/ForwardPlus.frag.glsl
+++ b/resources/Shaders/ForwardPlus.frag.glsl
@@ -102,7 +102,7 @@ void main()
 {
 	vec4 texel = texture2D(texture0, Input.TextureCoordinate);
 	vec4 position = V * M * vec4(Input.Position, 1.0); 
-	vec4 normal = V  * vec4(Input.Normal, 0.0);
+	vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
 	vec4 viewVec = normalize(-position); 
 
 	vec2 tilePos;
diff --git a/src/Engine/Rendering/DrawColorCorrectionPass.cpp b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
index 8f9cd1ed..debbcab0 100644
--- a/src/Engine/Rendering/DrawColorCorrectionPass.cpp
+++ b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
@@ -5,7 +5,7 @@ DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
     m_Renderer = renderer;
 
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
-    m_Exposure = 3; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
+    m_Exposure = 2; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
 
     InitializeShaderPrograms();
 }

From afe43c5f444e0672644ac0abd47ba1244d05282b Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Thu, 21 Jan 2016 14:53:47 +0100
Subject: [PATCH 05/13] Shader will now handle Glowmaps. However the load code
 is not there yet.

---
 assets                                        |  2 +-
 include/Engine/Rendering/DrawFinalPass.h      |  2 ++
 resources/Shaders/ForwardPlus.frag.glsl       | 32 ++++++++++---------
 .../Rendering/DrawColorCorrectionPass.cpp     |  2 +-
 src/Engine/Rendering/DrawFinalPass.cpp        | 13 ++++++--
 5 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/assets b/assets
index 6ffb46e1..cf2ac2a5 160000
--- a/assets
+++ b/assets
@@ -1 +1 @@
-Subproject commit 6ffb46e155c8f013241cd1507098c94900ec2448
+Subproject commit cf2ac2a570b0f2f50907bbbd59d00c59edb53443
diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h
index 407ad58c..e4c714ef 100644
--- a/include/Engine/Rendering/DrawFinalPass.h
+++ b/include/Engine/Rendering/DrawFinalPass.h
@@ -29,6 +29,8 @@ private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
 
     Texture* m_WhiteTexture;
+    Texture* m_BlackTexture;
+    Texture* TEMP_glowTestTexture;
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
diff --git a/resources/Shaders/ForwardPlus.frag.glsl b/resources/Shaders/ForwardPlus.frag.glsl
index a3f998b8..421f130c 100644
--- a/resources/Shaders/ForwardPlus.frag.glsl
+++ b/resources/Shaders/ForwardPlus.frag.glsl
@@ -5,7 +5,8 @@ uniform mat4 V;
 uniform mat4 P;
 uniform vec4 Color;
 uniform vec2 ScreenDimensions;
-uniform sampler2D texture0;
+layout (binding = 0) uniform sampler2D DiffuseTexture;
+layout (binding = 1) uniform sampler2D GlowMap;
 
 #define TILE_SIZE 16
 
@@ -100,7 +101,8 @@ LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensi
 
 void main()
 {
-	vec4 texel = texture2D(texture0, Input.TextureCoordinate);
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate);
+	vec4 glowTexel = texture2D(GlowMap, Input.TextureCoordinate);
 	vec4 position = V * M * vec4(Input.Position, 1.0); 
 	vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
 	vec4 viewVec = normalize(-position); 
@@ -121,32 +123,32 @@ void main()
 		int l = int(LightIndex[i]);
 		LightSource light = LightSources.List[l];
 
-		LightResult result;
+		LightResult light_result;
 		//These if statements should be removed.
 		if(light.Type == 1) { // point
-			result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
 		} else if (light.Type == 2) { //Directional
-			result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
 		}
-		totalLighting.Diffuse += result.Diffuse;
-		totalLighting.Specular += result.Specular;
+		totalLighting.Diffuse += light_result.Diffuse;
+		totalLighting.Specular += light_result.Specular;
 	}
 
 	//sceneColor += Input.DiffuseColor;
-	vec4 fragment = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color;
+	vec4 color_result = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * diffuseTexel * Color;
 	//bloomColor = vec4(0.3, 0.8, 0.6, 1.0);
-	sceneColor = vec4(fragment.xyz, 1.0);
-	//These if statements should be removed.
-
-	if(fragment.x > 1 || fragment.y > 1 || fragment.z > 1) {
-		bloomColor = vec4(fragment.xyz, 1.0);
+	sceneColor = vec4(color_result.xyz, 1.0);
+	//These if statements should be removed if they are slow.
+	color_result += glowTexel;
+	if(color_result.x > 1 || color_result.y > 1 || color_result.z > 1) {
+		bloomColor = vec4(color_result.xyz, 1.0);
 	} else {
 		bloomColor = vec4(0.0, 0.0, 0.0, 1.0);
 	}
 	
-	//sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color;
+	//sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * diffuseTexel * Color;
 	//sceneColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
-	//sceneColor = texel * Input.DiffuseColor * Color;
+	//sceneColor = diffuseTexel * Input.DiffuseColor * Color;
 	//sceneColor += vec4(currentTile/3600.f, 0, 0, 1);
 
 	//Tiled Debug Code
diff --git a/src/Engine/Rendering/DrawColorCorrectionPass.cpp b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
index debbcab0..72bcce2a 100644
--- a/src/Engine/Rendering/DrawColorCorrectionPass.cpp
+++ b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
@@ -5,7 +5,7 @@ DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
     m_Renderer = renderer;
 
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
-    m_Exposure = 2; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
+    m_Exposure = 1; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
 
     InitializeShaderPrograms();
 }
diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp
index 5a9f706e..a31beee6 100644
--- a/src/Engine/Rendering/DrawFinalPass.cpp
+++ b/src/Engine/Rendering/DrawFinalPass.cpp
@@ -12,6 +12,8 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling
 void DrawFinalPass::InitializeTextures()
 {
     m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
+    m_BlackTexture = ResourceManager::Load<Texture>("Textures/Core/Black.png");
+    TEMP_glowTestTexture = ResourceManager::Load<Texture>("Textures/Core/UnitRaptor_glow.png");
 }
 
 void DrawFinalPass::InitializeFrameBuffers()
@@ -65,13 +67,20 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
             glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
 
+            glActiveTexture(GL_TEXTURE0);
             if(modelJob->DiffuseTexture != nullptr) {
-                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
             } else {
-                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
             }
+            glActiveTexture(GL_TEXTURE1);
+            glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+
+            /*if(modelJob->GlowMap != nullptr) {
+                glBindTexture(GL_TEXTURE_2D, modelJob->GlowMap->m_Texture);
+            } else {
+                glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+            }*/
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);

From 6f739e22f3fe74d45d8ef7d3f893edab80fa8282 Mon Sep 17 00:00:00 2001
From: verysecrethero <hnorthh@gmail.com>
Date: Fri, 22 Jan 2016 10:10:39 +0100
Subject: [PATCH 06/13] Crash fix for: if you delete a team component in
 editor.

---
 src/Game/Systems/CapturePointSystem.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/Game/Systems/CapturePointSystem.cpp b/src/Game/Systems/CapturePointSystem.cpp
index 67c2353c..fbd20e38 100644
--- a/src/Game/Systems/CapturePointSystem.cpp
+++ b/src/Game/Systems/CapturePointSystem.cpp
@@ -66,6 +66,9 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
     nextPossibleCapturePoint["Blue"] = -1;
     for (size_t i = 0; i < m_NumberOfCapturePoints; i++)
     {
+        if (!m_World->HasComponent(m_CapturePointNumberToEntityIDMap[i], "Team")) {
+            continue;
+        }
         ComponentWrapper& capturePointOwnedBy = m_World->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team");
         if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint == 0) {
             nextPossibleCapturePoint["Red"] = i + 1;
@@ -76,6 +79,9 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper
     }
     for (int i = m_NumberOfCapturePoints - 1; i >= 0; i--)
     {
+        if (!m_World->HasComponent(m_CapturePointNumberToEntityIDMap[i], "Team")) {
+            continue;
+        }
         ComponentWrapper& capturePointOwnedBy = m_World->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team");
         if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint != 0) {
             nextPossibleCapturePoint["Red"] = i - 1;

From caf55fb8d1c787bc4b6ac413550df4ba5f6bd8f3 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Fri, 22 Jan 2016 10:52:45 +0100
Subject: [PATCH 07/13] Small fix to the bloom light, now feels smoother.

---
 resources/Shaders/ForwardPlus.frag.glsl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/resources/Shaders/ForwardPlus.frag.glsl b/resources/Shaders/ForwardPlus.frag.glsl
index 421f130c..403c96fc 100644
--- a/resources/Shaders/ForwardPlus.frag.glsl
+++ b/resources/Shaders/ForwardPlus.frag.glsl
@@ -140,11 +140,13 @@ void main()
 	sceneColor = vec4(color_result.xyz, 1.0);
 	//These if statements should be removed if they are slow.
 	color_result += glowTexel;
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+	/*
 	if(color_result.x > 1 || color_result.y > 1 || color_result.z > 1) {
 		bloomColor = vec4(color_result.xyz, 1.0);
 	} else {
 		bloomColor = vec4(0.0, 0.0, 0.0, 1.0);
-	}
+	} */
 	
 	//sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * diffuseTexel * Color;
 	//sceneColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);

From 2b8debbfff98fac69eba9a850e3805c97dcbeab9 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Fri, 22 Jan 2016 15:55:32 +0100
Subject: [PATCH 08/13] Added MipMap texture generation

---
 include/Engine/Rendering/DrawFinalPass.h |  1 +
 src/Engine/Rendering/DrawFinalPass.cpp   | 18 +++++++++++++++++-
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h
index e4c714ef..540ce49a 100644
--- a/include/Engine/Rendering/DrawFinalPass.h
+++ b/include/Engine/Rendering/DrawFinalPass.h
@@ -27,6 +27,7 @@ public:
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
+    void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
 
     Texture* m_WhiteTexture;
     Texture* m_BlackTexture;
diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp
index a31beee6..ba1b4c59 100644
--- a/src/Engine/Rendering/DrawFinalPass.cpp
+++ b/src/Engine/Rendering/DrawFinalPass.cpp
@@ -23,7 +23,9 @@ void DrawFinalPass::InitializeFrameBuffers()
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
 
     GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_FLOAT, 4);
     
     m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
     m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
@@ -104,3 +106,17 @@ void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum fil
     glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
     GLERROR("Texture initialization failed");
 }
+
+void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const
+{
+    glGenTextures(1, texture);
+    glBindTexture(GL_TEXTURE_2D, *texture);
+    glTexStorage2D(GL_TEXTURE_2D, numMipMaps, GL_RGBA8, dimensions.x, dimensions.y);
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, dimensions.x, dimensions.y, format, type, texture);
+    glGenerateMipmap(GL_TEXTURE_2D);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    GLERROR("MipMap Texture initialization failed");
+}

From 445248af5558c56ffd2f7ca3df9d9c348c1523be Mon Sep 17 00:00:00 2001
From: viktorljung <vilb12@student.bth.se>
Date: Sat, 23 Jan 2016 11:38:31 +0100
Subject: [PATCH 09/13] Changed name and made a TextPassState

---
 assets                                        |  2 +-
 include/Engine/Rendering/Renderer.h           |  4 ++--
 .../Rendering/{TextRenderer.h => TextPass.h}  |  5 +++--
 include/Engine/Rendering/TextPassState.h      | 15 +++++++++++++++
 src/Engine/Rendering/Renderer.cpp             |  2 +-
 .../{TextRenderer.cpp => TextPass.cpp}        | 19 ++++++++-----------
 src/Engine/Rendering/TextPassState.cpp        | 16 ++++++++++++++++
 7 files changed, 46 insertions(+), 17 deletions(-)
 rename include/Engine/Rendering/{TextRenderer.h => TextPass.h} (91%)
 create mode 100644 include/Engine/Rendering/TextPassState.h
 rename src/Engine/Rendering/{TextRenderer.cpp => TextPass.cpp} (85%)
 create mode 100644 src/Engine/Rendering/TextPassState.cpp

diff --git a/assets b/assets
index b6592dbb..e8174f63 160000
--- a/assets
+++ b/assets
@@ -1 +1 @@
-Subproject commit b6592dbb0216bbac00ccea43a0afd0e27d0b185e
+Subproject commit e8174f630fc3242e15ada1346b42c72f44cbc854
diff --git a/include/Engine/Rendering/Renderer.h b/include/Engine/Rendering/Renderer.h
index 0e8c70ec..875fa616 100644
--- a/include/Engine/Rendering/Renderer.h
+++ b/include/Engine/Rendering/Renderer.h
@@ -19,7 +19,7 @@
 #include "Camera.h"
 #include "../Core/Transform.h"
 
-#include "TextRenderer.h"
+#include "TextPass.h"
 
 class Renderer : public IRenderer
 {
@@ -37,7 +37,7 @@ public:
 private:
     //----------------------Variables----------------------//
     EventBroker* m_EventBroker;
-    TextRenderer* m_TextRenderer;
+    TextPass* m_TextRenderer;
 
     Texture* m_ErrorTexture;
     Texture* m_WhiteTexture;
diff --git a/include/Engine/Rendering/TextRenderer.h b/include/Engine/Rendering/TextPass.h
similarity index 91%
rename from include/Engine/Rendering/TextRenderer.h
rename to include/Engine/Rendering/TextPass.h
index cdc1d8c7..eaace1c2 100644
--- a/include/Engine/Rendering/TextRenderer.h
+++ b/include/Engine/Rendering/TextPass.h
@@ -10,11 +10,12 @@
 #include "Font.h"
 #include "../Core/ResourceManager.h"
 #include "RenderQueue.h"
+#include "TextPassState.h"
 
-class TextRenderer
+class TextPass
 {
 public:
-    TextRenderer();
+    TextPass();
     void Initialize();
     void Update();
     void Draw(RenderScene& scene);
diff --git a/include/Engine/Rendering/TextPassState.h b/include/Engine/Rendering/TextPassState.h
new file mode 100644
index 00000000..9bc25f26
--- /dev/null
+++ b/include/Engine/Rendering/TextPassState.h
@@ -0,0 +1,15 @@
+#ifndef TextPassState_h__
+#define TextPassState_h__
+
+#include "Rendering/RenderState.h"
+
+class TextPassState : public RenderState
+{
+public:
+    TextPassState();
+    ~TextPassState();
+private:
+
+};
+
+#endif
\ No newline at end of file
diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index 4a2b30f6..02a986ad 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -9,7 +9,7 @@ void Renderer::Initialize()
 	glfwSwapInterval(m_VSYNC);
 	InitializeShaders();
     InitializeTextures();
-    m_TextRenderer = new TextRenderer();
+    m_TextRenderer = new TextPass();
     m_TextRenderer->Initialize();
 
 
diff --git a/src/Engine/Rendering/TextRenderer.cpp b/src/Engine/Rendering/TextPass.cpp
similarity index 85%
rename from src/Engine/Rendering/TextRenderer.cpp
rename to src/Engine/Rendering/TextPass.cpp
index a8dfc083..6b05d7fb 100644
--- a/src/Engine/Rendering/TextRenderer.cpp
+++ b/src/Engine/Rendering/TextPass.cpp
@@ -1,11 +1,11 @@
-#include "Rendering/TextRenderer.h"
+#include "Rendering/TextPass.h"
 
-TextRenderer::TextRenderer()
+TextPass::TextPass()
 {
 
 }
 
-void TextRenderer::Initialize()
+void TextPass::Initialize()
 {
     glGenVertexArrays(1, &VAO);
     glGenBuffers(1, &VBO);
@@ -24,12 +24,12 @@ void TextRenderer::Initialize()
     m_TextProgram->Link();
 }
 
-void TextRenderer::Update()
+void TextPass::Update()
 {
 
 }
 
-void TextRenderer::Draw(RenderScene& scene)
+void TextPass::Draw(RenderScene& scene)
 {
     for (auto &job : scene.TextJobs) {
         auto textJob = std::dynamic_pointer_cast<TextJob>(job);
@@ -40,11 +40,11 @@ void TextRenderer::Draw(RenderScene& scene)
     }
 }
 
-void TextRenderer::renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix)
+void TextPass::renderText(std::string text, Font* font, TextJob::AlignmentEnum alignment, glm::vec4 color, glm::mat4 modelMatrix, glm::mat4 projectionMatrix, glm::mat4 viewMatrix)
 {
     GLfloat penX = 0;
     GLfloat penY = 0;
-    float scale = 1.0/font->FontSize;
+    GLfloat scale = 1.0/font->FontSize;
 
     GLfloat stringWidth = 0.f;
 
@@ -61,10 +61,7 @@ void TextRenderer::renderText(std::string text, Font* font, TextJob::AlignmentEn
         penX = 0;
     }	
     
-    glEnable(GL_BLEND);
-    glDisable(GL_CULL_FACE);
-    glEnable(GL_DEPTH_TEST);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    TextPassState state;
 
     m_TextProgram->Bind();
     glUniform3f(glGetUniformLocation(m_TextProgram->GetHandle(), "textColor"), color.x, color.y, color.z);
diff --git a/src/Engine/Rendering/TextPassState.cpp b/src/Engine/Rendering/TextPassState.cpp
new file mode 100644
index 00000000..e81f7b7c
--- /dev/null
+++ b/src/Engine/Rendering/TextPassState.cpp
@@ -0,0 +1,16 @@
+#include "Rendering/TextPassState.h"
+
+
+TextPassState::TextPassState()
+{
+    BindFramebuffer(0);
+    glEnable(GL_BLEND);
+    glDisable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+TextPassState::~TextPassState()
+{
+
+}

From e4513376bbf5050747091bfb0dcfcb0075a8bdc5 Mon Sep 17 00:00:00 2001
From: viktorljung <vilb12@student.bth.se>
Date: Sat, 23 Jan 2016 11:39:10 +0100
Subject: [PATCH 10/13] fixup! Changed name and made a TextPassState

---
 src/Engine/Rendering/Renderer.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index 02a986ad..ce853acc 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -9,8 +9,8 @@ void Renderer::Initialize()
 	glfwSwapInterval(m_VSYNC);
 	InitializeShaders();
     InitializeTextures();
-    m_TextRenderer = new TextPass();
-    m_TextRenderer->Initialize();
+    m_TextPass = new TextPass();
+    m_TextPass->Initialize();
 
 
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
@@ -89,7 +89,7 @@ void Renderer::Update(double dt)
 {
     m_EventBroker->Process<Renderer>();
     InputUpdate(dt);
-    m_TextRenderer->Update();
+    m_TextPass->Update();
     m_ImGuiRenderPass->Update(dt);
 }
 
@@ -113,7 +113,7 @@ void Renderer::Draw(RenderFrame& frame)
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
 
-        m_TextRenderer->Draw(*scene);
+        m_TextPass->Draw(*scene);
 
     }
     

From b499f4b0209c6554ecd26637ef471747c8a55802 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Sat, 23 Jan 2016 12:17:38 +0100
Subject: [PATCH 11/13] Fixed some rendering bugs and some code refactoring

---
 include/Engine/Rendering/DrawBloomPass.h      |  9 ++-
 include/Engine/Rendering/DrawFinalPass.h      | 15 +++--
 include/Engine/Rendering/DrawFinalPassState.h |  2 +-
 include/Engine/Rendering/Renderer.h           |  3 +
 .../Engine/Rendering/Util/CommonFunctions.h   | 17 +++++
 src/Engine/Rendering/DrawBloomPass.cpp        | 13 ++++
 src/Engine/Rendering/DrawBloomPassState.cpp   |  2 -
 .../Rendering/DrawColorCorrectionPass.cpp     |  2 +-
 src/Engine/Rendering/DrawFinalPass.cpp        | 23 ++++---
 src/Engine/Rendering/DrawFinalPassState.cpp   |  6 +-
 src/Engine/Rendering/DrawScreenQuadPass.cpp   |  1 +
 .../Rendering/DrawScreenQuadPassState.cpp     |  4 +-
 src/Engine/Rendering/PickingPass.cpp          | 62 +++++++++----------
 src/Engine/Rendering/Renderer.cpp             | 33 +++++++---
 src/Engine/Rendering/Util/CommonFunctions.cpp |  2 +
 15 files changed, 131 insertions(+), 63 deletions(-)
 create mode 100644 include/Engine/Rendering/Util/CommonFunctions.h
 create mode 100644 src/Engine/Rendering/Util/CommonFunctions.cpp

diff --git a/include/Engine/Rendering/DrawBloomPass.h b/include/Engine/Rendering/DrawBloomPass.h
index d192c73a..539d6957 100644
--- a/include/Engine/Rendering/DrawBloomPass.h
+++ b/include/Engine/Rendering/DrawBloomPass.h
@@ -18,14 +18,16 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
     void InitializeBuffers();
+    void ClearBuffer();
 
     void FillGaussianBuffer(FrameBuffer* fb);
 
     void Draw(GLuint texture);
 
     //Getters
-    GLuint m_GaussianTexture_horiz;
-    GLuint m_GaussianTexture_vert;
+    //Return the blurred result of the texture that was sent into draw
+    GLuint GaussianTexture() const { return m_GaussianTexture_vert; }
+
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
@@ -37,6 +39,9 @@ private:
     //const LightCullingPass* m_LightCullingPass 
     GLuint m_iterations = 9;
 
+    GLuint m_GaussianTexture_horiz;
+    GLuint m_GaussianTexture_vert;
+
     FrameBuffer m_GaussianFrameBuffer_horiz;
     FrameBuffer m_GaussianFrameBuffer_vert;
 
diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h
index 540ce49a..70c82de9 100644
--- a/include/Engine/Rendering/DrawFinalPass.h
+++ b/include/Engine/Rendering/DrawFinalPass.h
@@ -18,12 +18,12 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
     void Draw(RenderScene& scene);
+    void ClearBuffer();
 
-    //Todo: Should not be public
-    FrameBuffer m_BloomFrameBuffer;
-    GLuint m_BloomTexture;
-    GLuint m_SceneTexture;
-    GLuint m_DepthBuffer;
+    //Return the texture that is used in later stages to apply the bloom effect
+    GLuint BloomTexture() const { return m_BloomTexture; }
+    //Return the texture with diffuse and lighting of the scene.
+    GLuint SceneTexture() const { return m_SceneTexture; }
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
@@ -33,6 +33,11 @@ private:
     Texture* m_BlackTexture;
     Texture* TEMP_glowTestTexture;
 
+    FrameBuffer m_FinalPassFrameBuffer;
+    GLuint m_BloomTexture;
+    GLuint m_SceneTexture;
+    GLuint m_DepthBuffer;
+
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
 
diff --git a/include/Engine/Rendering/DrawFinalPassState.h b/include/Engine/Rendering/DrawFinalPassState.h
index 72d8e392..10b840e9 100644
--- a/include/Engine/Rendering/DrawFinalPassState.h
+++ b/include/Engine/Rendering/DrawFinalPassState.h
@@ -6,7 +6,7 @@
 class DrawFinalPassState : public RenderState
 {
 public:
-    DrawFinalPassState();
+    DrawFinalPassState(GLuint frameBuffer);
     ~DrawFinalPassState();
 private:
 
diff --git a/include/Engine/Rendering/Renderer.h b/include/Engine/Rendering/Renderer.h
index 7d952a94..f745a9c3 100644
--- a/include/Engine/Rendering/Renderer.h
+++ b/include/Engine/Rendering/Renderer.h
@@ -20,6 +20,7 @@
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
 #include "../Core/Transform.h"
+#include "imgui/imgui.h"
 
 class Renderer : public IRenderer
 {
@@ -45,6 +46,8 @@ private:
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
+    int m_DebugTextureToDraw = 0;
+
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;
diff --git a/include/Engine/Rendering/Util/CommonFunctions.h b/include/Engine/Rendering/Util/CommonFunctions.h
new file mode 100644
index 00000000..b262568c
--- /dev/null
+++ b/include/Engine/Rendering/Util/CommonFunctions.h
@@ -0,0 +1,17 @@
+#ifndef CommonFuntions_h__
+#define CommonFuntions_h__
+
+#include "../../Common.h"
+#include "../../OpenGL.h"
+#include "../../GLM.h"
+
+class CommonFuntions
+{
+public:
+    CommonFuntions() = delete;
+
+private:
+
+};
+
+#endif
\ No newline at end of file
diff --git a/src/Engine/Rendering/DrawBloomPass.cpp b/src/Engine/Rendering/DrawBloomPass.cpp
index 20e5f0c0..1ad97eb5 100644
--- a/src/Engine/Rendering/DrawBloomPass.cpp
+++ b/src/Engine/Rendering/DrawBloomPass.cpp
@@ -45,6 +45,19 @@ void DrawBloomPass::InitializeBuffers()
     m_GaussianFrameBuffer_vert.Generate();
 }
 
+
+void DrawBloomPass::ClearBuffer()
+{
+    m_GaussianFrameBuffer_horiz.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    m_GaussianFrameBuffer_horiz.Unbind();
+    m_GaussianFrameBuffer_vert.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    m_GaussianFrameBuffer_vert.Unbind();
+}
+
 void DrawBloomPass::Draw(GLuint texture)
 {
     GLERROR("DrawBloomPass::Draw: Pre");
diff --git a/src/Engine/Rendering/DrawBloomPassState.cpp b/src/Engine/Rendering/DrawBloomPassState.cpp
index d4ee4956..f9c57475 100644
--- a/src/Engine/Rendering/DrawBloomPassState.cpp
+++ b/src/Engine/Rendering/DrawBloomPassState.cpp
@@ -7,8 +7,6 @@ DrawBloomPassState::DrawBloomPassState()
     Disable(GL_BLEND);
     Disable(GL_DEPTH_TEST);
     Disable(GL_CULL_FACE);
-    ClearColor(glm::vec4(0.f / 255, 0.f / 255, 0.f / 255, 0.f));
-    Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 }
 
 DrawBloomPassState::~DrawBloomPassState()
diff --git a/src/Engine/Rendering/DrawColorCorrectionPass.cpp b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
index 72bcce2a..c9789602 100644
--- a/src/Engine/Rendering/DrawColorCorrectionPass.cpp
+++ b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
@@ -26,7 +26,7 @@ void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture)
 
     DrawScreenQuadPassState state = DrawScreenQuadPassState();
     m_ColorCorrectionProgram->Bind();
-
+    glClear(GL_COLOR_BUFFER_BIT);
     glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), m_Exposure);
 
     glActiveTexture(GL_TEXTURE0);
diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp
index 3698cf2a..30bbb36e 100644
--- a/src/Engine/Rendering/DrawFinalPass.cpp
+++ b/src/Engine/Rendering/DrawFinalPass.cpp
@@ -27,10 +27,10 @@ void DrawFinalPass::InitializeFrameBuffers()
     //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_FLOAT, 4);
     
-    m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
-    m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
-    m_BloomFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
-    m_BloomFrameBuffer.Generate();
+    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
+    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
+    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
+    m_FinalPassFrameBuffer.Generate();
 
 }
 
@@ -47,9 +47,7 @@ void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("DrawFinalPass::Draw: Pre");
 
-    m_BloomFrameBuffer.Bind(); //in i state
-
-    DrawFinalPassState state;
+    DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
 
     m_ForwardPlusProgram->Bind();
     GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
@@ -96,10 +94,19 @@ void DrawFinalPass::Draw(RenderScene& scene)
             continue;
         }
     }
-    m_BloomFrameBuffer.Unbind();
+    m_FinalPassFrameBuffer.Unbind();
     GLERROR("DrawFinalPass::Draw: END");
 }
 
+
+void DrawFinalPass::ClearBuffer()
+{
+    m_FinalPassFrameBuffer.Bind();
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    m_FinalPassFrameBuffer.Unbind();
+}
+
 void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
 {
     glGenTextures(1, texture);
diff --git a/src/Engine/Rendering/DrawFinalPassState.cpp b/src/Engine/Rendering/DrawFinalPassState.cpp
index 077ae7dc..3ebe320d 100644
--- a/src/Engine/Rendering/DrawFinalPassState.cpp
+++ b/src/Engine/Rendering/DrawFinalPassState.cpp
@@ -1,14 +1,14 @@
 #include "Rendering/DrawFinalPassState.h"
 
 
-DrawFinalPassState::DrawFinalPassState()
+DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
 {
-    //BindFramebuffer(0);
+    BindFramebuffer(frameBuffer);
     Enable(GL_BLEND);
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
-    ClearColor(glm::vec4(155.f / 255, 0.f / 255, 155.f / 255, 0.f));
+    ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));
 }
 
 DrawFinalPassState::~DrawFinalPassState()
diff --git a/src/Engine/Rendering/DrawScreenQuadPass.cpp b/src/Engine/Rendering/DrawScreenQuadPass.cpp
index 4095db04..4b155fc9 100644
--- a/src/Engine/Rendering/DrawScreenQuadPass.cpp
+++ b/src/Engine/Rendering/DrawScreenQuadPass.cpp
@@ -25,6 +25,7 @@ void DrawScreenQuadPass::Draw(GLuint texture)
 
     DrawScreenQuadPassState state = DrawScreenQuadPassState();
     m_DrawQuadProgram->Bind();
+    glClear(GL_COLOR_BUFFER_BIT);
 
     glActiveTexture(GL_TEXTURE0);
     glBindTexture(GL_TEXTURE_2D, texture);
diff --git a/src/Engine/Rendering/DrawScreenQuadPassState.cpp b/src/Engine/Rendering/DrawScreenQuadPassState.cpp
index 1ee5d9a7..33a4895d 100644
--- a/src/Engine/Rendering/DrawScreenQuadPassState.cpp
+++ b/src/Engine/Rendering/DrawScreenQuadPassState.cpp
@@ -9,9 +9,7 @@ DrawScreenQuadPassState::DrawScreenQuadPassState()
     Disable(GL_DEPTH_TEST);
     Disable(GL_CULL_FACE);
     Disable(GL_BLEND);
-    glClearColor(0.f, 0.f, 0.f, 1.f);
-   // ClearColor(glm::vec4(255.f / 255, 163.f / 255, 176.f / 255, 0.f));
-    Clear(GL_COLOR_BUFFER_BIT);
+    ClearColor(glm::vec4(0.f));
 }
 
 DrawScreenQuadPassState::~DrawScreenQuadPassState()
diff --git a/src/Engine/Rendering/PickingPass.cpp b/src/Engine/Rendering/PickingPass.cpp
index 0c485bdc..328a5ce8 100644
--- a/src/Engine/Rendering/PickingPass.cpp
+++ b/src/Engine/Rendering/PickingPass.cpp
@@ -55,45 +55,45 @@ void PickingPass::Draw(RenderScene& scene)
     if (scene.ClearDepth) {
         glClear(GL_DEPTH_BUFFER_BIT);
     }
-        m_Camera = scene.Camera;
+    m_Camera = scene.Camera;
 
-        for (auto &job : scene.ForwardJobs) {
-            auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+    for (auto &job : scene.ForwardJobs) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
-            if (modelJob) {
-                int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+        if (modelJob) {
+            int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
 
-                PickingInfo pickInfo;
-                pickInfo.Entity = modelJob->Entity;
-                pickInfo.World = modelJob->World;
-                pickInfo.Camera = scene.Camera;
+            PickingInfo pickInfo;
+            pickInfo.Entity = modelJob->Entity;
+            pickInfo.World = modelJob->World;
+            pickInfo.Camera = scene.Camera;
 
-                auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
-                if (color != m_EntityColors.end()) {
-                    pickColor[0] = color->second[0];
-                    pickColor[1] = color->second[1];
+            auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
+            if (color != m_EntityColors.end()) {
+                pickColor[0] = color->second[0];
+                pickColor[1] = color->second[1];
+            } else {
+                m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
+                if (m_ColorCounter[0] > 255) {
+                    m_ColorCounter[0] = 0;
+                    m_ColorCounter[1]++;;
                 } else {
-                    m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
-                    if (m_ColorCounter[0] > 255) {
-                        m_ColorCounter[0] = 0;
-                        m_ColorCounter[1]++;;
-                    } else {
-                        m_ColorCounter[0]++;;
-                    }
+                    m_ColorCounter[0]++;;
                 }
-
-                m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
-
-                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-                glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
-
-                glBindVertexArray(modelJob->Model->VAO);
-                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-                glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
             }
+
+            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
+
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+            glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
         }
+    }
     
     m_PickingBuffer.Unbind();
     GLERROR("PickingPass Error");
diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index 3a9b1a3e..605a3578 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -76,10 +76,16 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
-    glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 0.f);
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking");
+    //clear buffer 0
+    glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
+    //Clear other buffers
     m_PickingPass->ClearPicking();
+    m_DrawFinalPass->ClearBuffer();
+    m_DrawBloomPass->ClearBuffer();
+
     for (auto scene : frame.RenderScenes){
         
         SortRenderJobsByDepth(*scene);
@@ -88,15 +94,28 @@ void Renderer::Draw(RenderFrame& frame)
         m_LightCullingPass->FillLightList(*scene);
         m_LightCullingPass->CullLights(*scene);
         m_DrawFinalPass->Draw(*scene);
-        //m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_SceneTexture);
-        //m_DrawScreenQuadPass->Draw(m_DrawFinalPass->m_BloomTexture);
-        m_DrawBloomPass->Draw(m_DrawFinalPass->m_BloomTexture);
-        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->m_SceneTexture, m_DrawBloomPass->m_GaussianTexture_vert);
-        //m_DrawScreenQuadPass->Draw(m_DrawBloomPass->m_GaussianTexture_vert);
-        //m_DrawScenePass->Draw(rq);
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
     }
+    m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
+    if(m_DebugTextureToDraw == 0) {
+        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture());
+    }
+    if (m_DebugTextureToDraw == 1) {
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture());
+    }
+    if (m_DebugTextureToDraw == 2) {
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTexture());
+    }
+    if (m_DebugTextureToDraw == 3) {
+        m_DrawScreenQuadPass->Draw(m_DrawBloomPass->GaussianTexture());
+    }
+    if (m_DebugTextureToDraw == 4) {
+        m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
+    }
+
+    //m_DrawBloomPass->Draw(m_DrawFinalPass->m_BloomTexture);
+    //m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->m_SceneTexture, m_DrawBloomPass->m_GaussianTexture_vert);
 
     m_ImGuiRenderPass->Draw();
 	glfwSwapBuffers(m_Window);
diff --git a/src/Engine/Rendering/Util/CommonFunctions.cpp b/src/Engine/Rendering/Util/CommonFunctions.cpp
new file mode 100644
index 00000000..3c81de66
--- /dev/null
+++ b/src/Engine/Rendering/Util/CommonFunctions.cpp
@@ -0,0 +1,2 @@
+#include "Rendering/Util/CommonFunctions.h"
+

From f623232a2beeb357c410911812a038f0191075f1 Mon Sep 17 00:00:00 2001
From: Tleety <dahltobbe@hotmail.com>
Date: Sat, 23 Jan 2016 14:52:29 +0100
Subject: [PATCH 12/13] Removed a temp variable.

---
 include/Engine/Rendering/DrawFinalPass.h | 1 -
 src/Engine/Rendering/DrawFinalPass.cpp   | 1 -
 src/Engine/Rendering/Renderer.cpp        | 3 ---
 3 files changed, 5 deletions(-)

diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h
index 70c82de9..caf68f24 100644
--- a/include/Engine/Rendering/DrawFinalPass.h
+++ b/include/Engine/Rendering/DrawFinalPass.h
@@ -31,7 +31,6 @@ private:
 
     Texture* m_WhiteTexture;
     Texture* m_BlackTexture;
-    Texture* TEMP_glowTestTexture;
 
     FrameBuffer m_FinalPassFrameBuffer;
     GLuint m_BloomTexture;
diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp
index 30bbb36e..36a14610 100644
--- a/src/Engine/Rendering/DrawFinalPass.cpp
+++ b/src/Engine/Rendering/DrawFinalPass.cpp
@@ -13,7 +13,6 @@ void DrawFinalPass::InitializeTextures()
 {
     m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
     m_BlackTexture = ResourceManager::Load<Texture>("Textures/Core/Black.png");
-    TEMP_glowTestTexture = ResourceManager::Load<Texture>("Textures/Core/UnitRaptor_glow.png");
 }
 
 void DrawFinalPass::InitializeFrameBuffers()
diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index 743cf8f5..57849d99 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -121,9 +121,6 @@ void Renderer::Draw(RenderFrame& frame)
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
     }
 
-    //m_DrawBloomPass->Draw(m_DrawFinalPass->m_BloomTexture);
-    //m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->m_SceneTexture, m_DrawBloomPass->m_GaussianTexture_vert);
-
     m_ImGuiRenderPass->Draw();
 	glfwSwapBuffers(m_Window);
 }

From bd62b5873d0ce4373865f2466f535f9df3513842 Mon Sep 17 00:00:00 2001
From: viktorljung <vilb12@student.bth.se>
Date: Sat, 23 Jan 2016 15:57:26 +0100
Subject: [PATCH 13/13] Revert "Merge pull request #43 from teamfisk/Forward+"

This reverts commit d59ab5aba270d66e8bcccb957713133dab4b5188, reversing
changes made to bef95235d0e94ea274afd27e650eb43ed83e34cc.
---
 include/Engine/Rendering/DrawBloomPass.h      |  53 -------
 include/Engine/Rendering/DrawBloomPassState.h |  15 --
 .../Rendering/DrawColorCorrectionPass.h       |  29 ----
 include/Engine/Rendering/DrawFinalPass.h      |  17 +--
 include/Engine/Rendering/DrawFinalPassState.h |   2 +-
 include/Engine/Rendering/DrawScreenQuadPass.h |  28 ----
 .../Rendering/DrawScreenQuadPassState.h       |  15 --
 include/Engine/Rendering/Renderer.h           |  14 +-
 .../Engine/Rendering/Util/CommonFunctions.h   |  17 ---
 .../Shaders/DrawColorCorrection.frag.glsl     |  32 -----
 .../Shaders/DrawColorCorrection.vert.glsl     |  13 --
 resources/Shaders/ForwardPlus.frag.glsl       |  51 +++----
 resources/Shaders/Gaussian_horiz.frag.glsl    |  23 ---
 resources/Shaders/Gaussian_horiz.vert.glsl    |  13 --
 resources/Shaders/Gaussian_vert.frag.glsl     |  23 ---
 resources/Shaders/Gaussian_vert.vert.glsl     |  13 --
 src/Engine/Rendering/DrawBloomPass.cpp        | 134 ------------------
 src/Engine/Rendering/DrawBloomPassState.cpp   |  15 --
 .../Rendering/DrawColorCorrectionPass.cpp     |  41 ------
 src/Engine/Rendering/DrawFinalPass.cpp        |  68 +--------
 src/Engine/Rendering/DrawFinalPassState.cpp   |   6 +-
 src/Engine/Rendering/DrawScreenQuadPass.cpp   |  37 -----
 .../Rendering/DrawScreenQuadPassState.cpp     |  18 ---
 src/Engine/Rendering/FrameBuffer.cpp          |   7 +-
 src/Engine/Rendering/PickingPass.cpp          |  63 ++++----
 src/Engine/Rendering/Renderer.cpp             |  56 ++++----
 src/Engine/Rendering/Util/CommonFunctions.cpp |   2 -
 27 files changed, 99 insertions(+), 706 deletions(-)
 delete mode 100644 include/Engine/Rendering/DrawBloomPass.h
 delete mode 100644 include/Engine/Rendering/DrawBloomPassState.h
 delete mode 100644 include/Engine/Rendering/DrawColorCorrectionPass.h
 delete mode 100644 include/Engine/Rendering/DrawScreenQuadPass.h
 delete mode 100644 include/Engine/Rendering/DrawScreenQuadPassState.h
 delete mode 100644 include/Engine/Rendering/Util/CommonFunctions.h
 delete mode 100644 resources/Shaders/DrawColorCorrection.frag.glsl
 delete mode 100644 resources/Shaders/DrawColorCorrection.vert.glsl
 delete mode 100644 resources/Shaders/Gaussian_horiz.frag.glsl
 delete mode 100644 resources/Shaders/Gaussian_horiz.vert.glsl
 delete mode 100644 resources/Shaders/Gaussian_vert.frag.glsl
 delete mode 100644 resources/Shaders/Gaussian_vert.vert.glsl
 delete mode 100644 src/Engine/Rendering/DrawBloomPass.cpp
 delete mode 100644 src/Engine/Rendering/DrawBloomPassState.cpp
 delete mode 100644 src/Engine/Rendering/DrawColorCorrectionPass.cpp
 delete mode 100644 src/Engine/Rendering/DrawScreenQuadPass.cpp
 delete mode 100644 src/Engine/Rendering/DrawScreenQuadPassState.cpp
 delete mode 100644 src/Engine/Rendering/Util/CommonFunctions.cpp

diff --git a/include/Engine/Rendering/DrawBloomPass.h b/include/Engine/Rendering/DrawBloomPass.h
deleted file mode 100644
index 539d6957..00000000
--- a/include/Engine/Rendering/DrawBloomPass.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef DrawBloomPass_h__
-#define DrawBloomPass_h__
-
-#include "IRenderer.h"
-#include "DrawBloomPassState.h"
-//#include "LightCullingPass.h" Finalpass om den skall skickas in
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-//#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-
-class DrawBloomPass
-{
-public:
-    DrawBloomPass(IRenderer* renderer /* ,Texture or finalpass*/ );
-    ~DrawBloomPass() { }
-    void InitializeTextures();
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-    void InitializeBuffers();
-    void ClearBuffer();
-
-    void FillGaussianBuffer(FrameBuffer* fb);
-
-    void Draw(GLuint texture);
-
-    //Getters
-    //Return the blurred result of the texture that was sent into draw
-    GLuint GaussianTexture() const { return m_GaussianTexture_vert; }
-
-
-private:
-    void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-
-    Texture* m_WhiteTexture;
-    Model* m_ScreenQuad;
-
-    const IRenderer* m_Renderer;
-    //const LightCullingPass* m_LightCullingPass 
-    GLuint m_iterations = 9;
-
-    GLuint m_GaussianTexture_horiz;
-    GLuint m_GaussianTexture_vert;
-
-    FrameBuffer m_GaussianFrameBuffer_horiz;
-    FrameBuffer m_GaussianFrameBuffer_vert;
-
-    ShaderProgram* m_GaussianProgram_horiz;
-    ShaderProgram* m_GaussianProgram_vert;
-
-};
-
-#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawBloomPassState.h b/include/Engine/Rendering/DrawBloomPassState.h
deleted file mode 100644
index 7f2094cf..00000000
--- a/include/Engine/Rendering/DrawBloomPassState.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef DrawBloomPassState_h__
-#define DrawBloomPassState_h__
-
-#include "Rendering/RenderState.h"
-
-class DrawBloomPassState : public RenderState
-{
-public:
-    DrawBloomPassState();
-    ~DrawBloomPassState();
-private:
-
-};
-
-#endif
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawColorCorrectionPass.h b/include/Engine/Rendering/DrawColorCorrectionPass.h
deleted file mode 100644
index e9a7e281..00000000
--- a/include/Engine/Rendering/DrawColorCorrectionPass.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef DrawColorCorrectionPass_h__
-#define DrawColorCorrectionPass_h__
-
-#include "IRenderer.h"
-#include "DrawScreenQuadPassState.h"
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-//#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-
-class DrawColorCorrectionPass
-{
-public:
-    DrawColorCorrectionPass(IRenderer* renderer);
-    ~DrawColorCorrectionPass() { }
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-
-    void Draw(GLuint sceneTexture, GLuint bloomTexture);
-private:
-    const IRenderer* m_Renderer;
-
-    ShaderProgram* m_ColorCorrectionProgram;
-
-    Model* m_ScreenQuad;
-    GLfloat m_Exposure;
-};
-
-#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawFinalPass.h b/include/Engine/Rendering/DrawFinalPass.h
index caf68f24..20c7249d 100644
--- a/include/Engine/Rendering/DrawFinalPass.h
+++ b/include/Engine/Rendering/DrawFinalPass.h
@@ -17,25 +17,16 @@ public:
     void InitializeTextures();
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
-    void Draw(RenderScene& scene);
-    void ClearBuffer();
 
-    //Return the texture that is used in later stages to apply the bloom effect
-    GLuint BloomTexture() const { return m_BloomTexture; }
-    //Return the texture with diffuse and lighting of the scene.
-    GLuint SceneTexture() const { return m_SceneTexture; }
+    void Draw(RenderScene& scene);
+
+    //Getters
+
 
 private:
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const;
-    void GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const;
 
     Texture* m_WhiteTexture;
-    Texture* m_BlackTexture;
-
-    FrameBuffer m_FinalPassFrameBuffer;
-    GLuint m_BloomTexture;
-    GLuint m_SceneTexture;
-    GLuint m_DepthBuffer;
 
     const IRenderer* m_Renderer;
     const LightCullingPass* m_LightCullingPass;
diff --git a/include/Engine/Rendering/DrawFinalPassState.h b/include/Engine/Rendering/DrawFinalPassState.h
index 10b840e9..72d8e392 100644
--- a/include/Engine/Rendering/DrawFinalPassState.h
+++ b/include/Engine/Rendering/DrawFinalPassState.h
@@ -6,7 +6,7 @@
 class DrawFinalPassState : public RenderState
 {
 public:
-    DrawFinalPassState(GLuint frameBuffer);
+    DrawFinalPassState();
     ~DrawFinalPassState();
 private:
 
diff --git a/include/Engine/Rendering/DrawScreenQuadPass.h b/include/Engine/Rendering/DrawScreenQuadPass.h
deleted file mode 100644
index 117e9e1e..00000000
--- a/include/Engine/Rendering/DrawScreenQuadPass.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef DrawScreenQuadPass_h__
-#define DrawScreenQuadPass_h__
-
-#include "IRenderer.h"
-#include "DrawScreenQuadPassState.h"
-#include "FrameBuffer.h"
-#include "ShaderProgram.h"
-//#include "Util/UnorderedMapVec2.h"
-#include "Texture.h"
-
-class DrawScreenQuadPass
-{
-public:
-    DrawScreenQuadPass(IRenderer* renderer);
-    ~DrawScreenQuadPass() { }
-    void InitializeFrameBuffers();
-    void InitializeShaderPrograms();
-
-    void Draw(GLuint texture);
-private:
-    const IRenderer* m_Renderer;
-
-    ShaderProgram* m_DrawQuadProgram;
-
-    Model* m_ScreenQuad;
-};
-
-#endif 
\ No newline at end of file
diff --git a/include/Engine/Rendering/DrawScreenQuadPassState.h b/include/Engine/Rendering/DrawScreenQuadPassState.h
deleted file mode 100644
index 63ab4729..00000000
--- a/include/Engine/Rendering/DrawScreenQuadPassState.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef DrawScreenQuadPassState_h__
-#define DrawScreenQuadPassState_h__
-
-#include "Rendering/RenderState.h"
-
-class DrawScreenQuadPassState : public RenderState
-{
-public:
-    DrawScreenQuadPassState();
-    ~DrawScreenQuadPassState();
-private:
-
-};
-
-#endif
\ No newline at end of file
diff --git a/include/Engine/Rendering/Renderer.h b/include/Engine/Rendering/Renderer.h
index d84f41d5..7e124e3c 100644
--- a/include/Engine/Rendering/Renderer.h
+++ b/include/Engine/Rendering/Renderer.h
@@ -13,14 +13,10 @@
 #include "PickingPass.h"
 #include "LightCullingPass.h"
 #include "DrawFinalPass.h"
-#include "DrawScreenQuadPass.h"
-#include "DrawBloomPass.h"
-#include "DrawColorCorrectionPass.h"
 #include "../Core/EventBroker.h"
 #include "ImGuiRenderPass.h"
 #include "Camera.h"
 #include "../Core/Transform.h"
-#include "imgui/imgui.h"
 #include "TextPass.h"
 
 class Renderer : public IRenderer
@@ -48,15 +44,10 @@ private:
     Model* m_UnitQuad;
     Model* m_UnitSphere;
 
-    int m_DebugTextureToDraw = 0;
-
     PickingPass* m_PickingPass;
     LightCullingPass* m_LightCullingPass;
     ImGuiRenderPass* m_ImGuiRenderPass;
     DrawFinalPass* m_DrawFinalPass;
-    DrawScreenQuadPass* m_DrawScreenQuadPass;
-    DrawBloomPass* m_DrawBloomPass;
-    DrawColorCorrectionPass* m_DrawColorCorrectionPass;
 
     //----------------------Functions----------------------//
     void InitializeWindow();
@@ -66,13 +57,14 @@ private:
     //TODO: Renderer: Get InputUpdate out of renderer
     void InputUpdate(double dt);
     //void PickingPass(RenderQueueCollection& rq);
-    //void DrawScreenQuad(GLuint textureToDraw);
+    void DrawScreenQuad(GLuint textureToDraw);
 
     static bool DepthSort(const std::shared_ptr<RenderJob> &i, const std::shared_ptr<RenderJob> &j) { return (i->Depth < j->Depth); }
     void SortRenderJobsByDepth(RenderScene &scene);
     void GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type);
 	//--------------------ShaderPrograms-------------------//
-    ShaderProgram* m_BasicForwardProgram;
+	ShaderProgram* m_BasicForwardProgram;
+    ShaderProgram* m_DrawScreenQuadProgram;
 };
 
 #endif
\ No newline at end of file
diff --git a/include/Engine/Rendering/Util/CommonFunctions.h b/include/Engine/Rendering/Util/CommonFunctions.h
deleted file mode 100644
index b262568c..00000000
--- a/include/Engine/Rendering/Util/CommonFunctions.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef CommonFuntions_h__
-#define CommonFuntions_h__
-
-#include "../../Common.h"
-#include "../../OpenGL.h"
-#include "../../GLM.h"
-
-class CommonFuntions
-{
-public:
-    CommonFuntions() = delete;
-
-private:
-
-};
-
-#endif
\ No newline at end of file
diff --git a/resources/Shaders/DrawColorCorrection.frag.glsl b/resources/Shaders/DrawColorCorrection.frag.glsl
deleted file mode 100644
index 8d13992a..00000000
--- a/resources/Shaders/DrawColorCorrection.frag.glsl
+++ /dev/null
@@ -1,32 +0,0 @@
-#version 430
-
-layout (binding = 0) uniform sampler2D SceneTexture;
-layout (binding = 1) uniform sampler2D BloomTexture;
-uniform float Exposure;
-
-in VertexData{
-	vec2 TextureCoordinate;
-}Input;
-
-out vec4 fragmentColor;
-
-void main()
-{
-	const float gamma = 2.2;
-	vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate);
-	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
-	hdrColor += bloomColor;
-
-	//Toon mapping thingy
-	vec3 result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
-
-	//gamme correction
-	result = pow(result, vec3(1.0 / gamma));
-
-	fragmentColor = vec4(result, 1.0);
-	//fragmentColor = hdrColor;
-	//fragmentColor = bloomColor;
-	//fragmentColor = vec4(1,0.5,0.7,1);
-}
-
-
diff --git a/resources/Shaders/DrawColorCorrection.vert.glsl b/resources/Shaders/DrawColorCorrection.vert.glsl
deleted file mode 100644
index 346bc141..00000000
--- a/resources/Shaders/DrawColorCorrection.vert.glsl
+++ /dev/null
@@ -1,13 +0,0 @@
-#version 430
-
-layout (location = 0) in vec3 Position;
-
-out VertexData{
-	vec2 TextureCoordinate;
-}Output;
-
-void main()
-{
-	gl_Position = vec4(Position, 1.0);
-	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
-}
\ No newline at end of file
diff --git a/resources/Shaders/ForwardPlus.frag.glsl b/resources/Shaders/ForwardPlus.frag.glsl
index 403c96fc..78a2125e 100644
--- a/resources/Shaders/ForwardPlus.frag.glsl
+++ b/resources/Shaders/ForwardPlus.frag.glsl
@@ -5,8 +5,7 @@ uniform mat4 V;
 uniform mat4 P;
 uniform vec4 Color;
 uniform vec2 ScreenDimensions;
-layout (binding = 0) uniform sampler2D DiffuseTexture;
-layout (binding = 1) uniform sampler2D GlowMap;
+uniform sampler2D texture0;
 
 #define TILE_SIZE 16
 
@@ -49,8 +48,7 @@ in VertexData{
 	vec4 DiffuseColor;
 }Input;
 
-out vec4 sceneColor;
-out vec4 bloomColor;
+out vec4 fragmentColor;
 
 vec4 scene_ambient = vec4(0.3,0.3,0.3,1);
 
@@ -101,10 +99,9 @@ LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensi
 
 void main()
 {
-	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate);
-	vec4 glowTexel = texture2D(GlowMap, Input.TextureCoordinate);
+	vec4 texel = texture2D(texture0, Input.TextureCoordinate);
 	vec4 position = V * M * vec4(Input.Position, 1.0); 
-	vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
+	vec4 normal = V  * vec4(Input.Normal, 0.0);
 	vec4 viewVec = normalize(-position); 
 
 	vec2 tilePos;
@@ -123,42 +120,30 @@ void main()
 		int l = int(LightIndex[i]);
 		LightSource light = LightSources.List[l];
 
-		LightResult light_result;
-		//These if statements should be removed.
+		LightResult result;
 		if(light.Type == 1) { // point
-			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+			result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
 		} else if (light.Type == 2) { //Directional
-			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+			result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
 		}
-		totalLighting.Diffuse += light_result.Diffuse;
-		totalLighting.Specular += light_result.Specular;
+		totalLighting.Diffuse += result.Diffuse;
+		totalLighting.Specular += result.Specular;
 	}
 
-	//sceneColor += Input.DiffuseColor;
-	vec4 color_result = Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * diffuseTexel * Color;
-	//bloomColor = vec4(0.3, 0.8, 0.6, 1.0);
-	sceneColor = vec4(color_result.xyz, 1.0);
-	//These if statements should be removed if they are slow.
-	color_result += glowTexel;
-	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
-	/*
-	if(color_result.x > 1 || color_result.y > 1 || color_result.z > 1) {
-		bloomColor = vec4(color_result.xyz, 1.0);
-	} else {
-		bloomColor = vec4(0.0, 0.0, 0.0, 1.0);
-	} */
-	
-	//sceneColor += Input.DiffuseColor * (totalLighting.Diffuse) * diffuseTexel * Color;
-	//sceneColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
-	//sceneColor = diffuseTexel * Input.DiffuseColor * Color;
-	//sceneColor += vec4(currentTile/3600.f, 0, 0, 1);
+
+	//fragmentColor += Input.DiffuseColor;
+	fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse + totalLighting.Specular) * texel * Color;
+	//fragmentColor += Input.DiffuseColor * (totalLighting.Diffuse) * texel * Color;
+	//fragmentColor += Input.DiffuseColor + vec4(0.0, LightGrids.Data[currentTile].Amount/3, 0, 1);
+	//fragmentColor = texel * Input.DiffuseColor * Color;
+	//fragmentColor += vec4(currentTile/3600.f, 0, 0, 1);
 
 	//Tiled Debug Code
 	/*
 	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
-		sceneColor += vec4(0.5, 0, 0, 0);
+		fragmentColor += vec4(0.5, 0, 0, 0);
 	} else {
-		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+		fragmentColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
 	}
 	*/
 }
diff --git a/resources/Shaders/Gaussian_horiz.frag.glsl b/resources/Shaders/Gaussian_horiz.frag.glsl
deleted file mode 100644
index bd48d2d5..00000000
--- a/resources/Shaders/Gaussian_horiz.frag.glsl
+++ /dev/null
@@ -1,23 +0,0 @@
-#version 430
-
-layout (binding = 0) uniform sampler2D Texture;
-
-in VertexData{
-	vec2 TextureCoordinate;
-}Input;
-
-out vec4 fragmentColor;
-
-uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
-
-void main()
-{
-	vec2 tex_offset = 1.0 / textureSize(Texture, 0);
-	vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0];
-
-	for(int i = 1; i < 5; ++i) {
-	    result += texture(Texture, Input.TextureCoordinate + vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
-	    result += texture(Texture, Input.TextureCoordinate - vec2(tex_offset.x * i, 0.0)).rgb * weight[i];
-	}
-	fragmentColor = vec4(result, 1.0);
-}
\ No newline at end of file
diff --git a/resources/Shaders/Gaussian_horiz.vert.glsl b/resources/Shaders/Gaussian_horiz.vert.glsl
deleted file mode 100644
index 346bc141..00000000
--- a/resources/Shaders/Gaussian_horiz.vert.glsl
+++ /dev/null
@@ -1,13 +0,0 @@
-#version 430
-
-layout (location = 0) in vec3 Position;
-
-out VertexData{
-	vec2 TextureCoordinate;
-}Output;
-
-void main()
-{
-	gl_Position = vec4(Position, 1.0);
-	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
-}
\ No newline at end of file
diff --git a/resources/Shaders/Gaussian_vert.frag.glsl b/resources/Shaders/Gaussian_vert.frag.glsl
deleted file mode 100644
index 25b08f9f..00000000
--- a/resources/Shaders/Gaussian_vert.frag.glsl
+++ /dev/null
@@ -1,23 +0,0 @@
-#version 430
-
-layout (binding = 0) uniform sampler2D Texture;
-
-in VertexData{
-	vec2 TextureCoordinate;
-}Input;
-
-out vec4 fragmentColor;
-
-uniform float weight[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
-
-void main()
-{
-	vec2 tex_offset = 1.0 / textureSize(Texture, 0);
-	vec3 result = texture(Texture, Input.TextureCoordinate).rgb * weight[0];
-
-    for(int i = 1; i < 5; ++i) {
-        result += texture(Texture, Input.TextureCoordinate + vec2(0.0, tex_offset.y * i)).rgb * weight[i];
-        result += texture(Texture, Input.TextureCoordinate - vec2(0.0, tex_offset.y * i)).rgb * weight[i];
-    }
-    fragmentColor = vec4(result, 1.0);
-}
\ No newline at end of file
diff --git a/resources/Shaders/Gaussian_vert.vert.glsl b/resources/Shaders/Gaussian_vert.vert.glsl
deleted file mode 100644
index 346bc141..00000000
--- a/resources/Shaders/Gaussian_vert.vert.glsl
+++ /dev/null
@@ -1,13 +0,0 @@
-#version 430
-
-layout (location = 0) in vec3 Position;
-
-out VertexData{
-	vec2 TextureCoordinate;
-}Output;
-
-void main()
-{
-	gl_Position = vec4(Position, 1.0);
-	Output.TextureCoordinate = (vec2(Position) + 1) / 2;
-}
\ No newline at end of file
diff --git a/src/Engine/Rendering/DrawBloomPass.cpp b/src/Engine/Rendering/DrawBloomPass.cpp
deleted file mode 100644
index 1ad97eb5..00000000
--- a/src/Engine/Rendering/DrawBloomPass.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-#include "Rendering/DrawBloomPass.h"
-
-DrawBloomPass::DrawBloomPass(IRenderer* renderer)
-{
-    m_Renderer = renderer;
-
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
-
-    InitializeTextures();
-    InitializeBuffers();
-    InitializeShaderPrograms();
-}
-
-void DrawBloomPass::InitializeTextures()
-{
-    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
-}
-
-void DrawBloomPass::InitializeShaderPrograms()
-{
-    m_GaussianProgram_horiz = ResourceManager::Load<ShaderProgram>("##GaussianProgramHoriz");
-    m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_horiz.vert.glsl")));
-    m_GaussianProgram_horiz->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_horiz.frag.glsl")));
-    m_GaussianProgram_horiz->Compile();
-    m_GaussianProgram_horiz->Link();
-
-    m_GaussianProgram_vert = ResourceManager::Load<ShaderProgram>("##GaussianProgramVert");
-    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Gaussian_vert.vert.glsl")));
-    m_GaussianProgram_vert->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Gaussian_vert.frag.glsl")));
-    m_GaussianProgram_vert->Compile();
-    m_GaussianProgram_vert->Link();
-}
-
-
-void DrawBloomPass::InitializeBuffers()
-{
-    GenerateTexture(&m_GaussianTexture_horiz, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-
-    m_GaussianFrameBuffer_horiz.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_horiz, GL_COLOR_ATTACHMENT0)));
-    m_GaussianFrameBuffer_horiz.Generate();
-
-    GenerateTexture(&m_GaussianTexture_vert, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-
-    m_GaussianFrameBuffer_vert.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_GaussianTexture_vert, GL_COLOR_ATTACHMENT0)));
-    m_GaussianFrameBuffer_vert.Generate();
-}
-
-
-void DrawBloomPass::ClearBuffer()
-{
-    m_GaussianFrameBuffer_horiz.Bind();
-    glClearColor(0.f, 0.f, 0.f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    m_GaussianFrameBuffer_horiz.Unbind();
-    m_GaussianFrameBuffer_vert.Bind();
-    glClearColor(0.f, 0.f, 0.f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    m_GaussianFrameBuffer_vert.Unbind();
-}
-
-void DrawBloomPass::Draw(GLuint texture)
-{
-    GLERROR("DrawBloomPass::Draw: Pre");
-
-    DrawBloomPassState state;
-
-    GLuint shaderHandle_horiz = m_GaussianProgram_horiz->GetHandle();
-    GLuint shaderHandle_vert = m_GaussianProgram_vert->GetHandle();
-
-
-    //Horizontal pass, first use the given texture then save it to the horizontal framebuffer.
-    m_GaussianFrameBuffer_horiz.Bind();
-    m_GaussianProgram_horiz->Bind();
-
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, texture);
-
-    glBindVertexArray(m_ScreenQuad->VAO);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-
-    //Iterate some times to make it more gaussian.
-    for (int i = 1; i < m_iterations; i++) {
-        //Vertical pass
-        m_GaussianFrameBuffer_vert.Bind();
-        m_GaussianProgram_vert->Bind();
-
-        glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
-
-        glBindVertexArray(m_ScreenQuad->VAO);
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-
-        //horizontal pass
-
-        m_GaussianFrameBuffer_horiz.Bind();
-        m_GaussianProgram_horiz->Bind();
-
-        glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_vert);
-
-        glBindVertexArray(m_ScreenQuad->VAO);
-        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-        glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-            , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-    }
-
-    //final vertical gaussian after the iterations are done
-
-    m_GaussianFrameBuffer_vert.Bind();
-    m_GaussianProgram_vert->Bind();
-
-    glBindTexture(GL_TEXTURE_2D, m_GaussianTexture_horiz);
-
-    glBindVertexArray(m_ScreenQuad->VAO);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-
-    GLERROR("DrawBloomPass::Draw: END");
-}
-
-void DrawBloomPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
-{
-    glGenTextures(1, texture);
-    glBindTexture(GL_TEXTURE_2D, *texture);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
-    GLERROR("Texture initialization failed");
-}
diff --git a/src/Engine/Rendering/DrawBloomPassState.cpp b/src/Engine/Rendering/DrawBloomPassState.cpp
deleted file mode 100644
index f9c57475..00000000
--- a/src/Engine/Rendering/DrawBloomPassState.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "Rendering/DrawBloomPassState.h"
-
-
-DrawBloomPassState::DrawBloomPassState()
-{
-    //BindFramebuffer(0);
-    Disable(GL_BLEND);
-    Disable(GL_DEPTH_TEST);
-    Disable(GL_CULL_FACE);
-}
-
-DrawBloomPassState::~DrawBloomPassState()
-{
-
-}
diff --git a/src/Engine/Rendering/DrawColorCorrectionPass.cpp b/src/Engine/Rendering/DrawColorCorrectionPass.cpp
deleted file mode 100644
index c9789602..00000000
--- a/src/Engine/Rendering/DrawColorCorrectionPass.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include "Rendering/DrawColorCorrectionPass.h"
-
-DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
-{
-    m_Renderer = renderer;
-
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
-    m_Exposure = 1; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
-
-    InitializeShaderPrograms();
-}
-
-void DrawColorCorrectionPass::InitializeShaderPrograms()
-{
-    m_ColorCorrectionProgram = ResourceManager::Load<ShaderProgram>("#ColorCorrectionProgram");
-    m_ColorCorrectionProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawColorCorrection.vert.glsl")));
-    m_ColorCorrectionProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawColorCorrection.frag.glsl")));
-    m_ColorCorrectionProgram->Compile();
-    m_ColorCorrectionProgram->Link();
-}
-
-void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture)
-{
-    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    GLERROR("DrawScreenQuadPass::Draw: Pre");
-
-    DrawScreenQuadPassState state = DrawScreenQuadPassState();
-    m_ColorCorrectionProgram->Bind();
-    glClear(GL_COLOR_BUFFER_BIT);
-    glUniform1f(glGetUniformLocation(m_ColorCorrectionProgram->GetHandle(), "Exposure"), m_Exposure);
-
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, sceneTexture);
-    glActiveTexture(GL_TEXTURE1);
-    glBindTexture(GL_TEXTURE_2D, bloomTexture);
-
-    glBindVertexArray(m_ScreenQuad->VAO);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-}
diff --git a/src/Engine/Rendering/DrawFinalPass.cpp b/src/Engine/Rendering/DrawFinalPass.cpp
index 36a14610..eeaa7bb3 100644
--- a/src/Engine/Rendering/DrawFinalPass.cpp
+++ b/src/Engine/Rendering/DrawFinalPass.cpp
@@ -6,31 +6,11 @@ DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCulling
     m_LightCullingPass = lightCullingPass;
     InitializeTextures();
     InitializeShaderPrograms();
-    InitializeFrameBuffers();
 }
 
 void DrawFinalPass::InitializeTextures()
 {
     m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
-    m_BlackTexture = ResourceManager::Load<Texture>("Textures/Core/Black.png");
-}
-
-void DrawFinalPass::InitializeFrameBuffers()
-{
-    glGenRenderbuffers(1, &m_DepthBuffer);
-    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
-
-    GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
-    GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->Resolution().Width, m_Renderer->Resolution().Height), GL_RGB16F, GL_FLOAT, 4);
-    
-    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
-    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTexture, GL_COLOR_ATTACHMENT0)));
-    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTexture, GL_COLOR_ATTACHMENT1)));
-    m_FinalPassFrameBuffer.Generate();
-
 }
 
 void DrawFinalPass::InitializeShaderPrograms()
@@ -46,7 +26,7 @@ void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("DrawFinalPass::Draw: Pre");
 
-    DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
+    DrawFinalPassState state;
 
     m_ForwardPlusProgram->Bind();
     GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
@@ -71,20 +51,13 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
             glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
 
-            glActiveTexture(GL_TEXTURE0);
             if(modelJob->DiffuseTexture != nullptr) {
+                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
             } else {
+                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
             }
-            glActiveTexture(GL_TEXTURE1);
-            glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
-
-            /*if(modelJob->GlowMap != nullptr) {
-                glBindTexture(GL_TEXTURE_2D, modelJob->GlowMap->m_Texture);
-            } else {
-                glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
-            }*/
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -93,41 +66,6 @@ void DrawFinalPass::Draw(RenderScene& scene)
             continue;
         }
     }
-    m_FinalPassFrameBuffer.Unbind();
     GLERROR("DrawFinalPass::Draw: END");
-}
 
-
-void DrawFinalPass::ClearBuffer()
-{
-    m_FinalPassFrameBuffer.Bind();
-    glClearColor(0.f, 0.f, 0.f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    m_FinalPassFrameBuffer.Unbind();
-}
-
-void DrawFinalPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
-{
-    glGenTextures(1, texture);
-    glBindTexture(GL_TEXTURE_2D, *texture);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filtering);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filtering);
-    glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, dimensions.x, dimensions.y, 0, format, type, nullptr);//TODO: Renderer: Fix the precision and Resolution
-    GLERROR("Texture initialization failed");
-}
-
-void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm::vec2 dimensions, GLint format, GLenum type, GLint numMipMaps) const
-{
-    glGenTextures(1, texture);
-    glBindTexture(GL_TEXTURE_2D, *texture);
-    glTexStorage2D(GL_TEXTURE_2D, numMipMaps, GL_RGBA8, dimensions.x, dimensions.y);
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, dimensions.x, dimensions.y, format, type, texture);
-    glGenerateMipmap(GL_TEXTURE_2D);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-    GLERROR("MipMap Texture initialization failed");
 }
diff --git a/src/Engine/Rendering/DrawFinalPassState.cpp b/src/Engine/Rendering/DrawFinalPassState.cpp
index 3ebe320d..2cda4069 100644
--- a/src/Engine/Rendering/DrawFinalPassState.cpp
+++ b/src/Engine/Rendering/DrawFinalPassState.cpp
@@ -1,14 +1,14 @@
 #include "Rendering/DrawFinalPassState.h"
 
 
-DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
+DrawFinalPassState::DrawFinalPassState()
 {
-    BindFramebuffer(frameBuffer);
+    BindFramebuffer(0);
     Enable(GL_BLEND);
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
-    ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));
+    ClearColor(glm::vec4(200.f / 255, 0.f / 255, 200.f / 255, 0.f));
 }
 
 DrawFinalPassState::~DrawFinalPassState()
diff --git a/src/Engine/Rendering/DrawScreenQuadPass.cpp b/src/Engine/Rendering/DrawScreenQuadPass.cpp
deleted file mode 100644
index 4b155fc9..00000000
--- a/src/Engine/Rendering/DrawScreenQuadPass.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "Rendering/DrawScreenQuadPass.h"
-
-DrawScreenQuadPass::DrawScreenQuadPass(IRenderer* renderer)
-{
-    m_Renderer = renderer;
-
-    m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
-
-    InitializeShaderPrograms();
-}
-
-void DrawScreenQuadPass::InitializeShaderPrograms()
-{
-    m_DrawQuadProgram = ResourceManager::Load<ShaderProgram>("#DrawScreenQuadProgram");
-    m_DrawQuadProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
-    m_DrawQuadProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
-    m_DrawQuadProgram->Compile();
-    m_DrawQuadProgram->Link();
-}
-
-void DrawScreenQuadPass::Draw(GLuint texture)
-{
-    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    GLERROR("DrawScreenQuadPass::Draw: Pre");
-
-    DrawScreenQuadPassState state = DrawScreenQuadPassState();
-    m_DrawQuadProgram->Bind();
-    glClear(GL_COLOR_BUFFER_BIT);
-
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, texture);
-
-    glBindVertexArray(m_ScreenQuad->VAO);
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
-    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
-        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
-}
diff --git a/src/Engine/Rendering/DrawScreenQuadPassState.cpp b/src/Engine/Rendering/DrawScreenQuadPassState.cpp
deleted file mode 100644
index 33a4895d..00000000
--- a/src/Engine/Rendering/DrawScreenQuadPassState.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "Rendering/DrawScreenQuadPassState.h"
-
-
-DrawScreenQuadPassState::DrawScreenQuadPassState()
-{
-    GLERROR("---");
-    BindFramebuffer(0);
-    GLERROR("---");
-    Disable(GL_DEPTH_TEST);
-    Disable(GL_CULL_FACE);
-    Disable(GL_BLEND);
-    ClearColor(glm::vec4(0.f));
-}
-
-DrawScreenQuadPassState::~DrawScreenQuadPassState()
-{
-
-}
diff --git a/src/Engine/Rendering/FrameBuffer.cpp b/src/Engine/Rendering/FrameBuffer.cpp
index b7e908cc..b2b29626 100644
--- a/src/Engine/Rendering/FrameBuffer.cpp
+++ b/src/Engine/Rendering/FrameBuffer.cpp
@@ -55,9 +55,8 @@ void FrameBuffer::Generate()
             glFramebufferRenderbuffer(GL_FRAMEBUFFER, (*it)->m_Attachment, (*it)->m_ResourceType, *(*it)->m_ResourceHandle);
             GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
             if ( (*it)->m_Attachment != GL_COLOR_ATTACHMENT0 ||
-                (*it)->m_Attachment != GL_COLOR_ATTACHMENT1 ||
                 (*it)->m_Attachment != GL_DEPTH_ATTACHMENT ||
-                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT) //TODO: Viktor: Fixa detta
+                (*it)->m_Attachment != GL_STENCIL_ATTACHMENT)
             {
                 LOG_ERROR("RenderBuffer Attachment not valid.");
             }
@@ -70,8 +69,10 @@ void FrameBuffer::Generate()
         }
     }
         
+   
+    
     GLenum* bufferTextures = &attachments[0];
-    glDrawBuffers(attachments.size(), bufferTextures);
+    glDrawBuffers(1, bufferTextures);
 
     if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
         LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);
diff --git a/src/Engine/Rendering/PickingPass.cpp b/src/Engine/Rendering/PickingPass.cpp
index f063b344..6f448896 100644
--- a/src/Engine/Rendering/PickingPass.cpp
+++ b/src/Engine/Rendering/PickingPass.cpp
@@ -54,49 +54,52 @@ void PickingPass::Draw(RenderScene& scene)
     if (scene.ClearDepth) {
         glClear(GL_DEPTH_BUFFER_BIT);
     }
-    m_Camera = scene.Camera;
 
-    for (auto &job : scene.ForwardJobs) {
-        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+        m_Camera = scene.Camera;
 
-        if (modelJob) {
-            int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
+        for (auto &job : scene.ForwardJobs) {
+            auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
-            PickingInfo pickInfo;
-            pickInfo.Entity = modelJob->Entity;
-            pickInfo.World = modelJob->World;
-            pickInfo.Camera = scene.Camera;
+            if (modelJob) {
+                int pickColor[2] = { m_ColorCounter[0], m_ColorCounter[1] };
 
-            auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
-            if (color != m_EntityColors.end()) {
-                pickColor[0] = color->second[0];
-                pickColor[1] = color->second[1];
-            } else {
-                m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
-                if (m_ColorCounter[0] > 255) {
-                    m_ColorCounter[0] = 0;
-                        m_ColorCounter[1]++;
+                PickingInfo pickInfo;
+                pickInfo.Entity = modelJob->Entity;
+                pickInfo.World = modelJob->World;
+                pickInfo.Camera = scene.Camera;
+
+                auto color = m_EntityColors.find(std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera));
+                if (color != m_EntityColors.end()) {
+                    pickColor[0] = color->second[0];
+                    pickColor[1] = color->second[1];
                 } else {
+                    m_EntityColors[std::make_tuple(pickInfo.Entity, pickInfo.World, pickInfo.Camera)] = glm::ivec2(pickColor[0], pickColor[1]);
+                    if (m_ColorCounter[0] > 255) {
+                        m_ColorCounter[0] = 0;
+                        m_ColorCounter[1]++;
+                    } else {
                         m_ColorCounter[0]++;
+                    }
                 }
+
+                m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
+
+                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
+                glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
+                glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
+
+                glBindVertexArray(modelJob->Model->VAO);
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+                glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
             }
-
-            m_PickingColorsToEntity[glm::ivec2(pickColor[0], pickColor[1])] = pickInfo;
-
-            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
-            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "V"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ViewMatrix()));
-            glUniformMatrix4fv(glGetUniformLocation(ShaderHandle, "P"), 1, GL_FALSE, glm::value_ptr(scene.Camera->ProjectionMatrix()));
-            glUniform2fv(glGetUniformLocation(ShaderHandle, "PickingColor"), 1, glm::value_ptr(glm::vec2(pickColor[0], pickColor[1])));
-
-            glBindVertexArray(modelJob->Model->VAO);
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
-            glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
         }
-    }
+    
     
     m_PickingBuffer.Unbind();
     GLERROR("PickingPass Error");
 
+
     delete state;
 }
 
diff --git a/src/Engine/Rendering/Renderer.cpp b/src/Engine/Rendering/Renderer.cpp
index 57849d99..e84768e4 100644
--- a/src/Engine/Rendering/Renderer.cpp
+++ b/src/Engine/Rendering/Renderer.cpp
@@ -63,6 +63,12 @@ void Renderer::InitializeWindow()
 void Renderer::InitializeShaders()
 {
     m_BasicForwardProgram = ResourceManager::Load<ShaderProgram>("#m_BasicForwardProgram");
+
+    m_DrawScreenQuadProgram = ResourceManager::Load<ShaderProgram>("#DrawScreenQuadProgram");
+    m_DrawScreenQuadProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/DrawScreenQuad.vert.glsl")));
+    m_DrawScreenQuadProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/DrawScreenQuad.frag.glsl")));
+    m_DrawScreenQuadProgram->Compile();
+    m_DrawScreenQuadProgram->Link();
 }
 
 void Renderer::InputUpdate(double dt)
@@ -80,16 +86,10 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
-    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking");
-    //clear buffer 0
-    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-    //Clear other buffers
     m_PickingPass->ClearPicking();
-    m_DrawFinalPass->ClearBuffer();
-    m_DrawBloomPass->ClearBuffer();
-
     for (auto scene : frame.RenderScenes){
         
         SortRenderJobsByDepth(*scene);
@@ -98,28 +98,14 @@ void Renderer::Draw(RenderFrame& frame)
         m_LightCullingPass->FillLightList(*scene);
         m_LightCullingPass->CullLights(*scene);
         m_DrawFinalPass->Draw(*scene);
+        //m_DrawScenePass->Draw(rq);
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
 
         m_TextPass->Draw(*scene);
 
     }
-    m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
-    if(m_DebugTextureToDraw == 0) {
-        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture());
-    }
-    if (m_DebugTextureToDraw == 1) {
-        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture());
-    }
-    if (m_DebugTextureToDraw == 2) {
-        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTexture());
-    }
-    if (m_DebugTextureToDraw == 3) {
-        m_DrawScreenQuadPass->Draw(m_DrawBloomPass->GaussianTexture());
-    }
-    if (m_DebugTextureToDraw == 4) {
-        m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
-    }
+    
 
     m_ImGuiRenderPass->Draw();
 	glfwSwapBuffers(m_Window);
@@ -130,6 +116,27 @@ PickData Renderer::Pick(glm::vec2 screenCoord)
     return m_PickingPass->Pick(screenCoord);
 }
 
+void Renderer::DrawScreenQuad(GLuint textureToDraw)
+{
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_CULL_FACE);
+
+    glClearColor(0.f, 0.f, 0.f, 1.f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+
+    m_DrawScreenQuadProgram->Bind();
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, textureToDraw);
+
+    glBindVertexArray(m_ScreenQuad->VAO);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);
+    glDrawElementsBaseVertex(GL_TRIANGLES, m_ScreenQuad->MaterialGroups()[0].EndIndex - m_ScreenQuad->MaterialGroups()[0].StartIndex +1
+        , GL_UNSIGNED_INT, 0, m_ScreenQuad->MaterialGroups()[0].StartIndex);
+}
+
 void Renderer::InitializeTextures()
 {
     m_ErrorTexture = ResourceManager::Load<Texture>("Textures/Core/ErrorTexture.png");
@@ -160,7 +167,4 @@ void Renderer::InitializeRenderPasses()
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
     m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
-    m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
-    m_DrawBloomPass = new DrawBloomPass(this);
-    m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
 }
diff --git a/src/Engine/Rendering/Util/CommonFunctions.cpp b/src/Engine/Rendering/Util/CommonFunctions.cpp
deleted file mode 100644
index 3c81de66..00000000
--- a/src/Engine/Rendering/Util/CommonFunctions.cpp
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "Rendering/Util/CommonFunctions.h"
-