Merge branch 'master' into FrustumCulling

src/Engine/Core/EntityWrapper.cpp

@@ -19,7 +19,7 @@ bool EntityWrapper::HasComponent(const std::string& componentName)
 void EntityWrapper::AttachComponent(const char* componentName)
 {
     if (!Valid()) {
-        LOG_WARNING("Could not attach \"%s\" component to #%i, component is not valid.", componentName, ID);
+        LOG_WARNING("Could not attach \"%s\" component to #%i, entity is not valid.", componentName, ID);
         return;
     }
     World->AttachComponent(ID, componentName);

src/Engine/Editor/EditorRenderSystem.cpp

@@ -56,9 +56,9 @@ void EditorRenderSystem::Update(double dt)
             for (auto matGroup : model->MaterialGroups()) {
                 std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f);
                 if (cModel["Transparent"]) {
-                    scene.TransparentObjects.push_back(modelJob);
+                    scene.Jobs.TransparentObjects.push_back(modelJob);
                 } else {
-                    scene.OpaqueObjects.push_back(modelJob);
+                    scene.Jobs.OpaqueObjects.push_back(modelJob);
                 }
             }
         }
@@ -75,7 +75,7 @@ void EditorRenderSystem::Update(double dt)
             EntityWrapper entity(m_World, cPointLight.EntityID);
             ComponentWrapper& cTransform = entity["Transform"];
             std::shared_ptr<PointLightJob> pointLightJob = std::make_shared<PointLightJob>(cTransform, cPointLight, entity.World);
-            scene.PointLightJobs.push_back(pointLightJob);
+            scene.Jobs.PointLight.push_back(pointLightJob);
         }
     }
 

src/Engine/Rendering/DrawColorCorrectionPass.cpp

@@ -6,8 +6,6 @@ DrawColorCorrectionPass::DrawColorCorrectionPass(IRenderer* renderer)
 
     m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.mesh");
 
-    //m_Exposure = 0.4; //TODO: Renderer: Fixa så att denna går att ändra på genom komponent eller setting.
-
     InitializeShaderPrograms();
 }
 
@@ -20,7 +18,7 @@ void DrawColorCorrectionPass::InitializeShaderPrograms()
     m_ColorCorrectionProgram->Link();
 }
 
-void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLfloat gamma, GLfloat exposure)
+void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLuint sceneTextureLowRes, GLuint bloomTextureLowRes, GLfloat gamma, GLfloat exposure)
 {
     //glBindFramebuffer(GL_FRAMEBUFFER, 0);
     GLERROR("DrawScreenQuadPass::Draw: Pre");
@@ -35,6 +33,10 @@ void DrawColorCorrectionPass::Draw(GLuint sceneTexture, GLuint bloomTexture, GLf
     glBindTexture(GL_TEXTURE_2D, sceneTexture);
     glActiveTexture(GL_TEXTURE1);
     glBindTexture(GL_TEXTURE_2D, bloomTexture);
+    glActiveTexture(GL_TEXTURE2);
+    glBindTexture(GL_TEXTURE_2D, sceneTextureLowRes);
+    glActiveTexture(GL_TEXTURE3);
+    glBindTexture(GL_TEXTURE_2D, bloomTextureLowRes);
 
     glBindVertexArray(m_ScreenQuad->VAO);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ScreenQuad->ElementBuffer);

src/Engine/Rendering/DrawFinalPass.cpp

@@ -2,8 +2,10 @@
 
 DrawFinalPass::DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass)
 {
+    //TODO: Make sure that uniforms are not sent into shader if not needed.
     m_Renderer = renderer;
     m_LightCullingPass = lightCullingPass;
+    m_ShieldPixelRate = 8;
     InitializeTextures();
     InitializeShaderPrograms();
     InitializeFrameBuffers();
@@ -21,18 +23,39 @@ void DrawFinalPass::InitializeFrameBuffers()
 {
     glGenRenderbuffers(1, &m_DepthBuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer);
-    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    GLERROR("RenderBuffer generation");
 
     GenerateTexture(&m_SceneTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
     //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
+    //GenerateTexture(&m_StencilTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_STENCIL, GL_STENCIL_INDEX8, GL_INT);
 
-    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_ATTACHMENT)));
+    m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBuffer, GL_DEPTH_STENCIL_ATTACHMENT)));
+    //m_FinalPassFrameBuffer.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_StencilTexture, GL_STENCIL_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();
+    GLERROR("FBO generation");
 
