Merge remote-tracking branch 'origin/master' into Importer

# Conflicts:
#	resources/Schema/Entities/RenderingWorld.xml
#	resources/Shaders/ForwardPlus.frag.glsl
#	src/Engine/Editor/EditorSystem.cpp
#	src/Engine/Network/Server.cpp
#	src/Engine/Rendering/DrawFinalPass.cpp
#	src/Tests/OctTreeTestGameClass.cpp
#	src/Tests/OctTreeTestHardCodedTestWorld.h
#	src/Tests/ResourceManagerTest.cpp

src/Engine/Rendering/Camera.cpp

@@ -79,6 +79,19 @@ void Camera::UpdateProjectionMatrix()
 	m_ProjectionMatrix = glm::perspective(m_FOV, m_AspectRatio, m_NearClip, m_FarClip);
 }
 
+glm::vec2 Camera::WorldToScreen(glm::vec3 worldCoord, Rectangle resolution)
+{
+    glm::vec4 screenCoord = m_ProjectionMatrix * m_ViewMatrix * glm::vec4(worldCoord, 1.f);
+    if (screenCoord.w != 0) {
+        screenCoord.x /= screenCoord.w;
+        screenCoord.y /= screenCoord.w;
+        screenCoord.z /= screenCoord.w;
+    }
+    screenCoord.x = screenCoord.x * (resolution.Width / 2.f);
+    screenCoord.y = screenCoord.y * (resolution.Height / 2.f);
+    return glm::vec2(screenCoord);
+}
+
 void Camera::UpdateViewMatrix()
 {
 	m_ViewMatrix = glm::toMat4(glm::inverse(m_Orientation))

src/Engine/Rendering/DrawBloomPass.cpp

@@ -0,0 +1,134 @@
+#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");
+}

src/Engine/Rendering/DrawBloomPassState.cpp

@@ -0,0 +1,15 @@
+#include "Rendering/DrawBloomPassState.h"
+
+
+DrawBloomPassState::DrawBloomPassState()
+{
+    //BindFramebuffer(0);
+    Disable(GL_BLEND);
+    Disable(GL_DEPTH_TEST);
+    Disable(GL_CULL_FACE);
+}
+
+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 = 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);
+}

src/Engine/Rendering/DrawFinalPass.cpp

@@ -6,11 +6,31 @@ 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()
@@ -19,6 +39,8 @@ void DrawFinalPass::InitializeShaderPrograms()
     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->BindFragDataLocation(0, "sceneColor");
+    m_ForwardPlusProgram->BindFragDataLocation(1, "bloomColor");
     m_ForwardPlusProgram->Link();
 }
 static double tempTime = 0.0;
@@ -26,16 +48,21 @@ void DrawFinalPass::Draw(RenderScene& scene)
 {
     GLERROR("DrawFinalPass::Draw: Pre");
 
-    DrawFinalPassState state;
+    DrawFinalPassState* state = new DrawFinalPassState(m_FinalPassFrameBuffer.GetHandle());
+
     m_ForwardPlusProgram->Bind();
     GLuint shaderHandle = m_ForwardPlusProgram->GetHandle();
 
+    if (scene.ClearDepth) {
+        glClear(GL_DEPTH_BUFFER_BIT);
+    }
+
     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()));
+    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()));
     glUniform2f(glGetUniformLocation(shaderHandle, "ScreenDimensions"), m_Renderer->Resolution().Width, m_Renderer->Resolution().Height);
 
     //TODO: Render: Add code for more jobs than modeljobs.
@@ -47,11 +74,10 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
             glUniform4fv(glGetUniformLocation(shaderHandle, "DiffuseColor"), 1, glm::value_ptr(modelJob->DiffuseColor));
 
+            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);
             }
             tempTime += 0.01f;
@@ -62,6 +88,14 @@ void DrawFinalPass::Draw(RenderScene& scene)
                     std::vector<glm::mat4> frameBones = modelJob->Model->m_RawModel->m_Skeleton->GetFrameBones(
                         *animation,
                         tempTime
+            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);
+            }*/
                         );
                     glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "Bones"), frameBones.size(), GL_FALSE, glm::value_ptr(frameBones[0]));
                 }
@@ -72,6 +106,42 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glDrawElements(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, (void*)(modelJob->StartIndex * sizeof(unsigned int)));
         }
     }
