initial commit

HydraEngine/source/task/HydraTask.cpp

@@ -0,0 +1,10 @@
+#include "HydraTask.h"
+#include "../scheduler/HydraTaskScheduler.h"
+#include "../engine/HydraEngine.h"
+
+void HydraTask::_RunTask()
+{
+    GetEngine()->TaskScheduler()->NotifyStart(m_taskID);
+    Process();
+    GetEngine()->TaskScheduler()->NotifyComplete(m_taskID);
+}

HydraEngine/source/task/HydraTask.h

@@ -0,0 +1,31 @@
+#ifndef HYDRATASK
+#define HYDRATASK
+
+#include "../engine/HydraObject.h"
+
+#include <thread>
+
+class CLASS_DEFINE HydraTask : public HydraObject
+{
+private:
+    int m_child_tasks = 0;
+    
+    HydraID m_dependant_task = INVALID_HYDRA_ID;
+    HydraID m_barrierID = INVALID_HYDRA_ID;
+    std::thread::id m_notifyID;        
+    HydraThreadAffinity ThreadAffinity = HydraThreadAffinity::General;
+    bool m_notifyThread = true;
+    
+    void _RunTask();
+    friend class HydraTaskScheduler;
+protected:
+    HydraID m_taskID;
+
+public:
+    HydraID GetBarrierID() {return m_barrierID;}
+    virtual void Process() = 0;
+    virtual void Notify() {};
+    virtual void Complete() {};
+};
+
+#endif /* HYDRATASK */

HydraEngine/source/task/actor/HydraLoadGLTFFileTask.hpp

@@ -0,0 +1,29 @@
+#ifndef HYDRALOADGLTFFILETASK
+#define HYDRALOADGLTFFILETASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../actor/HydraPlayerActor.h"
+#include "../../actor/HydraActorManager.h"
+#include "../../fileaccess/HydraGLTFLoader.h"
+
+class HydraLoadGLTFFileTask : public HydraTask
+{
+    private:
+        HydraID* m_actor_id_out;        
+        std::string m_filename = "";
+    protected:
+    public:
+        virtual void Process() override
+        {
+            HydraGLTFLoader loader;
+            *m_actor_id_out = loader.LoadGLTFFile(m_filename);
+        }
+        virtual void Initialise(std::string filename, HydraID* actor_id_out)
+        {
+            m_actor_id_out = actor_id_out;
+            m_filename = filename;
+        }
+        
+};
+
+#endif /* HYDRALOADGLTFFILETASK */

HydraEngine/source/task/actor/HydraUpdatePlayerTask.h

@@ -0,0 +1,30 @@
+#ifndef HYDRAUPDATEPLAYERTASK
+#define HYDRAUPDATEPLAYERTASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../actor/HydraPlayerActor.h"
+#include "../../actor/HydraActorManager.h"
+
+class HydraUpdatePlayerTask : public HydraTask
+{
+    private:        
+    protected:
+    public:
+        virtual void Process() override
+        {
+            HydraID playerID = GetEngine()->GetPossessedPlayer();
+            if(playerID != INVALID_HYDRA_ID)
+            {
+                HydraActor* tempActor = GetEngine()->ActorManager()->GetActor(playerID);
+                HydraPlayerActor* player = dynamic_cast<HydraPlayerActor*>(tempActor);
+                if(player != nullptr)
+                {
+                    player->HandleInput(GetEngine()->GetDeltaT());
+                }
+            }
+        }
+        
+};
+
+#endif /* HYDRAUPDATEPLAYERTASK */

HydraEngine/source/task/buffer/HydraCreateGPUBufferTask.hpp