+    glGenRenderbuffers(1, &m_DepthBufferLowRes);
+    glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBufferLowRes);
+    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, (int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate));
+    GLERROR("RenderBufferLowRes generation");
+
+    GenerateTexture(&m_SceneTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_RGB, GL_FLOAT);
+    GenerateTexture(&m_BloomTextureLowRes, GL_CLAMP_TO_EDGE, GL_NEAREST, glm::vec2((int)(m_Renderer->GetViewportSize().Width/m_ShieldPixelRate), (int)(m_Renderer->GetViewportSize().Height/m_ShieldPixelRate)), GL_RGB16F, GL_RGB, GL_FLOAT);
+    //GenerateMipMapTexture(&m_BloomTexture, GL_CLAMP_TO_EDGE, glm::vec2(m_Renderer->GetViewPortSize().Width, m_Renderer->GetViewPortSize().Height), GL_RGB16F, GL_FLOAT, 4);
+    //GenerateTexture(&m_StencilTexture, GL_CLAMP_TO_EDGE, GL_LINEAR, glm::vec2(m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height), GL_STENCIL, GL_STENCIL_INDEX8, GL_INT);
+
+    m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new RenderBuffer(&m_DepthBufferLowRes, GL_DEPTH_STENCIL_ATTACHMENT)));
+    //m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_StencilTexture, GL_STENCIL_ATTACHMENT)));
+    m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_SceneTextureLowRes, GL_COLOR_ATTACHMENT0)));
+    m_FinalPassFrameBufferLowRes.AddResource(std::shared_ptr<BufferResource>(new Texture2D(&m_BloomTextureLowRes, GL_COLOR_ATTACHMENT1)));
+    m_FinalPassFrameBufferLowRes.Generate();
+    GLERROR("FBO2 generation");
 }
 
 void DrawFinalPass::InitializeShaderPrograms()
@@ -55,6 +78,20 @@ void DrawFinalPass::InitializeShaderPrograms()
     m_ExplosionEffectProgram->BindFragDataLocation(1, "bloomColor");
     m_ExplosionEffectProgram->Link();
     GLERROR("Creating explosion program");
+
+    m_ShieldToStencilProgram = ResourceManager::Load<ShaderProgram>("#ShieldToStencilProgram");
+    m_ShieldToStencilProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/ShieldStencil.vert.glsl")));
+    m_ShieldToStencilProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/ShieldStencil.frag.glsl")));
+    m_ShieldToStencilProgram->Compile();
+    m_ShieldToStencilProgram->Link();
+    GLERROR("Creating Shield program");
+
+    m_FillDepthBufferProgram = ResourceManager::Load<ShaderProgram>("#FillDepthBufferProgram");
+    m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/FillDepthBuffer.vert.glsl")));
+    m_FillDepthBufferProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/FillDepthBuffer.frag.glsl")));
+    m_FillDepthBufferProgram->Compile();
+    m_FillDepthBufferProgram->Link();
+    GLERROR("Creating DepthFill program");
 }
 
 void DrawFinalPass::Draw(RenderScene& scene)
@@ -65,20 +102,92 @@ void DrawFinalPass::Draw(RenderScene& scene)
     if (scene.ClearDepth) {
         glClear(GL_DEPTH_BUFFER_BIT);
     }
+    //TODO: Do we need check for this or will it be per scene always?
+    glClearStencil(0x00);
+    glClear(GL_STENCIL_BUFFER_BIT);
 
-    DrawModelRenderQueues(scene.OpaqueObjects, scene);
+    //Fill depth buffer
+
+
+    state->StencilMask(0x00);
+    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
     GLERROR("OpaqueObjects");
-    DrawModelRenderQueues(scene.TransparentObjects, scene);
+    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
     GLERROR("TransparentObjects");
 
-    delete state;
+    //DrawStencilState* stencilState = new DrawStencilState(m_FinalPassFrameBuffer.GetHandle());
+    //Draw shields to stencil pass
+    state->StencilFunc(GL_ALWAYS, 1, 0xFF);
+    state->StencilMask(0xFF);
+    DrawShieldToStencilBuffer(scene.Jobs.ShieldObjects, scene);
+    GLERROR("StencilPass");
+
+    //Draw Opaque shielded objects
+    state->StencilFunc(GL_NOTEQUAL, 1, 0xFF);
+    state->StencilMask(0x00);
+    DrawShieldedModelRenderQueue(scene.Jobs.OpaqueShieldedObjects, scene);
+    GLERROR("Shielded Opaque object");
+
+    //Draw Transparen Shielded objects
+    DrawShieldedModelRenderQueue(scene.Jobs.TransparentShieldedObjects, scene);
+    GLERROR("Shielded Transparent objects");
+
     GLERROR("END");