+    m_FinalPassFrameBuffer.Unbind();
     GLERROR("DrawFinalPass::Draw: END");
+    delete state;
+}
 
+
+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");
 }

src/Engine/Rendering/DrawFinalPassState.cpp

@@ -1,15 +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(200.f / 255, 0.f / 255, 200.f / 255, 0.f));
-    Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));
 }
 
 DrawFinalPassState::~DrawFinalPassState()

src/Engine/Rendering/DrawScenePass.cpp

@@ -1,62 +0,0 @@
-#include "Rendering/DrawScenePass.h"
-
-DrawScenePass::DrawScenePass(IRenderer* renderer)
-{
-    m_Renderer = renderer;
-    InitializeTextures();
-    InitializeShaderPrograms();
-}
-
-void DrawScenePass::InitializeTextures()
-{
-    m_WhiteTexture = ResourceManager::Load<Texture>("Textures/Core/Blank.png");
-}
-
-void DrawScenePass::InitializeShaderPrograms()
-{
-    m_BasicForwardProgram = ResourceManager::Load<ShaderProgram>("#BasicForwardProgram");
-
-    m_BasicForwardProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/BasicForward.vert.glsl")));
-    m_BasicForwardProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/BasicForward.frag.glsl")));
-    m_BasicForwardProgram->Compile();
-    m_BasicForwardProgram->Link();
-}
-
-void DrawScenePass::Draw(RenderScene& scene)
-{
-    //glBindFramebuffer(GL_FRAMEBUFFER, 0);
-    GLERROR("DrawScenePass::Draw: Pre");
-
-    DrawScenePassState state = DrawScenePassState();
-    m_BasicForwardProgram->Bind();
-
-    for (auto &job : scene.ForwardJobs) {
-        auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
-        if (modelJob) {
-            GLuint ShaderHandle = m_BasicForwardProgram->GetHandle();
-
-            //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));
-            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()));            
-            glUniform4fv(glGetUniformLocation(ShaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
-
-            //TODO: Renderer: bättre textur felhantering samt fler texturer stöd
-            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("DrawScenePass::Draw: End");
-}

src/Engine/Rendering/DrawScenePassState.cpp

@@ -1,20 +0,0 @@
-#include "Rendering/DrawScenePassState.h"
-
-
-DrawScenePassState::DrawScenePassState()
-{
-    GLERROR("---");
-    BindFramebuffer(0);
-    GLERROR("---");
-    Enable(GL_DEPTH_TEST);
-    Enable(GL_CULL_FACE);
-    Enable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-   // ClearColor(glm::vec4(255.f / 255, 163.f / 255, 176.f / 255, 0.f));
-   // Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-}
-
-DrawScenePassState::~DrawScenePassState()
-{
-
-}

src/Engine/Rendering/DrawScreenQuadPass.cpp

@@ -0,0 +1,37 @@
+#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);
+}

src/Engine/Rendering/DrawScreenQuadPassState.cpp

@@ -0,0 +1,18 @@
+#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()
+{
+
+}

src/Engine/Rendering/Font.cpp

@@ -0,0 +1,108 @@
+#include "Rendering/Font.h"
+
+
+Font::Font(std::string path)
+{
+    typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
+    boost::char_separator<char> sep(",");
+    tokenizer tok(path, sep);
+
+
+    tokenizer::iterator it = tok.begin();
+    std::string filePath = "";
+
+    if (it != tok.end()) {
+        filePath = (*it).c_str();
+        it++;
+        if (it != tok.end()) {
+            if((*it).c_str() == "") {
+                throw std::runtime_error("");
+            }
+
+            try {
+                FontSize = boost::lexical_cast<int>((*it).c_str());
+            } catch (boost::bad_lexical_cast const&) {
+                LOG_ERROR("input string did not have a valid font resolution");
+                throw std::runtime_error("");
+            }
+        }
+    } else {
+        throw std::runtime_error("");;
+    }
+
+
+    FT_Library library;
+    FT_Face face;
+
+    if (FT_Init_FreeType(&library)) {
+        LOG_ERROR("FreeType error: init failed");
+        throw std::runtime_error("");;
+    }
+
+    if (FT_New_Face(library, filePath.c_str(), 0, &face)) {
+        LOG_ERROR("FreeType error: loading font");
+        throw std::runtime_error("");;
+    }
+
+    FT_Set_Char_Size(face, 0, FontSize*64, 300, 300); // temp
+    FT_Set_Pixel_Sizes(face, 0, FontSize);            //
+
+    if (FT_Load_Char(face, 'X', FT_LOAD_RENDER)) {
+        LOG_ERROR("FreeType error: loading char");
+        throw std::runtime_error("");;
+    }
+
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    for (GLubyte c = 0; c < 128; c++) {
+       
+
+        //Load character glyph
+        if (FT_Load_Char(face, c, FT_LOAD_RENDER)) {
+            continue;
+        }
+
+        //Generate texture
+        GLuint texture;
+        glGenTextures(1, &texture);
+        glBindTexture(GL_TEXTURE_2D, texture);
+
+        glTexImage2D(
+            GL_TEXTURE_2D,
+            0,
+            GL_RED,
+            face->glyph->bitmap.width,
+            face->glyph->bitmap.rows,
+            0,
+            GL_RED,
+            GL_UNSIGNED_BYTE,
+            face->glyph->bitmap.buffer
+            );
+        // Set texture options
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        // Now store character for later use
+        Character character = {
+            texture,
+            glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows),
+            glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top),
+            face->glyph->advance.x
+        };
+
+        m_Characters.insert(std::pair<GLchar, Character>(c, character));
+    }
+
+    
+    FT_Done_Face(face);
+    FT_Done_FreeType(library);
+    GLERROR("Font Load");
+}
+
+Font::~Font()
+{
+    for (auto c : m_Characters) {
+        glDeleteTextures(1, &c.second.TextureID);
+    }
+}

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

