initial commit

HydraEngine/source/ecs/systems/HydraLightSystem.cpp

@@ -0,0 +1,55 @@
+#include "HydraLightSystem.h"
+#include "../../engine/HydraEngine.h"
+#include "../HydraECS.h"
+#include "../components/HydraLightComponent.h"
+#include "../components/HydraPositionComponent.h"
+#include "../../buffer/HydraLightBufferManager.h"
+#include "../../buffer/HydraLightBuffer.h"
+
+#include "../../scheduler/HydraTaskScheduler.h"
+#include "../../task/buffer/HydraCreateGPUBufferTask.hpp"
+#include "../../task/buffer/HydraUpdatePartialGPUBufferTask.hpp"
+#include "../../actor/HydraActorManager.h"
+#include <GLMIncludes.h>
+
+void HydraLightSystem::Initialise()
+{
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    HydraID create_gpu_buffer_task_id = task_scheduler->CreateTask<HydraCreateGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraCreateGPUBufferTask *task = static_cast<HydraCreateGPUBufferTask *>(task_scheduler->GetTask(create_gpu_buffer_task_id));
+    task->Intialise("LightBuffer", 1, MAX_LIGHTS * sizeof(HydraLightComponent), &m_light_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+}
+
+uint32_t HydraLightSystem::GetLightCount()
+{
+    return m_lights.size();
+}
+
+void HydraLightSystem::InitialiseComponent(HydraID entity_id)
+{
+    HydraLightBufferManager *light_man = GetEngine()->LightBufferManager();
+    uint32_t light_count = light_man->GetLightCount();
+    HydraECS *ecs = GetEngine()->ECS();
+
+    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(entity_id);
+    HydraLightComponent &light_comp = ecs->GetComponent<HydraLightComponent>(entity_id);
+
+    m_lights.push_back(light_comp);
+}
+
+void HydraLightSystem::UpdateSystem(float delta_t_seconds)
+{
+    _WriteToGPU();
+}
+
+void HydraLightSystem::_WriteToGPU()
+{
+    void *buffer = static_cast<void *>(m_lights.data());
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+
+    HydraID update_buffer_task_id = task_scheduler->CreateTask<HydraUpdatePartialGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraUpdatePartialGPUBufferTask *task = static_cast<HydraUpdatePartialGPUBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    task->Intialise(m_light_buffer_id, 0, sizeof(HydraLightComponent) * m_lights.size(), buffer);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+}

HydraEngine/source/ecs/systems/HydraLightSystem.h

@@ -0,0 +1,27 @@
+#ifndef HYDRALIGHTSYSTEM
+#define HYDRALIGHTSYSTEM
+
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include "../components/HydraLightComponent.h"
+#include <GLMIncludes.h>
+#include <queue>
+#include <vector>
+
+
+
+class HydraLightSystem : public HydraSystem
+{
+    public:        
+        void Initialise() override;
+        uint32_t GetLightCount();
+    protected: 
+        void InitialiseComponent(HydraID entity_id) override;
+        virtual void UpdateSystem(float delta_t_seconds);
+    private:
+        void _WriteToGPU();        
+        HydraID m_light_buffer_id = INVALID_HYDRA_ID;
+        std::vector<HydraLightComponent> m_lights;
+  
+};
+#endif /* HYDRALIGHTSYSTEM */

HydraEngine/source/ecs/systems/HydraMaterialSystem.cpp

@@ -0,0 +1,57 @@
+#include "HydraMaterialSystem.h"
+#include "../../engine/HydraEngine.h"
+#include "../HydraECS.h"
+#include "../components/HydraMaterialComponent.h"
+
+#include "../../buffer/HydraMaterialBufferManager.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+
+#include "../../scheduler/HydraTaskScheduler.h"
+#include "../../task/buffer/HydraCreateGPUBufferTask.hpp"
+#include "../../task/buffer/HydraUpdateWholeGPUBufferTask.hpp"
+#include "../../actor/HydraActorManager.h"
+
+
+
+void HydraMaterialSystem::Initialise()
+{
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+
+    HydraID create_gpu_buffer_task_id = task_scheduler->CreateTask<HydraCreateGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraCreateGPUBufferTask *task = static_cast<HydraCreateGPUBufferTask *>(task_scheduler->GetTask(create_gpu_buffer_task_id));
+    task->Intialise("MaterialBuffer", 1, MAX_MATERIALS * sizeof(HydraMaterialBuffer), &m_material_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+
+    create_gpu_buffer_task_id = task_scheduler->CreateTask<HydraCreateGPUBufferTask>(HydraThreadAffinity::Render);
+    task = static_cast<HydraCreateGPUBufferTask *>(task_scheduler->GetTask(create_gpu_buffer_task_id));
+    task->Intialise("TextureBuffer", 1, MAX_TEXTURES * sizeof(uint64_t), &m_texture_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+}
+
+void HydraMaterialSystem::InitialiseComponent(HydraID entity_id)
+{
+}
+
+void HydraMaterialSystem::UpdateSystem(float delta_t_seconds)
+{
+    _WriteToGPU();
+}
+
+
+void HydraMaterialSystem::_WriteToGPU()
+{
+    void* buffer = GetEngine()->MaterialBufferManager()->GetMaterialBuffer();
+
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+
+    HydraID update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateWholeGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraUpdateWholeGPUBufferTask *task = static_cast<HydraUpdateWholeGPUBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    task->Intialise(m_material_buffer_id, buffer);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+
+    buffer = GetEngine()->TextureBufferManager()->GetTextureBuffer();
+    update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateWholeGPUBufferTask>(HydraThreadAffinity::Render);
+    task = static_cast<HydraUpdateWholeGPUBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    task->Intialise(m_texture_buffer_id, buffer);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+}

HydraEngine/source/ecs/systems/HydraMaterialSystem.h

@@ -0,0 +1,27 @@
+#ifndef HYDRAMATERIALSYSTEM
+#define HYDRAMATERIALSYSTEM
+
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include <GLMIncludes.h>
+#include <queue>
+#include <vector>
+
+
+
+class HydraMaterialSystem : public HydraSystem
+{
+    public:        
+        void Initialise() override;
+    protected: 
+        void InitialiseComponent(HydraID entity_id) override;
+        virtual void UpdateSystem(float delta_t_seconds);
+    private:
+        void _WriteToGPU();
+        HydraID m_material_buffer_id = INVALID_HYDRA_ID;
+        HydraID m_texture_buffer_id = INVALID_HYDRA_ID;
+  
+};
+
+
+#endif /* HYDRAMATERIALSYSTEM */

HydraEngine/source/ecs/systems/HydraMeshSystem.cpp

@@ -0,0 +1,44 @@
+#include "HydraMeshSystem.h"
+#include "../HydraECS.h"
+#include "../../engine/HydraEngine.h"
+#include "../components/HydraMeshComponent.h"
+#include "../../buffer/HydraBufferManager.h"
+#include "../../scheduler/HydraTaskScheduler.h"
+#include "../../task/buffer/HydraCreateVertexBufferTask.hpp"
+
+#include "../../task/buffer/HydraUpdateVertexBufferTask.hpp"
+#include "../../mesh/HydraMeshManager.h"
+void HydraMeshSystem::Initialise()
+{
+
+}
+
+void HydraMeshSystem::InitialiseComponent(HydraID entity_id)
+{
+    HydraECS* ecs = GetEngine()->ECS();
+
+    HydraBufferManager *buffer_manager = GetEngine()->BufferManager();
+    HydraMeshComponent& mesh_comp = ecs->GetComponent<HydraMeshComponent>(entity_id);
+
+    HydraMeshManager* mesh_man = GetEngine()->MeshManager();
+    HydraMesh* mesh = mesh_man->GetMesh(mesh_comp.mesh_id);
+
+    uint32_t vertex_buffer_size = sizeof(StandardVertex) * mesh->vertexes.size();
+    uint32_t index_buffer_size = sizeof(uint32_t) * mesh->indexes.size();
+
+    uint32_t triangle_count = mesh->indexes.size();// / 3;
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+
+    //Create VAO and Vertex Buffer storage
+    HydraID create_vertex_task_id = task_scheduler->CreateTask<HydraCreateVertexBufferTask>(HydraThreadAffinity::Render);
+    HydraCreateVertexBufferTask *vertex_task = static_cast<HydraCreateVertexBufferTask *>(task_scheduler->GetTask(create_vertex_task_id));    
+    vertex_task->Intialise(vertex_buffer_size, index_buffer_size, triangle_count, &mesh_comp.vertex_buffer_id);
+    task_scheduler->WaitForTask(create_vertex_task_id);
+
+    //Update vertex buffer
+    HydraID update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateVertexBufferTask>(HydraThreadAffinity::Render);
+    HydraUpdateVertexBufferTask *vertex_update_task = static_cast<HydraUpdateVertexBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    vertex_update_task->Intialise(mesh_comp.vertex_buffer_id, &mesh->vertexes[0], &mesh->indexes[0]);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+
+}

HydraEngine/source/ecs/systems/HydraMeshSystem.h

@@ -0,0 +1,19 @@
+#ifndef HYDRAMESHSYSTEM
+#define HYDRAMESHSYSTEM
+
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include <GLMIncludes.h>
+#include <queue>
+
+class HydraMeshSystem : public HydraSystem
+{
+    public:
+        
+        void Initialise() override;
+    protected: 
+        void InitialiseComponent(HydraID entity_id) override;
+        virtual void UpdateSystem(float delta_t_seconds){}
+};
+
+#endif /* HYDRAMESHSYSTEM */

HydraEngine/source/ecs/systems/HydraRenderSystem.cpp

@@ -0,0 +1,6 @@
+#include "HydraRenderSystem.h"
+
+void HydraRenderSystem::Initialise()
+{
+    
+}

HydraEngine/source/ecs/systems/HydraRenderSystem.h

@@ -0,0 +1,18 @@
+#ifndef HYDRARENDERSYSTEM
+#define HYDRARENDERSYSTEM
+
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include <GLMIncludes.h>
+#include <queue>
+
+class HydraRenderSystem : public HydraSystem
+{
+    public:
+        
+        void Initialise() override;
+    protected:         
+        virtual void UpdateSystem(float delta_t_seconds){}
+};
+
+#endif /* HYDRARENDERSYSTEM */

HydraEngine/source/ecs/systems/HydraTransformSystem.cpp

@@ -0,0 +1,93 @@
+#include "HydraTransformSystem.h"
+#include "../../engine/HydraEngine.h"
+#include "../HydraECS.h"
+#include "../components/HydraPositionComponent.h"
+#include "../../scheduler/HydraTaskScheduler.h"
+#include "../../task/buffer/HydraCreateGPUBufferTask.hpp"
+#include "../../task/buffer/HydraUpdateWholeGPUBufferTask.hpp"
+#include "../../actor/HydraActorManager.h"
+
+void HydraTransformSystem::UpdateTransform(HydraID actor_id)
+{
+    
+    HydraECS *ecs = GetEngine()->ECS();
+    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
+    pos_comp.needs_update = true;    
+    m_entities_to_update.push(actor_id);        
+}
+
+void HydraTransformSystem::Initialise()
+{
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    HydraID create_gpu_buffer_task_id = task_scheduler->CreateTask<HydraCreateGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraCreateGPUBufferTask *task = static_cast<HydraCreateGPUBufferTask *>(task_scheduler->GetTask(create_gpu_buffer_task_id));
+    task->Intialise("PositionsBuffer", 1, MAX_ACTORS * sizeof(glm::mat4),
+     &m_transform_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+    m_model_matrix.resize(MAX_ACTORS);
+}
+
+void HydraTransformSystem::UpdateSystem(float delta_t_seconds)
+{
+    HydraECS *ecs = GetEngine()->ECS();
+    
+    while(m_entities_to_update.size() > 0)
+    {
+        HydraID actor_id = m_entities_to_update.front();
+        m_entities_to_update.pop();
+        HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
+        if(pos_comp.needs_update)
+        {
+            HydraID parent_id = GetEngine()->ActorManager()->GetRoot(actor_id);
+             glm::mat4 identity = glm::mat4(1);
+            _UpdateChild(INVALID_HYDRA_ID, parent_id, identity);
+        }
+    }
+    _WriteToGPU();
+}
+
+void HydraTransformSystem::InitialiseComponent(HydraID actor_id)
+{
+    HydraECS *ecs = GetEngine()->ECS();
+
+    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
+    if (pos_comp.needs_update)
+    {
+        glm::mat4 identity = glm::mat4(1);
+        _UpdateChild(INVALID_HYDRA_ID, actor_id, identity);
+    }
+}
+
+void HydraTransformSystem::_UpdateChild(HydraID parent_id, HydraID actor_id, glm::mat4 parent_transform)
+{
+    HydraECS *ecs = GetEngine()->ECS();
+    std::vector<HydraID> &child_ids = GetEngine()->ActorManager()->GetChildren(actor_id);
+    glm::mat4 trans = parent_transform;
+
+    if (ecs->HasComponent<HydraPositionComponent>(actor_id))
+    {
+        HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
+        glm::mat4 trans_matrix = glm::translate(glm::vec3(pos_comp.position.x, pos_comp.position.y, pos_comp.position.z));
+        glm::mat4 rot_matrix = glm::toMat4(glm::quat(pos_comp.orientation));
+        glm::mat4 scale_matrix = glm::scale(pos_comp.scale);
+        glm::mat4 model_matrix = trans_matrix * rot_matrix * scale_matrix;
+
+        pos_comp.transform =  trans * model_matrix;
+        pos_comp.needs_update = false;
+        m_model_matrix[actor_id] = pos_comp.transform;
+        trans =  pos_comp.transform;
+    }
+    for (uint32_t child_idx = 0; child_idx < child_ids.size(); child_idx++)
+    {
+        _UpdateChild(actor_id, child_ids[child_idx], trans);
+    }
+}
+
+void HydraTransformSystem::_WriteToGPU()
+{
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    HydraID update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateWholeGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraUpdateWholeGPUBufferTask *task = static_cast<HydraUpdateWholeGPUBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    task->Intialise(m_transform_buffer_id, &m_model_matrix[0]);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+}

HydraEngine/source/ecs/systems/HydraTransformSystem.h

@@ -0,0 +1,27 @@
+#ifndef HYDRAECSTRANSFORMSYSTEM
+#define HYDRAECSTRANSFORMSYSTEM
+#include "../../engine/HydraObject.h"
+#include "../HydraSystem.h"
+#include <GLMIncludes.h>
+#include <queue>
+class HydraTransformSystem : public HydraSystem
+{
+    public:
+        
+        void UpdateTransform(HydraID actor_id);
+        void Initialise() override;
+        
+    protected: 
+
+        virtual void UpdateSystem(float delta_t_seconds) override;
+        void InitialiseComponent(HydraID actor_id) override;
+    private:
+        void _UpdateChild(HydraID parent_id, HydraID actor_id, glm::mat4 parent_transform);
+        void _WriteToGPU();
+        
+        HydraID m_transform_buffer_id = INVALID_HYDRA_ID;
+        std::queue<HydraID> m_entities_to_update;
+        std::vector<glm::mat4> m_model_matrix;
+};
+
+#endif /* HYDRAECSTRANSFORMSYSTEM */