+    delete state;
+
+
+    DrawFinalPassState* stateLowRes = new DrawFinalPassState(m_FinalPassFrameBufferLowRes.GetHandle());
+    //Draw the lowres texture that will be shown behind the shield.
+    stateLowRes->Enable(GL_SCISSOR_TEST);
+    stateLowRes->Enable(GL_DEPTH_TEST);
+    //TODO: Viewports and scissor should be in state
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_ShieldPixelRate, m_Renderer->GetViewportSize().Height/m_ShieldPixelRate);
+    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+
+    glClearStencil(0x00);
+    glClear(GL_STENCIL_BUFFER_BIT);
+
+    //TODO: This should not be here...
+    stateLowRes->StencilFunc(GL_ALWAYS, 1, 0xFF);
+    stateLowRes->StencilMask(0x00);
+    DrawToDepthBuffer(scene.Jobs.OpaqueObjects, scene);
+    DrawToDepthBuffer(scene.Jobs.TransparentObjects, scene);
+
+    //Draw shields to stencil pass
+    stateLowRes->StencilFunc(GL_ALWAYS, 1, 0xFF);
+    stateLowRes->StencilMask(0xFF);
+    stateLowRes->Enable(GL_DEPTH_TEST);
+    DrawShieldToStencilBuffer(scene.Jobs.ShieldObjects, scene);
+    GLERROR("StencilPass");
+
+    glClear(GL_DEPTH_BUFFER_BIT);
+
+    stateLowRes->Enable(GL_DEPTH_TEST);
+    stateLowRes->StencilFunc(GL_LEQUAL, 1, 0xFF);
+    stateLowRes->StencilMask(0x00);
+    DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
+    GLERROR("OpaqueObjects");
+    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
+    GLERROR("TransparentObjects");
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    delete stateLowRes;
 }
 
 
 void DrawFinalPass::ClearBuffer()
 {
+    m_FinalPassFrameBufferLowRes.Bind();
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width/m_ShieldPixelRate, m_Renderer->GetViewportSize().Height/m_ShieldPixelRate);
+    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glClearColor(0.f, 0.f, 0.f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glDisable(GL_SCISSOR_TEST);
+    m_FinalPassFrameBufferLowRes.Unbind();
+
     m_FinalPassFrameBuffer.Bind();
+    glViewport(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+    glScissor(0, 0, m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     m_FinalPassFrameBuffer.Unbind();
@@ -110,7 +219,7 @@ void DrawFinalPass::GenerateMipMapTexture(GLuint* texture, GLenum wrapping, glm:
     GLERROR("MipMap Texture initialization failed");
 }
 
-void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& job, RenderScene& scene)
+void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
 {
     GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
     GLERROR("forwardHandle");
@@ -121,7 +230,7 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, m_LightCullingPass->LightGridSSBO());
     glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, m_LightCullingPass->LightIndexSSBO());
 
-    for(auto &job : job)
+    for(auto &job : jobs)
     {
         auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
         if(explosionEffectJob) {
@@ -201,6 +310,153 @@ void DrawFinalPass::DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>&
 
 }
 
+
+void DrawFinalPass::DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
+{
+    m_ShieldToStencilProgram->Bind();
+    GLuint shaderHandle = m_ShieldToStencilProgram->GetHandle();
+
+    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()));
+
+    for (auto &job : jobs) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+        if (modelJob) {
+            glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
+            if (GLERROR("models end")) {
+                continue;
+            }
+        }
+    }
+}
+
+void DrawFinalPass::DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
+{
+    GLuint forwardHandle = m_ForwardPlusProgram->GetHandle();
+    GLERROR("forwardHandle");
+    GLuint explosionHandle = m_ExplosionEffectProgram->GetHandle();
+    GLERROR("explosionHandle");
+
+    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());
+
+    for (auto &job : jobs) {
+        auto explosionEffectJob = std::dynamic_pointer_cast<ExplosionEffectJob>(job);
+        if (explosionEffectJob) {
+            //Bind program
+            if (GLERROR("Prebind")) {
+                continue;
+            }
+            m_ExplosionEffectProgram->Bind();
+            if (GLERROR("BindProgram")) {
+                continue;
+            }
+
+            glDisable(GL_CULL_FACE);
+
+            //Bind uniforms
+            BindExplosionUniforms(explosionHandle, explosionEffectJob, scene);
+            if (GLERROR("BindExplosionUniforms")) {
+                continue;
+            }
+
+            if (explosionEffectJob->Model->m_RawModel->m_Skeleton != nullptr) {
+
+                if (explosionEffectJob->Animation != nullptr) {
+                    std::vector<glm::mat4> frameBones = explosionEffectJob->Skeleton->GetFrameBones(*explosionEffectJob->Animation, explosionEffectJob->AnimationTime);
+                    glUniformMatrix4fv(glGetUniformLocation(explosionHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                }
+            }
+            if (GLERROR("Animation")) {
+                continue;
+            }
+
+            //bind textures
+            BindExplosionTextures(explosionEffectJob);
+            if (GLERROR("BindExplosionTextures")) {
+                continue;
+            }
+            //draw
+            glBindVertexArray(explosionEffectJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, explosionEffectJob->Model->ElementBuffer);
+            glDrawElements(GL_TRIANGLES, explosionEffectJob->EndIndex - explosionEffectJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(explosionEffectJob->StartIndex*sizeof(unsigned int)));
+            glEnable(GL_CULL_FACE);
+            if (GLERROR("explosion effect end")) {
+                continue;
+            }
+
+        } else {
+            auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+            if (modelJob) {
+                //bind forward program
+                m_ForwardPlusProgram->Bind();
+                glUniform2f(glGetUniformLocation(forwardHandle, "ScreenDimensions"), m_Renderer->GetViewportSize().Width, m_Renderer->GetViewportSize().Height);
+
+                //bind uniforms
+                BindModelUniforms(forwardHandle, modelJob, scene);
+
+                //bind textures
+                BindModelTextures(modelJob);
+
+                if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+
+                    if (modelJob->Animation != nullptr) {
+                        std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+                        glUniformMatrix4fv(glGetUniformLocation(forwardHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                    }
+                }
+
+                //draw
+                glBindVertexArray(modelJob->Model->VAO);
+                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+                glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
+                if (GLERROR("models end")) {
+                    continue;
+                }
+            }
+        }
+    }
+}
+
+
+void DrawFinalPass::DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene)
+{
+    m_FillDepthBufferProgram->Bind();
+    GLuint shaderHandle = m_FillDepthBufferProgram->GetHandle();
+    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()));
+
+    for (auto &job : jobs) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+      
+        //bind uniforms
+        glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
+
+        if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+
+            if (modelJob->Animation != nullptr) {
+                std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+                glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+            }
+        }
+
+        //draw
+        glBindVertexArray(modelJob->Model->VAO);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+        glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex*sizeof(unsigned int)));
+        if (GLERROR("models end")) {
+            continue;
+        }
+    }
+
+}
+
 void DrawFinalPass::BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene)
 {
     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(job->Matrix));

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -1,6 +1,7 @@
 #include "Rendering/DrawFinalPassState.h"
 
 