src/Engine/Rendering/ImGuiRenderPass.cpp

@@ -105,7 +105,7 @@ void ImGuiRenderPass::Draw()
             if (pcmd->UserCallback) {
                 pcmd->UserCallback(cmd_list, pcmd);
             } else {
-                glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
+                glBindTexture(GL_TEXTURE_2D, (GLuint)pcmd->TextureId);
                 glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
                 glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
             }
@@ -190,7 +190,7 @@ bool ImGuiRenderPass::createDeviceObjects()
         "{\n"
         "	Frag_UV = UV;\n"
         "	Frag_Color = Color;\n"
-        "	gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
+        "	gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n"
         "}\n";
 
     const GLchar* fragment_shader =
@@ -201,7 +201,7 @@ bool ImGuiRenderPass::createDeviceObjects()
         "out vec4 Out_Color;\n"
         "void main()\n"
         "{\n"
-        "	Out_Color = Frag_Color * texture( Texture, Frag_UV.st);\n"
+        "	Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n"
         "}\n";
 
     g_ShaderHandle = glCreateProgram();
@@ -271,7 +271,7 @@ bool ImGuiRenderPass::createFontsTexture()
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 
     // Store our identifier
-    io.Fonts->TexID = (void *)(intptr_t)g_FontTexture;
+    io.Fonts->TexID = (void*)g_FontTexture;
 
     // Restore state
     glBindTexture(GL_TEXTURE_2D, last_texture);

src/Engine/Rendering/PickingPass.cpp

@@ -46,60 +46,57 @@ 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();
 
-    
+    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");
 
-
     delete state;
 }
 

src/Engine/Rendering/PickingPassState.cpp

@@ -8,6 +8,7 @@ PickingPassState::PickingPassState(GLuint frameBuffer)
     GLERROR("---3");
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
+    Disable(GL_BLEND);
 
     glm::vec4 clearColor = glm::vec4(0.f);
     //ClearColor(clearColor);

src/Engine/Rendering/RenderState.cpp

@@ -44,12 +44,6 @@ bool RenderState::ClearColor(glm::vec4 color)
     return !GLERROR("RenderState::ClearColor");
 }
 
-bool RenderState::Clear(GLbitfield mask)
-{
-    glClear(mask);
-    return !GLERROR("RenderState::Clear");
-}
-
 bool RenderState::BindFramebuffer(GLint framebuffer)
 {
     GLint originalRead;
@@ -91,6 +85,15 @@ bool RenderState::BlendFunc(GLenum sfactor, GLenum dfactor)
     return !GLERROR("RenderState::BlendFunc");
 }
 
