initial commit

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 */