+
 DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
 {
     BindFramebuffer(frameBuffer);
@@ -8,6 +9,10 @@ DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
+    Enable(GL_STENCIL_TEST);
+    StencilFunc(GL_NOTEQUAL, 1, 0xFF);
+    StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+    StencilMask(0xFF);
     ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));
 }
 
@@ -15,3 +20,20 @@ DrawFinalPassState::~DrawFinalPassState()
 {
 
 }
+
+DrawStencilState::DrawStencilState(GLuint frameBuffer)
+{
+    BindFramebuffer(frameBuffer);
+    Enable(GL_STENCIL_TEST);
+    StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+    StencilFunc(GL_ALWAYS, 1, 0xFF);
+    StencilMask(0xFF);
+    Enable(GL_DEPTH_TEST);
+    ClearColor(glm::vec4(0.f));
+}
+
+DrawStencilState::~DrawStencilState()
+{
+
+}
+

src/Engine/Rendering/FrameBuffer.cpp

@@ -39,10 +39,13 @@ void FrameBuffer::AddResource(std::shared_ptr<BufferResource> resource)
 
 void FrameBuffer::Generate()
 {
+    GLERROR("PRE");
+
     std::vector<GLenum> attachments;
 
     glGenFramebuffers(1, &m_BufferHandle);
     glBindFramebuffer(GL_FRAMEBUFFER, m_BufferHandle);
+    GLERROR("1");
 
     for (auto it = m_Resources.begin(); it != m_Resources.end(); it++) {
         switch ((*it)->m_ResourceType) {
@@ -56,20 +59,30 @@ void FrameBuffer::Generate()
             GLERROR("FrameBuffer generate: glFramebufferRenderbuffer");
             break;
         }
-        
+        GLERROR("2");
 
-        if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT) {
+        if ((*it)->m_Attachment != GL_DEPTH_ATTACHMENT && (*it)->m_Attachment != GL_STENCIL_ATTACHMENT && (*it)->m_Attachment != GL_DEPTH_STENCIL_ATTACHMENT) {
             attachments.push_back((*it)->m_Attachment);
         }
+        GLERROR("Attachment");
+
     }
-        
+    GLERROR("3");
+
+
     GLenum* bufferTextures = &attachments[0];
     glDrawBuffers(attachments.size(), bufferTextures);
+    if(GLERROR("4")) {
+        printf("hello");
+    }
 
     if (GLenum frameBufferStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-        LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);
+        GLERROR("Framebuffer incomplete");
+        //LOG_ERROR("FrameBuffer incomplete: 0x%x\n", frameBufferStatus);
         exit(EXIT_FAILURE);
     }