@@ -0,0 +1,41 @@
+#ifndef HYDRACREATEGPUBUFFERTASK
+#define HYDRACREATEGPUBUFFERTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraBufferManager.h"
+#include <string>
+
+class HydraCreateGPUBufferTask : public HydraTask
+{
+    private:
+        uint32_t m_buffer_size_bytes = 0;
+        HydraID* m_buffer_id;
+        uint32_t m_binding = 0;
+        HYDRA_BUFFER_TYPE m_buffer_type;
+        std::string m_buffer_name;
+    protected:
+    public:        
+            
+        virtual void Process() override
+        {
+           *m_buffer_id = GetEngine()->BufferManager()->CreateGPUBuffer(m_buffer_name,
+            m_buffer_size_bytes, m_binding, m_buffer_type);
+        }
+        void Intialise(std::string buffer_name, 
+            uint32_t binding, 
+            uint32_t buffer_size_bytes, 
+            uint32_t* buffer_id,
+            HYDRA_BUFFER_TYPE buffer_type)
+        {
+            m_buffer_size_bytes = buffer_size_bytes;
+            m_buffer_id = buffer_id;
+            m_binding = binding;
+            m_buffer_name = buffer_name;
+            m_buffer_type = buffer_type;
+        }
+
+  
+
+};
+
+#endif /* HYDRACREATEGPUBUFFERTASK */

HydraEngine/source/task/buffer/HydraCreateTextureTask.hpp

@@ -0,0 +1,65 @@
+#ifndef HYDRACREATETEXTURETASK
+#define HYDRACREATETEXTURETASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+
+class HydraCreateTextureTask : public HydraTask
+{
+private:
+    std::string m_texture_name;
+    uint32_t m_width;
+    uint32_t m_height;
+    uint32_t m_internal_format;
+    uint32_t m_format;
+    uint32_t m_data_type;
+    uint32_t m_mip_levels;
+    uint32_t m_min_filter;
+    uint32_t m_mag_filter;
+    void *m_data;
+    HydraID *m_texture_id;
+
+protected:
+public:
+    virtual void Process() override
+    {
+        *m_texture_id = GetEngine()->TextureBufferManager()->CreateTexture(m_texture_name,
+             m_width, m_height, 
+             m_internal_format, 
+              m_min_filter,
+             m_mag_filter,
+             m_format, 
+             m_data_type, 
+             m_mip_levels, 
+             m_data);
+        GetEngine()->TextureBufferManager()->BindTexture(*m_texture_id);
+
+    }
+    void Initialise(std::string texture_name,
+                   uint32_t width,
+                   uint32_t height,
+                   uint32_t internal_format,
+                   uint32_t format,
+                   uint32_t min_filter,
+                   uint32_t mag_filter,
+                   uint32_t data_type,
+                   uint32_t mip_levels,
+                   void *data,
+                   HydraID *texture_id)
+    {
+        m_texture_name = texture_name;
+        m_width = width;
+        m_height = height;
+        m_internal_format = internal_format;
+        m_format = format;
+        m_data_type = data_type;
+        m_mip_levels = mip_levels;
+        m_data = data;
+        m_texture_id = texture_id;
+        m_min_filter = min_filter;
+        m_mag_filter = mag_filter;
+
+    }
+};
+#endif /* HYDRACREATETEXTURETASK */

HydraEngine/source/task/buffer/HydraCreateVertexBufferTask.hpp

@@ -0,0 +1,36 @@
+#ifndef HYDRACREATEVERTEXBUFFERTASK
+#define HYDRACREATEVERTEXBUFFERTASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraVertexBufferManager.h"
+
+class HydraCreateVertexBufferTask : public HydraTask
+{
+    private:
+        uint32_t m_vertex_buffer_size_bytes = 0;
+        uint32_t m_index_buffer_size_bytes = 0;
+        HydraID* m_buffer_id;
+        uint32_t m_triangle_count = 0;
+
+    protected:
+    public:
+        virtual void Process() override
+        {
+           *m_buffer_id = GetEngine()->VertexBufferManager()->CreateVertexBuffer(m_vertex_buffer_size_bytes, 
+                            m_index_buffer_size_bytes,
+                            m_triangle_count);
+        }
+        void Intialise(uint32_t vertex_buffer_size_bytes, 
+                      uint32_t index_buffer_size_bytes, 
+                      uint32_t triangle_count,
+                      uint32_t* buffer_id)
+        {
+            m_vertex_buffer_size_bytes = vertex_buffer_size_bytes;
+            m_index_buffer_size_bytes = index_buffer_size_bytes;
+            m_buffer_id = buffer_id;
+            m_triangle_count = triangle_count;
+        }
+
+};
+#endif /* HYDRACREATEVERTEXBUFFERTASK */