+bool RenderState::DepthMask(GLboolean flag)
+{
+    GLboolean original;
+    glGetBooleanv(GL_DEPTH_WRITEMASK, &original);
+    m_ResetFunctions.push_back(std::bind(glDepthMask, original));
+    glDepthMask(flag);
+    return !GLERROR("RenderState::DepthMask");
+}
+
 RenderState::~RenderState()
 {
     for (auto& f : m_ResetFunctions) {

src/Engine/Rendering/RenderSystem.cpp

@@ -1,7 +1,7 @@
 #include "Rendering/RenderSystem.h"
 
-RenderSystem::RenderSystem(EventBroker* eventBroker, const IRenderer* renderer, RenderFrame* renderFrame)
-    : System(eventBroker)
+RenderSystem::RenderSystem(World* world, EventBroker* eventBroker, const IRenderer* renderer, RenderFrame* renderFrame) 
+    : System(world, eventBroker)
     , m_Renderer(renderer)
     , m_RenderFrame(renderFrame)
 {
@@ -9,74 +9,29 @@ RenderSystem::RenderSystem(EventBroker* eventBroker, const IRenderer* renderer,
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &RenderSystem::OnInputCommand);
 
     m_Camera = new Camera((float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, glm::radians(45.f), 0.01f, 5000.f);
-    m_DebugCameraInputController = new DebugCameraInputController<RenderSystem>(eventBroker, -1);
 }
 
 RenderSystem::~RenderSystem()
 {
     delete m_Camera;
-    delete m_DebugCameraInputController;
 }
 
-bool RenderSystem::OnSetCamera(const Events::SetCamera &event)
+bool RenderSystem::OnSetCamera(Events::SetCamera& e)
 {
-    auto cameras = m_World->GetComponents("Camera");
-
-    if (cameras != nullptr) {
-        for (auto it = cameras->begin(); it != cameras->end(); it++) {
-            if ((std::string)(*it)["Name"] == event.Name) {
-                switchCamera((*it).EntityID);
-            }
-        }
-    }
+    ComponentWrapper cTransform = e.CameraEntity["Transform"];
+    ComponentWrapper cCamera = e.CameraEntity["Camera"];
+    m_Camera->SetFOV((double)cCamera["FOV"]);
+    m_Camera->SetNearClip((double)cCamera["NearClip"]);
+    m_Camera->SetFarClip((double)cCamera["FarClip"]);
+    m_Camera->SetPosition(cTransform["Position"]);
+    m_Camera->SetOrientation(glm::quat((const glm::vec3&)cTransform["Orientation"]));
+    m_CurrentCamera = e.CameraEntity;
     return true;
 }
 
-void RenderSystem::switchCamera(EntityID entity)
+void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs)
 {
-    if(m_World->HasComponent(entity, "Camera")) {
-
-        if (m_CurrentCamera != EntityID_Invalid) {
-            if (m_World->HasComponent(m_CurrentCamera, "Model")) {
-                m_World->GetComponent(m_CurrentCamera, "Model")["Visible"] = true;
-            }
-            if (m_World->HasComponent(m_CurrentCamera, "Listener")) {
-                m_World->DeleteComponent(m_CurrentCamera, "Listener");
-            }
-        }
-
-        if (m_World->HasComponent(entity, "Model")) {
-            m_World->GetComponent(entity, "Model")["Visible"] = false;
-        }
-        if (!m_World->HasComponent(entity, "Listener")) {
-            m_World->AttachComponent(entity, "Listener");
-        }
-        m_CurrentCamera = entity;
-        m_SwitchCamera = false;
-
-    } else {
-        LOG_ERROR("Entity %i does not have a CameraComponent", entity);
-        m_SwitchCamera = false;
-    }
-}
-
-void RenderSystem::updateProjectionMatrix(ComponentWrapper& cameraComponent)
-{
-    double fov = cameraComponent["FOV"];
-    double aspectRatio = (float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height;
-    double nearClip = cameraComponent["NearClip"];
-    double farClip = cameraComponent["FarClip"];
-
-    m_Camera->SetFOV(glm::radians(fov));
-    m_Camera->SetAspectRatio(aspectRatio);
-    m_Camera->SetNearClip(nearClip);
-    m_Camera->SetFarClip(farClip);
-    m_Camera->UpdateProjectionMatrix();
-}
-
-void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
-{
-    auto models = world->GetComponents("Model");
+    auto models = m_World->GetComponents("Model");
     if (models == nullptr) {
         return;
     }
@@ -113,18 +68,17 @@ void RenderSystem::fillModels(std::list<std::shared_ptr<RenderJob>>& jobs, World
             }
         }
 
-        glm::mat4 modelMatrix = Transform::ModelMatrix(modelComponent.EntityID, world);
+        glm::mat4 modelMatrix = Transform::ModelMatrix(modelComponent.EntityID, m_World);
         for (auto matGroup : model->MaterialGroups()) {
-            std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(model, m_Camera, modelMatrix, matGroup, modelComponent, world));
+            std::shared_ptr<ModelJob> modelJob = std::shared_ptr<ModelJob>(new ModelJob(model, m_Camera, modelMatrix, matGroup, modelComponent, m_World));
             jobs.push_back(modelJob);
         }
     }
 }
 