+    GLERROR("END");
+
 }
 
 void FrameBuffer::Bind()

src/Engine/Rendering/LightCullingPass.cpp

@@ -16,7 +16,7 @@ LightCullingPass::~LightCullingPass()
 
 void LightCullingPass::GenerateNewFrustum(RenderScene& scene)
 {
-    if (scene.PointLightJobs.size() == 0)
+    if (scene.Jobs.PointLight.size() == 0)
         return;
 
     GLERROR("CalculateFrustum Error: Pre");
@@ -83,7 +83,7 @@ void LightCullingPass::FillLightList(RenderScene& scene)
 {
     m_LightSources.clear();
 
-    for(auto &job : scene.PointLightJobs) {
+    for(auto &job : scene.Jobs.PointLight) {
         auto pointLightjob = std::dynamic_pointer_cast<PointLightJob>(job);
         if (pointLightjob) {
             LightSource p;
@@ -97,7 +97,7 @@ void LightCullingPass::FillLightList(RenderScene& scene)
             m_LightSources.push_back(p);
         }
     }
-    for(auto &job : scene.DirectionalLightJobs) {
+    for(auto &job : scene.Jobs.DirectionalLight) {
         auto directionalLightJob = std::dynamic_pointer_cast<DirectionalLightJob>(job);
         if(directionalLightJob) {
             LightSource p;

src/Engine/Rendering/PickingPass.cpp

@@ -56,7 +56,7 @@ void PickingPass::Draw(RenderScene& scene)
     }
     m_Camera = scene.Camera;
 
-    for (auto &job : scene.OpaqueObjects) {
+    for (auto &job : scene.Jobs.OpaqueObjects) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {
@@ -102,7 +102,99 @@ void PickingPass::Draw(RenderScene& scene)
         }
     }
 
-    for (auto &job : scene.TransparentObjects) {
+    for (auto &job : scene.Jobs.TransparentObjects) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+
+        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;
+
+            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] += 1;
+                } else {
+                    m_ColorCounter[0] += 1;
+                }
+            }
+
+            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])));
+
+            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+
+                if (modelJob->Animation != nullptr) {
+                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                }
+            }
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
+        }
+    }
+
+    for (auto &job : scene.Jobs.OpaqueShieldedObjects) {
+        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
+
+        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;
+
+            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] += 1;
+                } else {
+                    m_ColorCounter[0] += 1;
+                }
+            }
+
+            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])));
+
+            if (modelJob->Model->m_RawModel->m_Skeleton != nullptr) {
+
+                if (modelJob->Animation != nullptr) {
+                    std::vector<glm::mat4> frameBones = modelJob->Skeleton->GetFrameBones(*modelJob->Animation, modelJob->AnimationTime);
+                    glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
+                }
+            }
+
+            glBindVertexArray(modelJob->Model->VAO);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
+            glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
+        }
+    }
+
+    for (auto &job : scene.Jobs.TransparentShieldedObjects) {
         auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
 
         if (modelJob) {

src/Engine/Rendering/RenderState.cpp

@@ -6,9 +6,10 @@ bool RenderState::Enable(GLenum cap)
         //LOG_WARNING("Trying to enable somthing that is already enabled.");
         return false;
     }
+
     m_ResetFunctions.push_back(std::bind(glDisable, cap));
     glEnable(cap);
-    return !GLERROR("RenderState::Enable");
+    return !GLERROR("Enable");
 }
 
 bool RenderState::Disable(GLenum cap)
@@ -16,9 +17,10 @@ bool RenderState::Disable(GLenum cap)
     if (!glIsEnabled(cap)) {
         return false;
     }
+
     m_ResetFunctions.push_back(std::bind(glEnable, cap));
     glDisable(cap);
-    return !GLERROR("RenderState::Disable");
+    return !GLERROR("Disable");
 }
 
 bool RenderState::CullFace(GLenum mode)
@@ -32,7 +34,7 @@ bool RenderState::CullFace(GLenum mode)
     glGetIntegerv(GL_CULL_FACE_MODE, &original);
     m_ResetFunctions.push_back(std::bind(glCullFace, original));
     glCullFace(mode);
-    return !GLERROR("RenderState::CullFace");
+    return !GLERROR("CullFace");
 }
 
 bool RenderState::ClearColor(glm::vec4 color)
