initial commit

HydraEngine/source/pipeline/HydraDeferredPipeline.cpp

@@ -0,0 +1,270 @@
+#include "HydraDeferredPipeline.h"
+#include "HydraRenderStage.h"
+#include "../engine/HydraEngine.h"
+#include "../buffer/HydraBufferManager.h"
+#include "../buffer/HydraTextureBufferManager.h"
+#include "../buffer/HydraLightBufferManager.h"
+#include "PerFrameUBO.hpp"
+
+#include "../camera/HydraCamera.h"
+#include "../renderer/HydraRenderer.h"
+#include "../ecs/HydraECS.h"
+#include "../ecs/systems/HydraRenderSystem.h"
+#include "../mesh/StandardVertex.h"
+#include "../actor/HydraActorManager.h"
+#include "../actor/HydraOutputActor.h"
+
+void HydraDeferredPipeline::Initialise()
+{
+    
+    _CreateUBOs();
+    //already on the render thread so dont neet another job
+    _CreateOutputActor();
+    _CreateFrameBuffer();
+    _CreateColourRenderStage();
+    _CreateOutputRenderStage();    
+}
+
+void HydraDeferredPipeline::Shutdown()
+{
+    for(uint32_t rs_idx =0; rs_idx <m_render_stages.size(); rs_idx++)
+    {
+        m_render_stages[rs_idx]->ShutDown();
+        delete m_render_stages[rs_idx];
+    }
+    glDeleteFramebuffers(1, &m_frame_buffer_id);
+}
+
+void HydraDeferredPipeline::Render()
+{
+    _UpdateUBO();
+    
+    glBindFramebuffer(GL_FRAMEBUFFER, m_frame_buffer_id);
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // we're not using the stencil buffer now
+    glEnable(GL_DEPTH_TEST);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    HydraECS* ecs = GetEngine()->ECS();
+    std::shared_ptr<HydraRenderSystem> render_system = ecs->GetSystem<HydraRenderSystem>();
+    
+    GetEngine()->Renderer()->BeginFrame();
+    
+    for(uint32_t rs_idx = 0; rs_idx <m_render_stages.size(); rs_idx++)
+    {
+        m_render_stages[rs_idx]->Render(render_system->Entities);
+    }
+    GetEngine()->Renderer()->EndFrame();
+}
+
+void HydraDeferredPipeline::_UpdateUBO()
+{
+    HydraCamera* camera = GetEngine()->Camera();
+    PerFrameUBO ubo = {};
+    
+    uint32_t light_count = GetEngine()->GetLightCount();
+
+    ubo.view = camera->GetView();
+    ubo.proj = camera->GetProjection();
+    ubo.viewer_pos = camera->GetPosition();
+    ubo.light_count = light_count;
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+    buffer_manager->UpdateWholeBuffer(m_per_frame_ubo, &ubo);
+    glBindBuffer(GL_UNIFORM_BUFFER, m_per_frame_ubo);
+
+    PerFrameUBO output_ubo = {};
+    output_ubo.view = glm::mat4(1);
+    output_ubo.proj = glm::ortho(-0.5f, 0.5f, -0.5f, 0.5f);
+    output_ubo.viewer_pos = camera->GetPosition();
+    output_ubo.light_count = light_count;
+    buffer_manager->UpdateWholeBuffer(m_per_frame_output_ubo, &output_ubo);
+    glBindBuffer(GL_UNIFORM_BUFFER, m_per_frame_output_ubo);
+}
+
+void HydraDeferredPipeline::_CreateFrameBuffer()
+{
+    HydraEngine* engine = GetEngine();
+    HydraTextureBufferManager* tex_buffer_manager = engine->TextureBufferManager();
+    HydraRenderSettings render_settings = engine->RenderSettings();
+     glGenFramebuffers(1, &m_frame_buffer_id);
+     glBindFramebuffer(GL_FRAMEBUFFER, m_frame_buffer_id);  
+
+    HydraOutputActor* actor = static_cast<HydraOutputActor*>(GetEngine()->ActorManager()->GetActor(m_output_actor_id));
+
+    HydraTextureBuffer depth_texture = tex_buffer_manager->GetTexture(actor->texture_buffers[0]);
+    HydraTextureBuffer buffer_0_texture = tex_buffer_manager->GetTexture(actor->texture_buffers[1]);
+    HydraTextureBuffer metal_rough_texture = tex_buffer_manager->GetTexture(actor->texture_buffers[2]);
+    HydraTextureBuffer normal_texture = tex_buffer_manager->GetTexture(actor->texture_buffers[3]);
+    HydraTextureBuffer position_texture = tex_buffer_manager->GetTexture(actor->texture_buffers[4]);
+
+    glBindTexture(GL_TEXTURE_2D, buffer_0_texture.gl_tex_id);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer_0_texture.gl_tex_id, 0);
+
+    glBindTexture(GL_TEXTURE_2D, metal_rough_texture.gl_tex_id);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, metal_rough_texture.gl_tex_id, 0);
+
+    glBindTexture(GL_TEXTURE_2D, normal_texture.gl_tex_id);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, normal_texture.gl_tex_id, 0);
+
+    glBindTexture(GL_TEXTURE_2D, position_texture.gl_tex_id);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT3, GL_TEXTURE_2D, position_texture.gl_tex_id, 0);
+
+    glBindTexture(GL_TEXTURE_2D, depth_texture.gl_tex_id);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth_texture.gl_tex_id, 0);
+
+    GLenum draw_buffers[4] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3};
+
+    glDrawBuffers(4, draw_buffers);
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    tex_buffer_manager->BindTexture(depth_texture.texture_id);
+    tex_buffer_manager->BindTexture(buffer_0_texture.texture_id);
+    tex_buffer_manager->BindTexture(metal_rough_texture.texture_id);
+    tex_buffer_manager->BindTexture(normal_texture.texture_id);
+    tex_buffer_manager->BindTexture(position_texture.texture_id);
+
+
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+    buffer_manager->UpdateWholeBuffer(m_output_texture_ubo, &actor->texture_buffers[0]);
+    glBindBuffer(GL_UNIFORM_BUFFER, m_output_texture_ubo);
+}
+
+void HydraDeferredPipeline::_CreateColourRenderStage()
+{
+    HydraRenderStage* render_stage = new HydraRenderStage();
+    std::string shader_path = std::string(shader_base);
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+
+    HydraID pos_buffer_id = buffer_manager->FindBuffer("PositionsBuffer");
+    HydraID mat_buffer_id = buffer_manager->FindBuffer("MaterialBuffer");
+    HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
+    HydraID per_frame_buffer_id = buffer_manager->FindBuffer("DeferredPerFrameUBO");
+
+    HydraShaderBinding shader_binding = {};
+    
+    shader_binding.block_name.push_back("PositionsBuffer");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(pos_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("MaterialBuffer");
+    shader_binding.binding_point.push_back(2);
+    shader_binding.buffer_id.push_back(mat_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("TextureBuffer");
+    shader_binding.binding_point.push_back(3);
+    shader_binding.buffer_id.push_back(tex_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("uniform_per_frame");
+    shader_binding.binding_point.push_back(0);
+    shader_binding.buffer_id.push_back(per_frame_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+    std::vector<uint32_t> textures;
+
+
+
+    render_stage->Initialise(shader_path + "deferred_shader.vert", 
+        shader_path + "deferred_shader.frag", 
+        shader_binding, 
+        m_frame_buffer_id,
+        textures,
+        true,
+        HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
+    m_render_stages.push_back(render_stage);
+}
+
+
+void HydraDeferredPipeline::_CreateOutputRenderStage()
+{
+     HydraRenderStage* render_stage = new HydraRenderStage();
+    std::string shader_path = std::string(shader_base);
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+
+    std::vector<uint32_t> textures;
+
+    GetEngine()->ActorManager()->InitialiseActor(m_output_actor_id);
+    HydraOutputActor* actor = static_cast<HydraOutputActor*>(GetEngine()->ActorManager()->GetActor(m_output_actor_id));
+
+    HydraTextureBufferManager* tex_buf_manager = GetEngine()->TextureBufferManager();
+
+    HydraID pos_buffer_id = buffer_manager->FindBuffer("PositionsBuffer");
+    HydraID per_frame_buffer_id = buffer_manager->FindBuffer("DeferredOutputPerFrameUBO");
+    HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
+    HydraID output_texture_buffer_id = buffer_manager->FindBuffer("DeferredOutputTextureUBO");
+    HydraID light_buffer_id = buffer_manager->FindBuffer("LightBuffer");
+
+    HydraShaderBinding shader_binding = {};
+    shader_binding.block_name.push_back("PositionsBuffer");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(pos_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+
+    shader_binding.block_name.push_back("TextureBuffer");
+    shader_binding.binding_point.push_back(3);
+    shader_binding.buffer_id.push_back(tex_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    shader_binding.block_name.push_back("uniform_per_frame");
+    shader_binding.binding_point.push_back(0);
+    shader_binding.buffer_id.push_back(per_frame_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+        
+    shader_binding.block_name.push_back("uniform_output_textures");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(output_texture_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+
+    shader_binding.block_name.push_back("LightBuffer");
+    shader_binding.binding_point.push_back(4);
+    shader_binding.buffer_id.push_back(light_buffer_id);
+    shader_binding.buffer_type.push_back(HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+
+    
+    render_stage->Initialise(shader_path + "deferred_output_shader.vert", 
+        shader_path + "deferred_output_shader.frag", 
+        shader_binding, 
+        0,
+        textures,
+        false,     
+        HYDRA_RENDERABLE_TYPE::HYDRA_OUTPUT);
+    m_render_stages.push_back(render_stage);
+}
+
+void HydraDeferredPipeline::_CreateOutputActor()
+{
+    m_output_actor_id = GetEngine()->ActorManager()->CreateActor<HydraOutputActor>();
+    GetEngine()->ActorManager()->InitialiseActor(m_output_actor_id);
+    HydraOutputActor* actor = static_cast<HydraOutputActor*>(GetEngine()->ActorManager()->GetActor(m_output_actor_id));
+
+
+}
+
+void HydraDeferredPipeline::_CreateUBOs()
+{
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+
+    m_per_frame_ubo = buffer_manager->CreateGPUBuffer("DeferredPerFrameUBO", 
+    sizeof(PerFrameUBO), 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+    
+    m_per_frame_output_ubo = buffer_manager->CreateGPUBuffer("DeferredOutputPerFrameUBO", 
+    sizeof(PerFrameUBO), 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+
+    m_output_texture_ubo = buffer_manager->CreateGPUBuffer("DeferredOutputTextureUBO", 
+    sizeof(uint32_t)*16, 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+
+
+}
+

HydraEngine/source/pipeline/HydraDeferredPipeline.h

@@ -0,0 +1,41 @@
+#ifndef HYDRADEFERREDPIPELINE
+#define HYDRADEFERREDPIPELINE
+
+#include "../engine/HydraObject.h"
+#include "../windowmanager/HydraRenderSettings.h"
+#include "HydraPipeline.h"
+#include "HydraRenderStage.h"
+
+#include <vector>
+
+class HydraRenderStage;
+
+class HydraDeferredPipeline : public HydraPipeline
+{
+    public:        
+        virtual void Initialise() override;
+        virtual void Shutdown() override;
+        virtual void Render() override;
+    private:
+        HydraID m_per_frame_ubo = INVALID_HYDRA_ID;
+        HydraID m_per_frame_output_ubo = INVALID_HYDRA_ID;
+        
+        HydraID m_material_buffer = INVALID_HYDRA_ID;
+        HydraID m_buffer_0 = INVALID_HYDRA_ID; //Frame buffer 0;
+        HydraID m_depth = INVALID_HYDRA_ID;
+        HydraID m_output_actor_id = INVALID_HYDRA_ID;
+        HydraID m_output_texture_ubo = INVALID_HYDRA_ID;
+        HydraID m_output_light_ubo = INVALID_HYDRA_ID;
+
+        uint32_t m_frame_buffer_id;
+
+        void _UpdateUBO();
+        void _CreateFrameBuffer();
+        
+        void _CreateColourRenderStage();
+        void _CreateOutputRenderStage();
+        void _CreateOutputActor();
+        void _CreateUBOs();
+};
+
+#endif /* HYDRADEFERREDPIPELINE */

HydraEngine/source/pipeline/HydraForwardPipeline.cpp

@@ -0,0 +1,101 @@
+#include "HydraForwardPipeline.h"
+#include "HydraRenderStage.h"
+#include "../engine/HydraEngine.h"
+#include "../buffer/HydraBufferManager.h"
+#include "PerFrameUBO.hpp"
+#include "../camera/HydraCamera.h"
+#include "../renderer/HydraRenderer.h"
+#include "../ecs/HydraECS.h"
+#include "../ecs/systems/HydraRenderSystem.h"
+#include "../mesh/StandardVertex.h"
+
+void HydraForwardPipeline::Initialise()
+{
+    _EnableVertexAttributes();
+    HydraRenderStage* render_stage = new HydraRenderStage();
+    std::string shader_path = std::string(shader_base);
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+
+    HydraID pos_buffer_id = buffer_manager->FindBuffer("PositionsBuffer");
+    HydraID mat_buffer_id = buffer_manager->FindBuffer("MaterialBuffer");
+    HydraID tex_buffer_id = buffer_manager->FindBuffer("TextureBuffer");
+
+    HydraShaderBinding shader_binding = {};
+    
+    shader_binding.block_name.push_back("PositionsBuffer");
+    shader_binding.binding_point.push_back(1);
+    shader_binding.buffer_id.push_back(pos_buffer_id);
+
+    shader_binding.block_name.push_back("MaterialBuffer");
+    shader_binding.binding_point.push_back(2);
+    shader_binding.buffer_id.push_back(mat_buffer_id);
+
+    shader_binding.block_name.push_back("TextureBuffer");
+    shader_binding.binding_point.push_back(3);
+    shader_binding.buffer_id.push_back(tex_buffer_id);
+    std::vector<uint32_t> textures;
+    std::vector<uint32_t> rb_attachments;
+    
+    
+    
+    render_stage->Initialise(shader_path + "forward_shader.vert", shader_path + "forward_shader.frag", shader_binding, 0, textures, true, HYDRA_RENDERABLE_TYPE::HYDRA_COLOUR);
+    m_render_stages.push_back(render_stage);
+
+
+    m_per_frame_ubo = buffer_manager->CreateGPUBuffer("PerFrameUBO", 
+        sizeof(PerFrameUBO), 0, HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER);
+    
+}
+
+void HydraForwardPipeline::Shutdown()
+{
+    for(uint32_t rs_idx =0; rs_idx <m_render_stages.size(); rs_idx++)
+    {
+        m_render_stages[rs_idx]->ShutDown();
+        delete m_render_stages[rs_idx];
+    }
+}
+
+void HydraForwardPipeline::Render()
+{
+    _UpdateUBO();
+    
+    HydraECS* ecs = GetEngine()->ECS();
+    std::shared_ptr<HydraRenderSystem> render_system = ecs->GetSystem<HydraRenderSystem>();
+    
+    GetEngine()->Renderer()->BeginFrame();
+    
+    for(uint32_t rs_idx = 0; rs_idx <m_render_stages.size(); rs_idx++)
+    {
+        m_render_stages[rs_idx]->Render(render_system->Entities);
+    }
+    GetEngine()->Renderer()->EndFrame();
+}
+
+void HydraForwardPipeline::_UpdateUBO()
+{
+    HydraCamera* camera = GetEngine()->Camera();
+    PerFrameUBO ubo = {};
+
+    ubo.view = camera->GetView();
+    ubo.proj = camera->GetProjection();
+
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+    buffer_manager->UpdateWholeBuffer(m_per_frame_ubo, &ubo);
+    glBindBuffer(GL_UNIFORM_BUFFER, m_per_frame_ubo);
+}
+
+void HydraForwardPipeline::_EnableVertexAttributes()
+{
+
+        //already on the render thread so dont neet another job
+    // position
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(StandardVertex), (void *)0);
+    glEnableVertexAttribArray(0);
+    // texcoord01
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(StandardVertex), (void *)(3 * sizeof(float)));
+    glEnableVertexAttribArray(1);
+    // chunkID
+    glVertexAttribIPointer(2, 3, GL_UNSIGNED_INT, sizeof(StandardVertex), (void *)(5 * sizeof(float)));
+    glEnableVertexAttribArray(2);
+}

HydraEngine/source/pipeline/HydraForwardPipeline.h

@@ -0,0 +1,28 @@
+#ifndef HYDRAFORWARDPIPELINE
+#define HYDRAFORWARDPIPELINE
+#include "../engine/HydraObject.h"
+#include "../windowmanager/HydraRenderSettings.h"
+#include "HydraPipeline.h"
+#include "HydraRenderStage.h"
+
+#include <vector>
+
+class HydraRenderStage;
+
+class HydraForwardPipeline : public HydraPipeline
+{
+    public:        
+        virtual void Initialise() override;
+        virtual void Shutdown() override;
+        virtual void Render() override;
+    private:
+        HydraID m_per_frame_ubo = INVALID_HYDRA_ID;
+        HydraID m_texture_buffer = INVALID_HYDRA_ID;
+        HydraID m_material_buffer = INVALID_HYDRA_ID;
+        void _UpdateUBO();
+        void _EnableVertexAttributes();
+
+};
+
+
+#endif /* HYDRAFORWARDPIPELINE */

HydraEngine/source/pipeline/HydraFrameBuffer.hpp

@@ -0,0 +1,14 @@
+#ifndef HYDRAFRAMEBUFFER
+#define HYDRAFRAMEBUFFER
+
+#include "../engine/HydraObject.h"
+#include "../buffer/HydraTexureBuffer.h"
+#include <vector>
+
+struct HydraFrameBuffer
+{
+    std::vector<HydraID> colour_attachements;
+    HydraID depth_attachment;
+};
+
+#endif /* HYDRAFRAMEBUFFER */

HydraEngine/source/pipeline/HydraPipeline.h

@@ -0,0 +1,20 @@
+#ifndef HYDRAPIPELINE
+#define HYDRAPIPELINE
+#include "../engine/HydraObject.h"
+#include "../windowmanager/HydraRenderSettings.h"
+#include <vector>
+
+class HydraRenderStage;
+
+class HydraPipeline : public HydraObject
+{
+    public:        
+        virtual void Initialise() = 0;
+        virtual void Shutdown() = 0;    
+        virtual void Render() = 0;
+    protected:
+        std::vector<HydraRenderStage*> m_render_stages;
+};
+
+
+#endif /* HYDRAPIPELINE */

HydraEngine/source/pipeline/HydraRenderStage.cpp

@@ -0,0 +1,163 @@
+#include "HydraRenderStage.h"
+#include "../ecs/HydraECS.h"
+#include "../ecs/components/HydraMeshComponent.h"
+#include "../ecs/components/HydraRenderableComponent.h"
+
+#include "../engine/HydraEngine.h"
+#include "../buffer/HydraVertexBufferManager.h"
+#include "../buffer/HydraBufferManager.h"
+#include <set>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <GLMIncludes.h>
+
+void HydraRenderStage::Initialise(std::string vertex_shader_file, 
+    std::string fragment_shader_file, 
+    HydraShaderBinding shader_binding,
+    uint32_t framebuffer_id,
+    std::vector<uint32_t> textures, 
+    bool enable_culling,   
+    HYDRA_RENDERABLE_TYPE renderable_type)
+{
+    m_framebuffer_id = framebuffer_id;
+    m_renderable_type = static_cast<uint32_t>(renderable_type);
+    m_shader_binding = shader_binding;
+    m_textures = textures;
+    m_cull = enable_culling;
+
+    if(vertex_shader_file.length() > 0)
+    {
+        m_vertex_shader = _LoadShader(vertex_shader_file, GL_VERTEX_SHADER);        
+    }
+    if(fragment_shader_file.length() > 0)
+    {
+        m_fragment_shader = _LoadShader(fragment_shader_file, GL_FRAGMENT_SHADER);
+    }
+    m_program = glCreateProgram();
+    glAttachShader(m_program, m_vertex_shader);
+    glAttachShader(m_program, m_fragment_shader);
+    glLinkProgram(m_program);
+
+    
+}
+
+void HydraRenderStage::ShutDown()
+{
+    glDeleteShader(m_vertex_shader);
+    glDeleteShader(m_fragment_shader);
+    glDeleteProgram(m_program);
+}
+
+void HydraRenderStage::Render(std::set<HydraID>& entities)
+{
+    HydraECS* ecs = GetEngine()->ECS();
+
+    glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer_id);
+    //glDrawBuffers(m_rb_attachments.size(), &m_rb_attachments[0]);
+    HydraVertexBufferManager* vert_buffer_mananger = GetEngine()->VertexBufferManager();
+    glUseProgram(m_program);
+    _BindBuffers();
+    _BindTextures();
+    HydraSignature signature = {};
+    signature.set(m_renderable_type, true);
+    
+    if(m_cull)
+    {
+        glEnable(GL_CULL_FACE);
+    }
+    else
+    {
+        glDisable(GL_CULL_FACE);
+    }
+
+    for(const auto& entity_id : entities )
+    {
+        HydraRenderableComponent render_comp = ecs->GetComponent<HydraRenderableComponent>(entity_id);
+        if((render_comp.renderable_types & signature) == signature)
+        {
+            HydraMeshComponent mesh_comp = ecs->GetComponent<HydraMeshComponent>(entity_id);
+            
+            HydraVertexBuffer& vertex_buffer = vert_buffer_mananger->GetVertexBuffer(mesh_comp.vertex_buffer_id);
+
+            glBindVertexArray(vertex_buffer.vao);            
+            glDrawElements(GL_TRIANGLES, vertex_buffer.triangle_count, GL_UNSIGNED_INT, (void*)0 );
+            glBindVertexArray(0);
+        }
+    }
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+}
+
+uint32_t HydraRenderStage::_LoadShader(std::string filename, uint32_t shader_type)
+{ 
+
+    std::string shader_source = _LoadShaderSource(filename);
+    const char* src = shader_source.c_str();
+    GLuint shader = glCreateShader(shader_type);
+    int length = shader_source.length();
+    int success;
+    char infoLog[512];
+
+    glShaderSource(shader, 1, &src, &length);
+    glCompileShader(shader);
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+    if(!success)
+    {
+        glGetShaderInfoLog(shader, 512, NULL, infoLog);
+        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
+    };
+
+    return shader;
+}
+
+std::string HydraRenderStage::_LoadShaderSource(std::string filename)
+{    
+    std::ifstream file(filename);
+    if (!file.is_open()) {
+        std::cerr << "Failed to open shader file: " << filename << std::endl;
+        return "";
+    }
+    std::stringstream buffer;
+    buffer << file.rdbuf();
+    return buffer.str();
+
+}
+
+void HydraRenderStage::_BindBuffers()
+{
+    HydraBufferManager* buffer_manager = GetEngine()->BufferManager();
+
+    for(uint32_t bind_idx = 0; bind_idx <m_shader_binding.block_name.size(); bind_idx++)
+    {
+        HydraBuffer buffer = buffer_manager->GetBuffer(m_shader_binding.buffer_id[bind_idx]);
+        
+        switch(m_shader_binding.buffer_type[bind_idx])
+        {
+            case HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER:
+            {                
+                glBindBufferBase(GL_SHADER_STORAGE_BUFFER, m_shader_binding.binding_point[bind_idx], buffer.gpu_buffer_id);
+                break;
+            }
+            case HYDRA_BUFFER_TYPE::HYDRA_UBO_BUFFER:
+            {
+                glBindBufferBase(GL_UNIFORM_BUFFER, m_shader_binding.binding_point[bind_idx], buffer.gpu_buffer_id);
+                break;
+            }
+        }
+        
+
+    }
+    
+}
+
+void HydraRenderStage::_BindTextures()
+{
+    uint32_t active_texture = 0;
+    for(auto texture:m_textures)
+    {
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glActiveTexture(GL_TEXTURE0 + active_texture);
+        glBindTexture(GL_TEXTURE_2D, 0);
+        active_texture++;
+    }
+}

HydraEngine/source/pipeline/HydraRenderStage.h

@@ -0,0 +1,38 @@
+#ifndef HYDRARENDERSTAGE
+#define HYDRARENDERSTAGE
+
+#include "../engine/HydraObject.h"
+#include "../windowmanager/HydraRenderSettings.h"
+#include "HydraShaderBinding.hpp"
+#include "../GlewIncludes.h"
+#include <vector>
+#include <set>
+class HydraRenderStage : public HydraObject
+{
+    public:        
+        void Initialise(std::string vertex_shader_file, 
+            std::string fragment_shader_file, 
+            HydraShaderBinding shader_binding, 
+            uint32_t framebuffer_id,
+            std::vector<uint32_t> textures,
+            bool enable_culling,
+            HYDRA_RENDERABLE_TYPE renderable_type);
+        void ShutDown();
+        void Render(std::set<HydraID>& entities);
+    private:
+        uint32_t _LoadShader(std::string filename, uint32_t shader_type);
+        std::string _LoadShaderSource(std::string filename);
+        void _BindBuffers();
+        void _BindTextures();
+        HydraShaderBinding m_shader_binding;
+        uint32_t m_vertex_shader = GL_INVALID_VALUE;
+        uint32_t m_fragment_shader = GL_INVALID_VALUE;
+        uint32_t m_program = GL_INVALID_VALUE;
+        uint32_t m_renderable_type;
+        uint32_t m_framebuffer_id = 0;
+        bool m_cull = false;
+        std::vector<uint32_t> m_textures;
+        
+};
+
+#endif /* HYDRARENDERSTAGE */

HydraEngine/source/pipeline/HydraShaderBinding.hpp

@@ -0,0 +1,13 @@
+#ifndef HYDRASHADERBINDING
+#define HYDRASHADERBINDING
+#include <string>
+#include <vector>
+
+struct HydraShaderBinding
+{
+    std::vector<HYDRA_BUFFER_TYPE> buffer_type;
+    std::vector<std::string> block_name;
+    std::vector<uint32_t> binding_point;
+    std::vector<uint32_t> buffer_id;
+};
+#endif /* HYDRASHADERBINDING */

HydraEngine/source/pipeline/PerFrameUBO.hpp

@@ -0,0 +1,13 @@
+#ifndef PERFRAMEUBO
+#define PERFRAMEUBO
+
+#include <GLMIncludes.h>
+
+struct PerFrameUBO
+{
+    glm::mat4 view;
+    glm::mat4 proj;
+    glm::vec3 viewer_pos = {0,0,0};
+    uint32_t light_count = 0;
+};
+#endif /* PERFRAMEUBO */