deferred pipeline now handles 2D mesh as gui objects

src/deferredpipeline.cpp

@@ -86,6 +86,9 @@ DeferredPipeline::DeferredPipeline() :
     m_lightingSource = new ShaderSource();
     m_lightingSource->setSource(shaderMap["shaders/lighting.vert.glsl"], ShaderSource::VERTEX);
     m_lightingSource->setSource(shaderMap["shaders/lighting.frag.glsl"], ShaderSource::FRAGMENT);
+    m_mesh2DSource = new ShaderSource();
+    m_mesh2DSource->setSource(shaderMap["shaders/gui.vert.glsl"], ShaderSource::VERTEX);
+    m_mesh2DSource->setSource(shaderMap["shaders/gui.frag.glsl"], ShaderSource::FRAGMENT);
     std::string vertSource = shaderMap["shaders/posteffects.vert.glsl"];
     std::string fragSource = shaderMap["shaders/posteffects.frag.glsl"];
     m_postEffectsShader = new Shader(vertSource, fragSource);
@@ -95,8 +98,9 @@ void DeferredPipeline::renderGL(Scene *scene)
 {
     if(m_renderTarget == NULL)
         return;
-    
+
     // GEOMETRY PASS
+    std::vector<GeometryNode*> mesh2D;
     m_gBuffer->bindFBO();
     glEnable(GL_DEPTH_TEST);
     glDepthFunc(GL_LESS);
@@ -109,12 +113,17 @@ void DeferredPipeline::renderGL(Scene *scene)
     for(SceneIterator<GeometryNode*>* geometryIt = scene->getGeometry();
         geometryIt->isValid(); geometryIt->next())
     {
-        
         GeometryNode* node = geometryIt->getItem();
-        Shader *shader = m_meshShaders[node->mesh->getFlags()];
+        unsigned int type = node->mesh->getFlags();
+        if(type & (1 << Mesh::MESH_2D))
+        {
+            mesh2D.push_back(node);
+            continue;
+        }
+        Shader *shader = m_mesh3DShaders[node->mesh->getFlags()];
         if(shader == NULL)
         {
-            fprintf(stderr, "no shader to render this geometry, please use refreshScene to generate the shader\n");
+            fprintf(stderr, "no shader to render this 3D geometry, please call refreshScene to generate the shader\n");
             continue;
         }
         shader->bind();
@@ -148,7 +157,7 @@ void DeferredPipeline::renderGL(Scene *scene)
         Shader *shader = m_lightShaders[light->getFlags()];
         if(shader == NULL)
         {
-            fprintf(stderr, "no shader to render this light, please use refreshScene to generate the shader\n");
+            fprintf(stderr, "no shader to render this light, please call refreshScene to generate the shader\n");
             continue;
         }
         shader->bind();
@@ -168,15 +177,32 @@ void DeferredPipeline::renderGL(Scene *scene)
     }
     m_gBuffer->unbindTextures();
     
-    // post effects pass
+    // POST EFFECTS PASS
     m_renderTarget->bindFBO();
     glDisable(GL_BLEND);
     m_lightingBuffer->getTexture(0)->bind(0);
     m_postEffectsShader->bind();
     m_postEffectsShader->bindInteger(m_postEffectsShader->getLocation("lightBuffer"), 0);
-    // TODO : send uniforms
     SparrowRenderer::drawQuad();
     m_lightingBuffer->getTexture(0)->unbind();
+
+    // 2D GUI PASS
+    glClear(GL_DEPTH_BUFFER_BIT);
+    for(GeometryNode* node : mesh2D)
+    {
+        Shader *shader = m_mesh2DShaders[node->mesh->getFlags()];
+        if(shader == NULL)
+        {
+            fprintf(stderr, "no shader to render this 2D geometry, please call refreshScene to generate the shader\n");
+            continue;
+        }
+        shader->bind();
+
+        shader->bindMat4(shader->getLocation("orthoMatrix"), m_orthoMatrix);
+        shader->bindMat4(shader->getLocation("transformMatrix"), node->modelMatrix);
+        // draw geometry
+        node->mesh->draw(shader);
+    }
 }
 
 void DeferredPipeline::resizeGL(int w, int h)