@@ -41,7 +43,7 @@ bool RenderState::ClearColor(glm::vec4 color)
     glGetFloatv(GL_COLOR_CLEAR_VALUE, &original[0]);
     m_ResetFunctions.push_back(std::bind(glClearColor, original[0], original[1], original[2], original[3]));
     glClearColor(color.r, color.g, color.b, color.a);
-    return !GLERROR("RenderState::ClearColor");
+    return !GLERROR("ClearColor");
 }
 
 bool RenderState::BindFramebuffer(GLint framebuffer)
@@ -55,7 +57,7 @@ bool RenderState::BindFramebuffer(GLint framebuffer)
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, originalDraw); 
     });
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-    return !GLERROR("RenderState::BindBuffer");
+    return !GLERROR("BindBuffer");
 }
 
 
@@ -67,7 +69,7 @@ bool RenderState::BlendEquation(GLenum mode)
     glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &originalAlpha);
     m_ResetFunctions.push_back(std::bind(glBlendEquationSeparate, originalRGB, originalAlpha));
     glBlendEquation(mode);
-    return !GLERROR("RenderState::BlendEquation");
+    return !GLERROR("BlendEquation");
 }
 
 bool RenderState::BlendFunc(GLenum sfactor, GLenum dfactor)
@@ -82,7 +84,46 @@ bool RenderState::BlendFunc(GLenum sfactor, GLenum dfactor)
     glGetIntegerv(GL_BLEND_DST_ALPHA, &originalDestAlpha);
     m_ResetFunctions.push_back(std::bind(glBlendFuncSeparate, originalSrcRGB, originalSrcAlpha, originalDestRGB, originalDestAlpha));
     glBlendFunc(sfactor, dfactor);
-    return !GLERROR("RenderState::BlendFunc");
+    return !GLERROR("BlendFunc");
+}
+
+
+bool RenderState::StencilOp(GLenum sfail, GLenum dpfail, GLenum dppass)
+{
+    GLint originalSFail;
+    glGetIntegerv(GL_STENCIL_FAIL, &originalSFail);
+    GLint originalDPFail;
+    glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &originalDPFail);
+    GLint originalDPPass;
+    glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &originalDPPass);
+    m_ResetFunctions.push_back(std::bind(glStencilOp, originalSFail, originalDPFail, originalDPPass));
+    glStencilOp(sfail, dpfail, dppass);
+    return !GLERROR("StencilOp");
+}
+
+
+bool RenderState::StencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+    GLint originalFunc;
+    glGetIntegerv(GL_STENCIL_FUNC, &originalFunc);
+    GLint originalRef;
+    glGetIntegerv(GL_STENCIL_REF, &originalRef);
+    GLint originalMask;
+    glGetIntegerv(GL_STENCIL_VALUE_MASK, &originalMask);
+    m_ResetFunctions.push_back(std::bind(glStencilFunc, originalFunc, originalRef, originalMask));
+    glStencilFunc(func, ref, mask);
+    return !GLERROR("StencilFunc");
+}
+
+
+
+bool RenderState::StencilMask(GLuint mask)
+{
+    GLint originalMask;
+    glGetIntegerv(GL_STENCIL_WRITEMASK, &originalMask);
+    m_ResetFunctions.push_back(std::bind(glStencilMask, mask));
+    glStencilMask(mask);
+    return !GLERROR("StencilMask");
 }
 
 bool RenderState::DepthMask(GLboolean flag)
@@ -91,12 +132,12 @@ bool RenderState::DepthMask(GLboolean flag)
     glGetBooleanv(GL_DEPTH_WRITEMASK, &original);
     m_ResetFunctions.push_back(std::bind(glDepthMask, original));
     glDepthMask(flag);
-    return !GLERROR("RenderState::DepthMask");
+    return !GLERROR("DepthMask");
 }
 
 RenderState::~RenderState()
 {
-    for (auto& f : m_ResetFunctions) {
+    for (auto& f : boost::adaptors::reverse(m_ResetFunctions)) {
         f();
     }
 }

src/Engine/Rendering/RenderSystem.cpp

@@ -43,7 +43,7 @@ bool RenderSystem::isChildOfCurrentCamera(EntityWrapper entity)
     return entity == m_CurrentCamera || entity.IsChildOf(m_CurrentCamera);
 }
 
-void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs, std::list<std::shared_ptr<RenderJob>>& transparentJobs)
+void RenderSystem::fillModels(RenderScene::Queues &Jobs)
 {
     Frustum frustum(m_Camera->ProjectionMatrix() * m_Camera->ViewMatrix());
     std::vector<EntityAABB> seenEntities;
@@ -94,7 +94,9 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs,
         }
 
         glm::mat4 modelMatrix = Transform::ModelMatrix(cModel.EntityID, m_World);
