Merge branch 'master' into BoxModelCollision

src/Engine/CMakeLists.txt

@@ -8,6 +8,7 @@ find_package(assimp REQUIRED)
 find_package(ZLIB REQUIRED)
 find_package(PNG REQUIRED)
 find_package(Xerces REQUIRED)
+find_package(Freetype REQUIRED)
 # Because FindOpenAL is retarded
 set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${CMAKE_SOURCE_DIR}/deps/include/OpenAL")
 find_package(OpenAL REQUIRED)
@@ -25,6 +26,7 @@ include_directories(
     ${assimp_INCLUDE_DIRS}
     ${PNG_INCLUDE_DIRS}
     ${Xerces_INCLUDE_DIRS}
+    ${FREETYPE_INCLUDE_DIRS}
     ${OPENAL_INCLUDE_DIR}
     ${X11_INCLUDE_DIRS}
 )
@@ -126,6 +128,7 @@ set(LIBRARIES
     ${assimp_LIBRARIES}
     ${PNG_LIBRARIES}
     ${Xerces_LIBRARIES}
+    ${FREETYPE_LIBRARIES}
     ${OPENAL_LIBRARY}
     ${X11_LIBRARIES}
 )

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();
 }
 
@@ -26,7 +48,7 @@ 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();
@@ -51,13 +73,20 @@ void DrawFinalPass::Draw(RenderScene& scene)
             glUniformMatrix4fv(glGetUniformLocation(shaderHandle, "M"), 1, GL_FALSE, glm::value_ptr(modelJob->Matrix));
             glUniform4fv(glGetUniformLocation(shaderHandle, "Color"), 1, glm::value_ptr(modelJob->Color));
 
+            glActiveTexture(GL_TEXTURE0);
             if(modelJob->DiffuseTexture != nullptr) {
-                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, modelJob->DiffuseTexture->m_Texture);
             } else {
-                glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, m_WhiteTexture->m_Texture);
             }
+            glActiveTexture(GL_TEXTURE1);
+            glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+
+            /*if(modelJob->GlowMap != nullptr) {
+                glBindTexture(GL_TEXTURE_2D, modelJob->GlowMap->m_Texture);
+            } else {
+                glBindTexture(GL_TEXTURE_2D, m_BlackTexture->m_Texture);
+            }*/
 
             glBindVertexArray(modelJob->Model->VAO);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
@@ -66,6 +95,42 @@ void DrawFinalPass::Draw(RenderScene& scene)
             continue;
         }
     }
+    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,14 +1,14 @@
 #include "Rendering/DrawFinalPassState.h"
 
 
-DrawFinalPassState::DrawFinalPassState()
+DrawFinalPassState::DrawFinalPassState(GLuint frameBuffer)
 {
-    BindFramebuffer(0);
+    BindFramebuffer(frameBuffer);
     Enable(GL_BLEND);
     BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     Enable(GL_DEPTH_TEST);
     Enable(GL_CULL_FACE);
-    ClearColor(glm::vec4(200.f / 255, 0.f / 255, 200.f / 255, 0.f));
+    ClearColor(glm::vec4(0.f, 0.f, 0.f, 0.f));
 }
 
 DrawFinalPassState::~DrawFinalPassState()

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/PickingPass.cpp

@@ -46,62 +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/RenderSystem.cpp

@@ -110,6 +110,42 @@ void RenderSystem::fillDirectionalLights(std::list<std::shared_ptr<RenderJob>>&
     }
 }
 
+
+void RenderSystem::fillText(std::list<std::shared_ptr<RenderJob>>& jobs, World* world)
+{
+    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);
+
+    }
+}
+
 bool RenderSystem::OnInputCommand(const Events::InputCommand& e)
 {
     return false;
@@ -132,6 +168,7 @@ void RenderSystem::Update(double dt)
     fillModels(scene.ForwardJobs);
     fillPointLights(scene.PointLightJobs, m_World);
     fillDirectionalLights(scene.DirectionalLightJobs, m_World);
+    fillText(scene.TextJobs, m_World);
     m_RenderFrame->Add(scene);
    
 }

src/Engine/Rendering/Renderer.cpp

@@ -9,6 +9,9 @@ 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");
@@ -60,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)
@@ -77,15 +74,22 @@ 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){
         
         SortRenderJobsByDepth(*scene);
@@ -94,9 +98,27 @@ void Renderer::Draw(RenderFrame& frame)
         m_LightCullingPass->FillLightList(*scene);
         m_LightCullingPass->CullLights(*scene);
         m_DrawFinalPass->Draw(*scene);
-        //m_DrawScenePass->Draw(rq);
 
         GLERROR("Renderer::Draw m_DrawScenePass->Draw");
+
+        m_TextPass->Draw(*scene, *m_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();
@@ -108,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");
@@ -159,4 +160,7 @@ void Renderer::InitializeRenderPasses()
     m_PickingPass = new PickingPass(this, m_EventBroker);
     m_LightCullingPass = new LightCullingPass(this);
     m_DrawFinalPass = new DrawFinalPass(this, m_LightCullingPass);
+    m_DrawScreenQuadPass = new DrawScreenQuadPass(this);
+    m_DrawBloomPass = new DrawBloomPass(this);
+    m_DrawColorCorrectionPass = new DrawColorCorrectionPass(this);
 }

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"
+