HydraEngine/source/task/buffer/HydraInitialiseTextureManagerTask.hpp

@@ -0,0 +1,21 @@
+#ifndef HYDRAINITIALISETEXTUREMANAGERTASK
+#define HYDRAINITIALISETEXTUREMANAGERTASK
+
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraTextureBufferManager.h"
+
+class HydraInitialiseTextureManagerTask : public HydraTask
+{
+    private:     
+    protected:
+    public:
+        virtual void Process() override
+        {
+           GetEngine()->TextureBufferManager()->Intialise();
+        }
+
+        
+};
+#endif /* HYDRAINITIALISETEXTUREMANAGERTASK */

HydraEngine/source/task/buffer/HydraShutdownBufferManagerTask.hpp

@@ -0,0 +1,19 @@
+#ifndef HYDRASHUTDOWNBUFFERMANAGERTASK
+#define HYDRASHUTDOWNBUFFERMANAGERTASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraBufferManager.h"
+
+class HydraShutdownBufferManagerTask : public HydraTask
+{
+    private:
+    protected:
+    public:
+        virtual void Process() override
+        {
+           GetEngine()->BufferManager()->Shutdown();
+           GetEngine()->VertexBufferManager()->Shutdown();
+        }
+};
+#endif /* HYDRASHUTDOWNBUFFERMANAGERTASK */

HydraEngine/source/task/buffer/HydraUpdatePartialGPUBufferTask.hpp

@@ -0,0 +1,31 @@
+#ifndef HYDRAUPDATEPARTIALGPUBUFFERTASK
+#define HYDRAUPDATEPARTIALGPUBUFFERTASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraBufferManager.h"
+
+class HydraUpdatePartialGPUBufferTask : public HydraTask
+{
+    private:
+        HydraID m_buffer_id = INVALID_HYDRA_ID;
+        void *m_data = nullptr;
+        uint32_t m_start = 0;
+        uint32_t m_size = 0;
+    protected:
+    public:
+        virtual void Process() override
+        {
+           GetEngine()->BufferManager()->UpdateWholeBuffer(m_buffer_id, m_data);
+        }
+        void Intialise(HydraID buffer_id, uint32_t start, uint32_t size, void* data)
+        {
+            m_buffer_id = buffer_id;
+            m_data = data;
+            m_start = start;
+            m_size = size;
+        }
+        
+};
+
+#endif /* HYDRAUPDATEPARTIALGPUBUFFERTASK */

HydraEngine/source/task/buffer/HydraUpdateVertexBufferTask.hpp

@@ -0,0 +1,28 @@
+#ifndef HYDRAUPDATEVERTEXBUFFERTASK
+#define HYDRAUPDATEVERTEXBUFFERTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraVertexBufferManager.h"
+
+class HydraUpdateVertexBufferTask : public HydraTask
+{
+    private:
+        HydraID m_buffer_id = INVALID_HYDRA_ID;
+        void *m_vertex_data = nullptr;
+        void *m_index_data = nullptr;
+    protected:
+    public:
+        virtual void Process() override
+        {
+           GetEngine()->VertexBufferManager()->UpdateVertexBuffer(m_buffer_id, m_vertex_data, m_index_data);
+        }
+        void Intialise(HydraID buffer_id, void* vertex_data, void* index_data)
+        {
+            m_buffer_id = buffer_id;
+            m_vertex_data = vertex_data;
+            m_index_data = index_data;
+        }
+        
+};
+
+#endif /* HYDRAUPDATEVERTEXBUFFERTASK */

HydraEngine/source/task/buffer/HydraUpdateWholeGPUBufferTask.hpp