-
 void RenderSystem::fillPointLights(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
 {
-    auto pointLights = world->GetComponents("PointLight");
+    auto pointLights = m_World->GetComponents("PointLight");
     if (pointLights != nullptr) {
         for (auto& pointlightC : *pointLights) {
             bool visible = pointlightC["Visible"];
@@ -164,98 +118,65 @@ void RenderSystem::fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>&
     }
 }
 
-bool RenderSystem::OnInputCommand(const Events::InputCommand& e)
+
+void RenderSystem::fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
 {
-    if (e.Command == "SwitchCamera" && e.Value > 0) {
-        m_SwitchCamera = true;
-        return true;
-    } else {
-        return false;
+    auto texts = world->GetComponents("Text");
+    if (texts == nullptr) {
+        return;
+    }
+
+    for (auto& textComponent : *texts) {
+        bool visible = textComponent["Visible"];
+        if (!visible) {
+            continue;
+        }
+        std::string resource = textComponent["Resource"];
+        if (resource.empty()) {
+            continue;
+        }
+
+        Font* font;
+        try {
+            font = ResourceManager::Load<Font>(resource);
+        } catch (const std::exception&) {
+            try {
+                font = ResourceManager::Load<Font>("Fonts/DroidSans.ttf,16");
+            } catch (const std::exception&) {
+                continue;
+            }
+        }
+
+        glm::mat4 modelMatrix = Transform::ModelMatrix(textComponent.EntityID, world);
+        std::shared_ptr<TextJob> modelJob = std::shared_ptr<TextJob>(new TextJob(modelMatrix, font, textComponent));
+        jobs.push_back(modelJob);
+
     }
 }
 
-void RenderSystem::Update(World* world, double dt)
+bool RenderSystem::OnInputCommand(const Events::InputCommand& e)
+{
+    return false;
+}
+
+void RenderSystem::Update(double dt)
 {
-    m_World = world;
     m_EventBroker->Process<RenderSystem>();
 
-    updateCamera(world, dt);
-
+    if (m_CurrentCamera) {
+        ComponentWrapper cameraTransform = m_CurrentCamera["Transform"];
+        m_Camera->SetPosition(cameraTransform["Position"]);
+        m_Camera->SetOrientation(glm::quat((const glm::vec3&)cameraTransform["Orientation"]));
+    }
     //Only supports opaque geometry atm
-    m_RenderFrame->Clear();
 
     RenderScene scene;
     scene.Camera = m_Camera;
     scene.Viewport = Rectangle(1280, 720);
-    fillModels(scene.ForwardJobs, world);
-    fillPointLights(scene.PointLightJobs, world);
-    fillDirectionalLights(scene.DirectionalLightJobs, world);
+    fillModels(scene.ForwardJobs);
+    fillPointLights(scene.PointLightJobs, m_World);
+    fillDirectionalLights(scene.DirectionalLightJobs, m_World);
+    fillText(scene.TextJobs, m_World);
     m_RenderFrame->Add(scene);
    
-}
-
-void RenderSystem::updateCamera(World* world, double dt)
-{
-    if (m_SwitchCamera) {
-        auto cameras = world->GetComponents("Camera");
-        if (cameras == nullptr) {
-            return;
-        }
-        for (auto it = cameras->begin(); it != cameras->end(); it++) {
-            if ((*it).EntityID == m_CurrentCamera) {
-                it++;
-                if (it != cameras->end()) {
-                    switchCamera((*it).EntityID);
-                } else {
-                    switchCamera((*cameras->begin()).EntityID);
-                }
-                break;
-            }
-        }
-        if (m_World->HasComponent(m_CurrentCamera, "Camera")) {
-            ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
-            ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
-
-            m_DebugCameraInputController->SetOrientation(glm::quat((glm::vec3)cameraTransform["Orientation"]));
-            m_DebugCameraInputController->SetPosition(cameraTransform["Position"]);
-        }
-    }
-
-    if (m_World->ValidEntity(m_CurrentCamera)) {
-        if (world->HasComponent(m_CurrentCamera, "Camera") && world->HasComponent(m_CurrentCamera, "Transform")) {
-            ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
-            ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
-
-            m_DebugCameraInputController->Update(dt);
-            (glm::vec3&)cameraTransform["Orientation"] = glm::eulerAngles(m_DebugCameraInputController->Orientation());
-            (glm::vec3&)cameraTransform["Position"] = m_DebugCameraInputController->Position();
-
-            glm::vec3 position = Transform::AbsolutePosition(world, m_CurrentCamera);
-            glm::quat orientation = Transform::AbsoluteOrientation(world, m_CurrentCamera);
-
-            m_Camera->SetPosition(position);
-            m_Camera->SetOrientation(orientation);
-
-            updateProjectionMatrix(cameraComponent);
-
-        }
-    } else {
-        m_Camera = m_Camera;
-
-        auto cameras = world->GetComponents("Camera");
-        if (cameras != nullptr) {
-            if (cameras->begin() != cameras->end()) {
-                ComponentWrapper& cameraC = *cameras->begin();
-                switchCamera(cameraC.EntityID);
-
-                ComponentWrapper& cameraComponent = world->GetComponent(m_CurrentCamera, "Camera");
-                ComponentWrapper& cameraTransform = world->GetComponent(m_CurrentCamera, "Transform");
-
-                m_DebugCameraInputController->SetOrientation(glm::quat((glm::vec3)cameraTransform["Orientation"]));
-                m_DebugCameraInputController->SetPosition(cameraTransform["Position"]);
-            }
-        }
-    }
-
-    m_Camera->UpdateViewMatrix();
 }

src/Engine/Rendering/Renderer.cpp

@@ -9,21 +9,15 @@ void Renderer::Initialize()
 	glfwSwapInterval(m_VSYNC);
 	InitializeShaders();
     InitializeTextures();
+    m_TextPass = new TextPass();
+    m_TextPass->Initialize();
+
 
    /* m_ScreenQuad = ResourceManager::Load<Model>("Models/Core/ScreenQuad.obj");
     m_UnitQuad = ResourceManager::Load<Model>("Models/Core/UnitQuad.obj");
     m_UnitSphere = ResourceManager::Load<Model>("Models/Core/UnitSphere.obj");*/
 
     m_ImGuiRenderPass = new ImGuiRenderPass(this, m_EventBroker);
-
-
-    // Create default camera
-    m_DefaultCamera = new ::Camera((float)m_Resolution.Width / m_Resolution.Height, glm::radians(45.f), 0.01f, 5000.f);
-    m_DefaultCamera->SetPosition(glm::vec3(0, 0, 10));
-    if (m_Camera == nullptr) {
-        m_Camera = m_DefaultCamera;
-    }
-
 }
 
 void Renderer::InitializeWindow()
@@ -69,12 +63,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)
@@ -86,28 +74,51 @@ void Renderer::Update(double dt)
 {
     m_EventBroker->Process<Renderer>();
     InputUpdate(dt);
+    m_TextPass->Update();
     m_ImGuiRenderPass->Update(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){
-        m_Camera = scene->Camera; // remove renderer camera when Editor uses the render scene cameras.
+        
         SortRenderJobsByDepth(*scene);
         m_PickingPass->Draw(*scene);
         m_LightCullingPass->GenerateNewFrustum(*scene);
         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_DrawFinalPass->FinalPassFrameBuffer());
+
+    }
+    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();
@@ -119,27 +130,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");
@@ -167,8 +157,10 @@ void Renderer::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filterin
 
 void Renderer::InitializeRenderPasses()
 {
-    m_DrawScenePass = new DrawScenePass(this);
     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);
+}