+        //Loop through all materialgroups of a model
         for (auto matGroup : model->MaterialGroups()) {
+            //If the model has an explosioneffect component, we will add an explosioneffectjob
             if (m_World->HasComponent(cModel.EntityID, "ExplosionEffect")) {
                 auto explosionEffectComponent = m_World->GetComponent(cModel.EntityID, "ExplosionEffect");
                 std::shared_ptr<ExplosionEffectJob> explosionEffectJob = std::shared_ptr<ExplosionEffectJob>(new ExplosionEffectJob(
@@ -108,14 +110,30 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs,
                     fillColor, 
                     fillPercentage
                 ));
-                if(explosionEffectJob->Color.a != 1.f || explosionEffectJob->EndColor.a != 1.f || explosionEffectJob->DiffuseColor.a != 1.f) {
-                    cModel["Transparent"] = true;
-                }
+                if (m_World->HasComponent(cModel.EntityID, "Shield")){
+                    Jobs.ShieldObjects.push_back(explosionEffectJob);
+                } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
+                    || m_World->HasComponent(cModel.EntityID, "Player")) {
 
-                if (cModel["Transparent"]) {
-                    transparentJobs.push_back(explosionEffectJob);
+                    if (explosionEffectJob->Color.a != 1.f || explosionEffectJob->EndColor.a != 1.f || explosionEffectJob->DiffuseColor.a != 1.f) {
+                        cModel["Transparent"] = true;
+                    }
+
+                    if (cModel["Transparent"]) {
+                        Jobs.TransparentShieldedObjects.push_back(explosionEffectJob);
+                    } else {
+                        Jobs.OpaqueShieldedObjects.push_back(explosionEffectJob);
+                    }
                 } else {
-                    opaqueJobs.push_back(explosionEffectJob);
+                    if (explosionEffectJob->Color.a != 1.f || explosionEffectJob->EndColor.a != 1.f || explosionEffectJob->DiffuseColor.a != 1.f) {
+                        cModel["Transparent"] = true;
+                    }
+
+                    if (cModel["Transparent"]) {
+                        Jobs.TransparentObjects.push_back(explosionEffectJob);
+                    } else {
+                        Jobs.OpaqueObjects.push_back(explosionEffectJob);
+                    }
                 }
             } else {
                 std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(
@@ -128,13 +146,30 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& opaqueJobs,
                     fillColor, 
                     fillPercentage
                 ));
-                if (modelJob->Color.a != 1.f || modelJob->DiffuseColor.a != 1.f) {
-                    cModel["Transparent"] = true;
-                }
-                if (cModel["Transparent"]) {
-                    transparentJobs.push_back(modelJob);
+                if (m_World->HasComponent(cModel.EntityID, "Shield")) {
+                    Jobs.ShieldObjects.push_back(modelJob);
+                } else if (m_World->HasComponent(cModel.EntityID, "Shielded")
+                    || m_World->HasComponent(cModel.EntityID, "Player")) {
+
+                    if (modelJob->Color.a != 1.f || modelJob->DiffuseColor.a != 1.f) {
+                        cModel["Transparent"] = true;
+                    }
+
+                    if (cModel["Transparent"]) {
+                        Jobs.TransparentShieldedObjects.push_back(modelJob);
+                    } else {
+                        Jobs.OpaqueShieldedObjects.push_back(modelJob);
+                    }
                 } else {
-                    opaqueJobs.push_back(modelJob);
+                    if (modelJob->Color.a != 1.f || modelJob->DiffuseColor.a != 1.f) {
+                        cModel["Transparent"] = true;
+                    }
+
+                    if (cModel["Transparent"]) {
+                        Jobs.TransparentObjects.push_back(modelJob);
+                    } else {
+                        Jobs.OpaqueObjects.push_back(modelJob);
+                    }
                 }
             }
         }
@@ -253,10 +288,10 @@ void RenderSystem::Update(double dt)
         scene.AmbientColor = (glm::vec4)(*cSceneLight->begin())["AmbientColor"];
     }
 
-    fillModels(scene.OpaqueObjects, scene.TransparentObjects);
-    fillPointLights(scene.PointLightJobs, m_World);
-    fillDirectionalLights(scene.DirectionalLightJobs, m_World);
-    fillText(scene.TextJobs, m_World);
+    fillModels(scene.Jobs);
+    fillPointLights(scene.Jobs.PointLight, m_World);
+    fillDirectionalLights(scene.Jobs.DirectionalLight, m_World);
+    fillText(scene.Jobs.Text, m_World);
     m_RenderFrame->Add(scene);
    
 }

src/Engine/Rendering/Renderer.cpp