@@ -0,0 +1,26 @@
+#ifndef HYDRAUPDATEGPUBUFFERTASK
+#define HYDRAUPDATEGPUBUFFERTASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../buffer/HydraBufferManager.h"
+
+class HydraUpdateWholeGPUBufferTask : public HydraTask
+{
+    private:
+        HydraID m_buffer_id = INVALID_HYDRA_ID;
+        void *m_data = nullptr;
+    protected:
+    public:
+        virtual void Process() override
+        {
+           GetEngine()->BufferManager()->UpdateWholeBuffer(m_buffer_id, m_data);
+        }
+        void Intialise(HydraID buffer_id, void* data)
+        {
+            m_buffer_id = buffer_id;
+            m_data = data;
+        }
+        
+};
+#endif /* HYDRAUPDATEGPUBUFFERTASK */

HydraEngine/source/task/ecs/HydraInitialiseComponentsTask.hpp

@@ -0,0 +1,23 @@
+#ifndef HYDRAINITIALISECOMPONENTSTASK
+#define HYDRAINITIALISECOMPONENTSTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../ecs/HydraECS.h"
+#include <memory>
+
+
+class  HydraInitialiseComponentsTask : public HydraTask
+{
+    private:        
+        
+    protected:
+    public:
+        virtual void Process() override
+        {
+           GetEngine()->ECS()->InitialiseComponents();
+        }    
+
+        
+};
+
+#endif /* HYDRAINITIALISECOMPONENTSTASK */

HydraEngine/source/task/ecs/HydraUpdateSystemTask.hpp

@@ -0,0 +1,28 @@
+#ifndef HYDRAUPDATESYSTEMTASK
+#define HYDRAUPDATESYSTEMTASk
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../ecs/systems/HydraTransformSystem.h"
+#include <memory>
+
+
+class  HydraUpdateSystemTask : public HydraTask
+{
+    private:
+        float m_delta_t_seconds;
+        std::shared_ptr<HydraSystem> m_system;
+    protected:
+    public:
+        virtual void Process() override
+        {
+            m_system->Update(m_delta_t_seconds);
+        }    
+        void Initialise(float delta_t_seconds, const std::shared_ptr<HydraSystem>& system)
+        {
+            m_delta_t_seconds = delta_t_seconds;
+            m_system = system;
+        }
+        
+};
+
+#endif /* HYDRAUPDATESYSTEMTASK */

HydraEngine/source/task/pipeline/HydraInitialisePipelineTask.hpp

@@ -0,0 +1,23 @@
+#ifndef HYDRAINITIALISEPIPELINETASK
+#define HYDRAINITIALISEPIPELINETASK
+
+#include "../HydraTask.h"
+#include "../../pipeline/HydraPipeline.h"
+
+
+class HydraInitialisePipelineTask : public HydraTask
+{
+    private:
+        HydraPipeline* m_pipeline = nullptr;
+    protected:
+    public:
+        virtual void Process() override
+        {
+            m_pipeline->Initialise();
+        }
+        void Initialise(HydraPipeline* pipeline)
+        {
+            m_pipeline = pipeline;
+        }
+};
+#endif /* HYDRAINITIALISEPIPELINETASK */

HydraEngine/source/task/pipeline/HydraRenderPipelineTask.hpp

@@ -0,0 +1,27 @@
+#ifndef HYDRARENDERPIPELINETASK
+#define HYDRARENDERPIPELINETASK
+
+#include "../HydraTask.h"
+#include "../../pipeline/HydraPipeline.h"
+
+
+class HydraRenderPipelineTask : public HydraTask
+{
+    private:
+        HydraPipeline* m_pipeline = nullptr;
+    protected:
+    public:
+        virtual void Process() override
+        {
+            m_pipeline->Render();
+        }
+        void Initialise(HydraPipeline* pipeline)
+        {
+            if(pipeline == nullptr)
+            {
+                std::cout<<"ERROR";
+            }
+            m_pipeline = pipeline;
+        }
+};
+#endif /* HYDRARENDERPIPELINETASK */

HydraEngine/source/task/pipeline/HydraShutdownPipelineTask.hpp

