Spot works

HydraEngine/source/buffer/HydraShadowBuffer.h

@@ -3,15 +3,12 @@
     
 
 #include "../engine/HydraEngine.h"
+#include "../ecs/components/HydraDirectionalShadowSourceComponent.h"
+#include "../ecs/components/HydraSpotShadowSourceComponent.h"
+
 struct HydraShadowBuffer
 {
-    uint32_t entity_id;
-    uint32_t cascade_count;
-    uint32_t shadow_texture_id;   
-    uint32_t padding0;
-    float near_plane[8];
-    float far_plane[8];
-    glm::mat4 light_space_proj[6];
-    glm::mat4 light_space_view[6];
+    HydraDirectionalShadowSourceComponent directional_shadows[MAX_DIRECTIONAL_SHADOWS];
+    HydraSpotShadowSourceComponent spot_shadows[MAX_SPOT_SHADOWS];
 };
 #endif /* HYDRASHADOWBUFFER */

HydraEngine/source/buffer/HydraShadowBufferManager.cpp

@@ -0,0 +1,115 @@
+#include "HydraShadowBufferManager.h"
+#include "../scheduler/HydraTaskScheduler.h"
+#include "../task/buffer/HydraCreateGPUBufferTask.hpp"
+#include "../task/buffer/HydraUpdateWholeGPUBufferTask.hpp"
+#include "../task/buffer/HydraUpdatePartialGPUBufferTask.hpp"
+#include "../task/buffer/HydraCreateUnBoundTextureTask.hpp"
+#include "../task/renderer/HydraCreateCascadeShadowFrameBuffer.hpp"
+#include "../task/renderer/HydraCreateShadowFrameBuffer.hpp"
+
+void HydraShadowBufferManager::Initialise()
+{
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    for(uint32_t i = 0; i < MAX_DIRECTIONAL_SHADOWS; i++)
+    {
+        m_available_dir.push(i);
+    }
+    for(uint32_t i = 0; i < MAX_SPOT_SHADOWS; i++)
+    {
+        m_available_spot.push(i);
+    }
+    m_directional_shadow_buffer.resize(MAX_DIRECTIONAL_SHADOWS);
+    m_spot_shadow_buffer.resize(MAX_SPOT_SHADOWS);
+
+
+    uint32_t buffer_size = (MAX_DIRECTIONAL_SHADOWS * sizeof(HydraDirectionalShadowSourceComponent));
+                          
+    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("DirectionalShadowBuffer", 1, buffer_size, &m_directional_shadow_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+
+    buffer_size = (MAX_SPOT_SHADOWS * sizeof(HydraSpotShadowSourceComponent));
+
+    create_gpu_buffer_task_id = task_scheduler->CreateTask<HydraCreateGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraCreateGPUBufferTask *spot_task = static_cast<HydraCreateGPUBufferTask *>(task_scheduler->GetTask(create_gpu_buffer_task_id));
+    spot_task->Intialise("SpotShadowBuffer", 1, buffer_size, &m_spot_shadow_buffer_id, HYDRA_BUFFER_TYPE::HYDRA_SSBO_BUFFER);
+    task_scheduler->WaitForTask(create_gpu_buffer_task_id);
+}
+void HydraShadowBufferManager::Shutdown()
+{
+
+}
+HydraID HydraShadowBufferManager::AddDirectionalShadow(HydraDirectionalShadowSourceComponent shadow)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(m_available_dir.size() == 0)
+    {
+        return INVALID_HYDRA_ID;
+    }
+
+    HydraID shadow_id = m_available_dir.front();
+    shadow.shadow_id = shadow_id;
+    m_directional_shadow_buffer[shadow_id] = shadow;
+    return shadow_id;
+}
+HydraID HydraShadowBufferManager::AddSpotShadow(HydraSpotShadowSourceComponent shadow)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(m_available_spot.size() == 0)
+    {
+        return INVALID_HYDRA_ID;
+    }
+
+    HydraID shadow_id = m_available_spot.front();
+    m_spot_shadow_buffer[shadow_id] = shadow;
+    return shadow_id;
+}
+
+void HydraShadowBufferManager::UpdateDirectionalShadow(HydraID shadow_id, HydraDirectionalShadowSourceComponent shadow)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if(shadow_id < MAX_DIRECTIONAL_SHADOWS)
+    {
+        m_directional_shadow_buffer[shadow_id] = shadow;
+    }
+}
+
+void HydraShadowBufferManager::UpdateSpotShadow(HydraID shadow_id, HydraSpotShadowSourceComponent shadow)
+{
+        std::lock_guard<std::mutex> lock(m_mutex);
+    if(shadow_id < MAX_SPOT_SHADOWS)
+    {
+        m_spot_shadow_buffer[shadow_id] = shadow;
+    }
+}
+
+void HydraShadowBufferManager::RemoveDirectionalShadow(HydraID shadow_id)
+{
+
+}
+void HydraShadowBufferManager::RemoveSpotShadow(HydraID shadow_id)
+{
+
+}
+
+void HydraShadowBufferManager::UpdateShadowBuffer()
+{
+    HydraEngine *engine = GetEngine();
+    HydraECS *ecs = engine->ECS();
+
+    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();
+    void *buffer = static_cast<void *>(m_directional_shadow_buffer.data());
+
+    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_directional_shadow_buffer_id,  buffer);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+
+    void *spot_buffer = static_cast<void *>(m_spot_shadow_buffer.data());
+
+    update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateWholeGPUBufferTask>(HydraThreadAffinity::Render);
+    HydraUpdateWholeGPUBufferTask *spot_task = static_cast<HydraUpdateWholeGPUBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
+    spot_task->Intialise(m_spot_shadow_buffer_id,  spot_buffer);
+    task_scheduler->WaitForTask(update_buffer_task_id);
+}

HydraEngine/source/buffer/HydraShadowBufferManager.h

@@ -0,0 +1,34 @@
+#ifndef HYDRASHADOWBUFFERMANAGER
+#define HYDRASHADOWBUFFERMANAGER
+
+#include "../engine/HydraObject.h"
+#include "HydraShadowBuffer.h"
+#include "../ecs/components/HydraDirectionalShadowSourceComponent.h"
+#include "../ecs/components/HydraSpotShadowSourceComponent.h"
+
+#include <queue>
+#include <mutex>
+
+class HydraShadowBufferManager : public HydraObject
+{
+    public:
+        void Initialise();
+        void Shutdown();
+        HydraID AddDirectionalShadow(HydraDirectionalShadowSourceComponent shadow);
+        HydraID AddSpotShadow(HydraSpotShadowSourceComponent shadow);
+        void UpdateDirectionalShadow(HydraID shadow_id, HydraDirectionalShadowSourceComponent shadow);
+        void UpdateSpotShadow(HydraID shadow_id, HydraSpotShadowSourceComponent shadow);
+        void RemoveDirectionalShadow(HydraID shadow_id);
+        void RemoveSpotShadow(HydraID shadow_id);
+        void UpdateShadowBuffer();
+    private:
+        std::vector<HydraDirectionalShadowSourceComponent> m_directional_shadow_buffer;
+        std::vector<HydraSpotShadowSourceComponent> m_spot_shadow_buffer;
+        std::queue<HydraID> m_available_dir;
+        std::queue<HydraID> m_available_spot;
+        uint32_t m_directional_shadow_buffer_id;
+        uint32_t m_spot_shadow_buffer_id;
+        std::mutex m_mutex;
+        
+};
+#endif /* HYDRASHADOWBUFFERMANAGER */