@@ -93,7 +93,7 @@ void Renderer::Update(double dt)
 
 void Renderer::Draw(RenderFrame& frame)
 {
-    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0Gaussian\0Picking");
+    ImGui::Combo("Draw textures", &m_DebugTextureToDraw, "Final\0Scene\0Bloom\0SceneLowRes\0BloomLowRes\0Gaussian\0Picking");
     //clear buffer 0
     glClearColor(0.f, 0.f, 0.f, 0.f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -120,7 +120,7 @@ void Renderer::Draw(RenderFrame& frame)
     }
     m_DrawBloomPass->Draw(m_DrawFinalPass->BloomTexture());
     if (m_DebugTextureToDraw == 0) {
-        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), frame.Gamma, frame.Exposure);
+        m_DrawColorCorrectionPass->Draw(m_DrawFinalPass->SceneTexture(), m_DrawBloomPass->GaussianTexture(), m_DrawFinalPass->SceneTextureLowRes(), m_DrawFinalPass->BloomTextureLowRes(), frame.Gamma, frame.Exposure);
     }
     if (m_DebugTextureToDraw == 1) {
         m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTexture());
@@ -129,9 +129,15 @@ void Renderer::Draw(RenderFrame& frame)
         m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTexture());
     }
     if (m_DebugTextureToDraw == 3) {
-        m_DrawScreenQuadPass->Draw(m_DrawBloomPass->GaussianTexture());
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->SceneTextureLowRes());
     }
     if (m_DebugTextureToDraw == 4) {
+        m_DrawScreenQuadPass->Draw(m_DrawFinalPass->BloomTextureLowRes());
+    }
+    if (m_DebugTextureToDraw == 5) {
+        m_DrawScreenQuadPass->Draw(m_DrawBloomPass->GaussianTexture());
+    }
+    if (m_DebugTextureToDraw == 6) {
         m_DrawScreenQuadPass->Draw(m_PickingPass->PickingTexture());
     }
 
@@ -154,7 +160,7 @@ void Renderer::InitializeTextures()
 void Renderer::SortRenderJobsByDepth(RenderScene &scene)
 {
     //Sort all forward jobs so transparency is good.
-    scene.TransparentObjects.sort(Renderer::DepthSort);
+    scene.Jobs.TransparentObjects.sort(Renderer::DepthSort);
 }
 
 void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type)

src/Engine/Rendering/TextPass.cpp

@@ -35,7 +35,7 @@ void TextPass::Draw(RenderScene& scene, FrameBuffer& frameBuffer)
 {
     GLERROR("Derp1");
     TextPassState* state = new TextPassState(frameBuffer.GetHandle());
-    for (auto &job : scene.TextJobs) {
+    for (auto &job : scene.Jobs.Text) {
         auto textJob = std::dynamic_pointer_cast<TextJob>(job);
         if (textJob) {
 

src/Game/Systems/CapturePointSystem.cpp

@@ -57,7 +57,7 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     int blueTeamPlayersStandingInside = 0;
     if (capturePointEntity.HasComponent("Model")) {
         //Now sets team color to the capturepoint, or white if it is uncaptured.
-        capturePointEntity["Model"]["Color"] = ownedBy == blueTeam ? glm::vec4(0, 0.2f, 1, 1) : ownedBy == redTeam ? glm::vec4(1, 0.2f, 0, 1) : glm::vec4(1, 1, 1, 1);
+        capturePointEntity["Model"]["Color"] = ownedBy == blueTeam ? glm::vec4(0, 0.2f, 1, 0.3) : ownedBy == redTeam ? glm::vec4(1, 0.2f, 0, 0.3) : glm::vec4(1, 1, 1, 0.3);
     }
 
     //calculate next possible capturePoint for both teams
@@ -106,10 +106,10 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
 
     //colorize next possible capturepoint
     if (nextPossibleCapturePoint["Red"] == capturePointNumber) {
-        capturePointEntity["Model"]["Color"] = glm::vec4(1, 1, 0, 1);
+        capturePointEntity["Model"]["Color"] = glm::vec4(1, 1, 0, 0.3);
     }
     if (nextPossibleCapturePoint["Blue"] == capturePointNumber) {
-        capturePointEntity["Model"]["Color"] = glm::vec4(0, 1, 1, 1);
+        capturePointEntity["Model"]["Color"] = glm::vec4(0, 1, 1, 0.3);
     }
 
     //check how many players are standing inside and are healthy

src/Game/Systems/PlayerMovementSystem.cpp

@@ -95,7 +95,7 @@ void PlayerMovementSystem::Update(double dt)
                 } else {
                     controller->SetDoubleJumping(true);
                 }
-                velocity.y += 4.f;
+                velocity.y = 4.f;
             }
 
             if (player.HasComponent("AABB")) {