@@ -0,0 +1,23 @@
+#ifndef HYDRASHUTDOWNPIPELINETAST
+#define HYDRASHUTDOWNPIPELINETAST
+
+#include "../HydraTask.h"
+#include "../../pipeline/HydraPipeline.h"
+
+
+class HydraShutdownPipelineTask : public HydraTask
+{
+    private:
+        HydraPipeline* m_pipeline = nullptr;
+    protected:
+    public:
+        virtual void Process() override
+        {
+            m_pipeline->Shutdown();
+        }
+        void Initialise(HydraPipeline* pipeline)
+        {
+            m_pipeline = pipeline;
+        }
+};
+#endif /* HYDRASHUTDOWNPIPELINETAST */

HydraEngine/source/task/renderer/HydraInitialiseRendererTask.hpp

@@ -0,0 +1,18 @@
+#ifndef HYDRAINITIALISERENDERERTASK
+#define HYDRAINITIALISERENDERERTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../renderer/HydraRenderer.h"
+
+class HydraInitialiseRendererTask : public HydraTask
+{
+    private:
+    protected:
+    public:
+        virtual void Process() override
+        {
+            GetEngine()->Renderer()->Initialise(GetEngine()->RenderSettings());
+        }
+};
+
+#endif /* HYDRAINITIALISERENDERERTASK */

HydraEngine/source/task/renderer/HydraRenderTask.hpp

@@ -0,0 +1,19 @@
+#ifndef HYDRARENDERTASK
+#define HYDRARENDERTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../renderer/HydraRenderer.h"
+
+class HydraRenderTask : public HydraTask
+{
+    private:
+    protected:
+    public:
+        virtual void Process() override
+        {
+            GetEngine()->Renderer()->BeginFrame();
+            GetEngine()->Renderer()->EndFrame();
+        }
+};
+
+#endif /* HYDRARENDERTASK */

HydraEngine/source/task/windowmanager/HydraInitialiseWindowManagerTask.hpp

@@ -0,0 +1,20 @@
+#ifndef HYDRAINITIALISEWINDOWMANAGERTASK
+#define HYDRAINITIALISEWINDOWMANAGERTASK
+
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../windowmanager/HydraWindowManager.h"
+#include "../../windowmanager/HydraRenderSettings.h"
+
+class HydraInitialiseWindowManagerTask : public HydraTask
+{
+    private:
+    protected:
+    public:
+        virtual void Process() override
+        {
+            GetEngine()->WindowManager()->CreateRenderWindow("Hydra", GetEngine()->RenderSettings());
+        }
+};
+
+#endif /* HYDRAINITIALISEWINDOWMANAGERTASK */

HydraEngine/source/task/windowmanager/HydraProcessInputTask.hpp

@@ -0,0 +1,19 @@
+#ifndef HYDRAPROCESSINPUTTASK
+#define HYDRAPROCESSINPUTTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../windowmanager/HydraWindowManager.h"
+#include "../../engine/HydraInputManager.h"
+
+class HydraProcessInputTask : public HydraTask
+{
+    private:
+    protected:
+    public:
+        virtual void Process() override
+        {
+            GetEngine()->WindowManager()->HandleMessages();
+            GetEngine()->InputManager()->ProcessInput();
+        }
+};
+#endif /* HYDRAPROCESSINPUTTASK */

HydraEngine/source/task/windowmanager/HydraShutdownWindowManagerTask.hpp

@@ -0,0 +1,20 @@
+#ifndef HYDRASHUTDOWNWINDOWMANAGERTASK
+#define HYDRASHUTDOWNWINDOWMANAGERTASK
+#include "../HydraTask.h"
+#include "../../engine/HydraEngine.h"
+#include "../../windowmanager/HydraWindowManager.h"
+#include "../../windowmanager/HydraRenderSettings.h"
+
+class HydraShutdownWindowManagerTask : public HydraTask
+{
+    private:
+    protected:
+    public:
+        virtual void Process() override
+        {
+            GetEngine()->WindowManager()->Shutdown();
+        }
+};
+
+
+#endif /* HYDRASHUTDOWNWINDOWMANAGERTAST */