src/Engine/Rendering/TextPass.cpp

@@ -0,0 +1,113 @@
+#include "Rendering/TextPass.h"
+
+TextPass::TextPass()
+{
+
+}
+
+void TextPass::Initialize()
+{
+    glGenVertexArrays(1, &VAO);
+    glGenBuffers(1, &VBO);
+    glBindVertexArray(VAO);
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6 * 4, NULL, GL_DYNAMIC_DRAW);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), 0);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
+
+    m_TextProgram = ResourceManager::Load<ShaderProgram>("#TextProgram");
+    m_TextProgram->AddShader(std::shared_ptr<Shader>(new VertexShader("Shaders/Text.vert.glsl")));
+    m_TextProgram->AddShader(std::shared_ptr<Shader>(new FragmentShader("Shaders/Text.frag.glsl")));
+    m_TextProgram->Compile();
+    m_TextProgram->BindFragDataLocation(0, "sceneColor");
+    m_TextProgram->BindFragDataLocation(1, "bloomColor");
+    m_TextProgram->Link();
+}
+
+void TextPass::Update()
+{
+
+}
+
+void TextPass::Draw(RenderScene& scene, FrameBuffer& frameBuffer)
+{
+    GLERROR("Derp1");
+    TextPassState* state = new TextPassState(frameBuffer.GetHandle());
+    for (auto &job : scene.TextJobs) {
+        auto textJob = std::dynamic_pointer_cast<TextJob>(job);
+        if (textJob) {
+
+            renderText(textJob->Content, textJob->Resource, textJob->Alignment, textJob->Color, textJob->Matrix, scene.Camera->ProjectionMatrix(), scene.Camera->ViewMatrix());
+        }
+    }
+    GLERROR("Derp2");
+    delete state;
+}
+
+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;
+    GLfloat scale = 1.0/font->FontSize;
+
+    GLfloat stringWidth = 0.f;
+
+    for (std::string::const_iterator c = text.begin(); c != text.end(); c++) {
+        Font::Character ch = font->m_Characters[*c];
+        stringWidth += (ch.Advance >> 6) * scale;
+    }
+
+    if(alignment == TextJob::AlignmentEnum::Center) {
+        penX = -stringWidth/2.f;
+    } else if (alignment == TextJob::AlignmentEnum::Right) {
+        penX = -stringWidth;
+    } else {
+        penX = 0;
+    }	
+    
+    
+
+    m_TextProgram->Bind();
+    glUniform4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "textColor"), 1, glm::value_ptr(color));
+    glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "M"), 1, GL_FALSE, glm::value_ptr(modelMatrix));
+    glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "V"), 1, GL_FALSE, glm::value_ptr(viewMatrix));
+    glUniformMatrix4fv(glGetUniformLocation(m_TextProgram->GetHandle(), "P"), 1, GL_FALSE, glm::value_ptr(projectionMatrix));
+    glActiveTexture(GL_TEXTURE0);
+    glBindVertexArray(VAO);
+
+
+    for (std::string::const_iterator c = text.begin(); c != text.end(); c++) {
+        Font::Character ch = font->m_Characters[*c];
+
+        GLfloat xpos = penX + ch.Bearing.x * scale;
+        GLfloat ypos = penY - (ch.Size.y - ch.Bearing.y) * scale;
+
+        GLfloat w = ch.Size.x * scale;
+        GLfloat h = ch.Size.y * scale;
+
+        GLfloat vertices[6][4] = {
+            { xpos, ypos + h, 0.0, 0.0 },
+            { xpos, ypos, 0.0, 1.0 },
+            { xpos + w, ypos, 1.0, 1.0 },
+
+            { xpos, ypos + h, 0.0, 0.0 },
+            { xpos + w, ypos, 1.0, 1.0 },
+            { xpos + w, ypos + h, 1.0, 0.0 }
+        };
+
+        glBindTexture(GL_TEXTURE_2D, ch.TextureID);
+
+        glBindBuffer(GL_ARRAY_BUFFER, VBO);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        glDrawArrays(GL_TRIANGLES, 0, 6);
+        penX += (ch.Advance >> 6) * scale; // Bitshift by 6 to get value in pixels (2^6 = 64)
+    }
+    glBindVertexArray(0);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    GLERROR("Text rendering Error");
+}
+

src/Engine/Rendering/TextPassState.cpp

@@ -0,0 +1,16 @@
+#include "Rendering/TextPassState.h"
+
+
+TextPassState::TextPassState(GLuint frameBuffer)
+{
+    BindFramebuffer(frameBuffer);
+    glEnable(GL_BLEND);
+    glDisable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+TextPassState::~TextPassState()
+{
+
+}

src/Engine/Rendering/Util/CommonFunctions.cpp

@@ -0,0 +1,2 @@
+#include "Rendering/Util/CommonFunctions.h"
+