Bloom effect added, will have to see if it needs improving. Also added HDR colors and gamma correction.

include/Engine/Rendering/DrawBloomEffect.h

@@ -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 

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 

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

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 

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();

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);
+}
+
+

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;
+}

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);
+}

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;
+}

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);
+}

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;
+}

src/Engine/Rendering/DrawBloomEffect.cpp

@@ -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");
-
-}

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");
+}

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()
+{
+
+}

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);
+}

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);
 }