@@ -193,9 +219,10 @@ void DeferredPipeline::resizeGL(int w, int h)
     }
     m_gBuffer = new GBuffer(w, h);
     m_lightingBuffer = new LightingBuffer(w, h);
+    m_orthoMatrix = glm::ortho(0.f, float(m_width), float(m_height), 0.f);
 }
 
-void DeferredPipeline::setSources(ShaderSource *gBufferSource, ShaderSource *lightingSource, Shader *postEffectsShader)
+void DeferredPipeline::setSources(ShaderSource *gBufferSource, ShaderSource *lightingSource, ShaderSource *guiSource, Shader *postEffectsShader)
 {
     if(m_gBufferSource != NULL)
         delete m_gBufferSource;
@@ -203,6 +230,9 @@ void DeferredPipeline::setSources(ShaderSource *gBufferSource, ShaderSource *lig
     if(m_lightingSource != NULL)
         delete m_lightingSource;
     m_lightingSource = lightingSource;
+    if(m_mesh2DSource != NULL)
+        delete m_mesh2DSource;
+    m_mesh2DSource = guiSource;
     if(m_postEffectsShader != NULL)
         delete m_postEffectsShader;
     m_postEffectsShader = postEffectsShader;
@@ -210,13 +240,18 @@ void DeferredPipeline::setSources(ShaderSource *gBufferSource, ShaderSource *lig
 
 void DeferredPipeline::refreshScene(Scene *scene)
 {
-    for(auto it : m_meshShaders)
+    for(auto it : m_mesh3DShaders)
         delete it.second;
-    m_meshShaders.clear();
+    m_mesh3DShaders.clear();
     m_meshTypes.clear();
     scene->getMeshTypes(m_meshTypes);
     for(unsigned int type : m_meshTypes)
-        m_meshShaders[type] = m_gBufferSource->compile(type, 0);
+    {
+        if(type & (1 << Mesh::MESH_2D))
+            m_mesh2DShaders[type] = m_mesh2DSource->compile(type, 0);
+        else
+            m_mesh3DShaders[type] = m_gBufferSource->compile(type, 0);
+    }
     
     for(auto it : m_lightShaders)
         delete it.second;

src/deferredpipeline.h

@@ -4,6 +4,7 @@
 #include "pipeline.h"
 #include "framebuffer.h"
 #include <unordered_map>
+#include <glm/mat4x4.hpp>
 
 class Shader;
 class Camera;
@@ -30,16 +31,20 @@ class DeferredPipeline : public Pipeline
     int m_width;
     int m_height;
     
+    glm::mat4 m_orthoMatrix;
+
     // shaders
     std::vector<unsigned int> m_meshTypes;
     std::vector<unsigned int> m_lightTypes;
     
-    std::unordered_map<unsigned int, Shader*> m_meshShaders;
+    std::unordered_map<unsigned int, Shader*> m_mesh3DShaders;
     std::unordered_map<unsigned int, Shader*> m_lightShaders;
+    std::unordered_map<unsigned int, Shader*> m_mesh2DShaders;
     
     ShaderSource *m_gBufferSource;
     ShaderSource *m_lightingSource;
-    Shader *m_postEffectsShader;
+    ShaderSource *m_mesh2DSource;
+    Shader *m_postEffectsShader; // TODELETE
     
     // framebuffers
     GBuffer *m_gBuffer;
@@ -50,7 +55,7 @@ public:
     DeferredPipeline();
     
     void setCamera(Camera *camera) { m_camera = camera; }
-    void setSources(ShaderSource *gBufferSource, ShaderSource *lightingSource, Shader *postEffectsShader);
+    void setSources(ShaderSource *gBufferSource, ShaderSource *lightingSource, ShaderSource *guiSource, Shader *postEffectsShader);
     void setRenderTarget(const FrameBuffer *fbo) { m_renderTarget = fbo; }
     void refreshScene(Scene *scene);