HydraV3/HydraEngine/source/ecs/systems/HydraTransformSystem.cpp

#include "HydraTransformSystem.h"
#include "../../engine/HydraEngine.h"
#include "../HydraECS.h"
#include "HydraPhysicsSystem.h"
#include "../components/HydraPositionComponent.h"
#include "../../scheduler/HydraTaskScheduler.h"
#include "../../task/buffer/HydraCreateGPUBufferTask.hpp"
#include "../../task/buffer/HydraDeleteGPUBufferTask.hpp"
#include "../../task/buffer/HydraUpdateWholeGPUBufferTask.hpp"
#include "../../task/physics/HydraSetPhysicsTransform.hpp"
#include "../../actor/HydraActorManager.h"
#include "../components/HydraPhysicsComponent.h"

void HydraTransformSystem::UpdateTransform(HydraID actor_id, bool ignore_physics)
{

    HydraECS *ecs = GetEngine()->ECS();
    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
    pos_comp.needs_update = true;
    m_entities_to_update.push(actor_id);
    if (!ignore_physics)
    {
        if (ecs->HasComponent<HydraPhysicsComponent>(actor_id))
        {
            std::shared_ptr<HydraPhysicsSystem> phys_sys = GetEngine()->ECS()->GetSystem<HydraPhysicsSystem>();
            phys_sys->SetTransform(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::FreeSystemResources()
{
    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();

    HydraID delete_gpu_buffer_task_id = task_scheduler->CreateTask<HydraDeleteGPUBufferTask>(HydraThreadAffinity::Render);
    HydraDeleteGPUBufferTask *task = static_cast<HydraDeleteGPUBufferTask *>(task_scheduler->GetTask(delete_gpu_buffer_task_id));
    task->Intialise(m_transform_buffer_id);
    task_scheduler->WaitForTask(delete_gpu_buffer_task_id);
}

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;
        if (ecs->HasComponent<HydraPhysicsComponent>(actor_id))
        {
            HydraPhysicsComponent phys_comp = ecs->GetComponent<HydraPhysicsComponent>(actor_id);
            if (phys_comp.initialised)
            {
                HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();

                HydraID task_id = task_scheduler->CreateTask<HydraSetPhysicsTransform>(HydraThreadAffinity::Render);
                HydraSetPhysicsTransform *task = static_cast<HydraSetPhysicsTransform *>(task_scheduler->GetTask(task_id));
                task->Initialise(phys_comp.body_id,
                                 glm::vec3(pos_comp.position.x, pos_comp.position.y, pos_comp.position.z),
                                 glm::quat(pos_comp.orientation));
                task_scheduler->WaitForTask(task_id);
            }
        }

        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);
}