311 lines
9.2 KiB
C++
311 lines
9.2 KiB
C++
|
|
//
|
|
#include "HydraActorManager.h"
|
|
#include "../actor/HydraActor.h"
|
|
#include "../engine/HydraEngine.h"
|
|
#include "../ecs/HydraEntityManager.h"
|
|
#include "../ecs/HydraECS.h"
|
|
#include "../ecs/components/HydraPositionComponent.h"
|
|
#include "../ecs/components/HydraPhysicsComponent.h"
|
|
#include "../ecs/systems/HydraTransformSystem.h"
|
|
#include "../ecs/systems/HydraPhysicsSystem.h"
|
|
#include "../fileaccess/HydraGLTFLoader.h"
|
|
#include "../task/actor/HydraLoadGLTFFileTask.hpp"
|
|
#include "../scheduler/HydraTaskScheduler.h"
|
|
#include <stdio.h>
|
|
|
|
HydraActor *const HydraActorManager::GetActor(HydraID actorID)
|
|
{
|
|
if (actorID < MAX_ACTORS)
|
|
{
|
|
return m_actors[actorID];
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
std::vector<HydraID> &HydraActorManager::GetChildren(HydraID actor_id)
|
|
{
|
|
return m_actors[actor_id]->m_children;
|
|
}
|
|
|
|
void HydraActorManager::DeleteActor(HydraID actorID)
|
|
{
|
|
assert(actorID <= m_actors.size() && "DeleteActor::INVALID ACTOR ID");
|
|
//std::lock_guard<std::mutex> lock(m_mutex);
|
|
if(m_actors[actorID] != nullptr)
|
|
{
|
|
|
|
GetEngine()->ECS()->DestroyEntity(actorID);
|
|
_SetActorDeleted(actorID);
|
|
}
|
|
|
|
}
|
|
|
|
void HydraActorManager::_SetActorDeleted(HydraID actorID)
|
|
{
|
|
if (m_actors[actorID] != nullptr)
|
|
{
|
|
delete m_actors[actorID];
|
|
}
|
|
m_actors[actorID] = nullptr;
|
|
m_available_actor_ids.push_back(actorID);
|
|
}
|
|
|
|
|
|
HydraID HydraActorManager::LoadActor(std::string filename)
|
|
{
|
|
HydraID actor_id = INVALID_HYDRA_ID;
|
|
HydraTaskScheduler* task_scheduler = GetEngine()->TaskScheduler();
|
|
HydraID load_task_id = task_scheduler->CreateTask<HydraLoadGLTFFileTask>(HydraThreadAffinity::Render);
|
|
HydraLoadGLTFFileTask* load_task = static_cast<HydraLoadGLTFFileTask*>(task_scheduler->GetTask(load_task_id));
|
|
load_task->Initialise(filename, &actor_id);
|
|
task_scheduler->WaitForTask(load_task_id);
|
|
return actor_id;
|
|
}
|
|
|
|
|
|
HydraID HydraActorManager::_SaveActor(HydraActor *actor)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
|
|
if (m_available_actor_ids.size() > 0)
|
|
{
|
|
HydraID id = m_available_actor_ids.front();
|
|
m_available_actor_ids.pop_front();
|
|
actor->m_id = id;
|
|
m_actors[id] = actor;
|
|
|
|
return id;
|
|
}
|
|
delete actor;
|
|
return INVALID_HYDRA_ID;
|
|
}
|
|
|
|
void HydraActorManager::Initialise(size_t max_actors)
|
|
{
|
|
m_max_actors = max_actors;
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
|
|
|
m_actors.resize(max_actors);
|
|
|
|
for (int i = 0; i < max_actors; i++)
|
|
{
|
|
m_available_actor_ids.push_back(i);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void HydraActorManager::FixedTickActor(float actor_id, float delta_t)
|
|
{
|
|
HydraActor *actor = GetActor(actor_id);
|
|
if (actor != nullptr)
|
|
{
|
|
actor->FixedTick(delta_t);
|
|
}
|
|
|
|
}
|
|
void HydraActorManager::InitialiseActor(HydraID actorID)
|
|
{
|
|
HydraActor *actor = GetActor(actorID);
|
|
if (actor != nullptr)
|
|
{
|
|
actor->InitialiseComponents();
|
|
m_actors_waiting_for_init.push_back(actorID);
|
|
}
|
|
}
|
|
|
|
void HydraActorManager::Shutdown()
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
|
// for (HydraID actor_id = 0; actor_id < MAX_ACTORS; actor_id++)
|
|
// {
|
|
// if (m_actors[actor_id] != nullptr)
|
|
// {
|
|
// HydraActor *actor = m_actors[actor_id];
|
|
|
|
// m_actors[actor_id]->m_status = HydraActorStatus::WAITING_FOR_DELETE;
|
|
// _RemoveActorFromTickFixed(actor_id);
|
|
// _RemoveActorFromWaiting(actor_id);
|
|
// actor->Destroy();
|
|
// // for (int i = 0; i < m_actors[actor_id]->m_component_types.size(); i++)
|
|
// // {
|
|
// // GetEngine()->ComponentManager()->DeleteComponent(m_actors[actor_id]->m_component_types[i], actor_id);
|
|
// // }
|
|
|
|
// // HydraID delete_task_id = GetEngine()->TaskScheduler()->CreateTask<HydraDeleteActorTask>(HydraThreadAffinity::General);
|
|
// // HydraDeleteActorTask *task = (HydraDeleteActorTask *)GetEngine()->TaskScheduler()->GetTask(delete_task_id);
|
|
// // task->Initialise(actor_id);
|
|
// // GetEngine()->TaskScheduler()->WaitForTask(delete_task_id);
|
|
// }
|
|
// _SetActorDeleted(actor_id);
|
|
// }
|
|
}
|
|
|
|
void HydraActorManager::RotateActor(HydraID actorID, float euler_x, float euler_y, float euler_z)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
|
|
|
|
pos_comp.orientation[0] += euler_x;
|
|
pos_comp.orientation[1] += euler_y;
|
|
pos_comp.orientation[2] += euler_z;
|
|
pos_comp.needs_update = true;
|
|
ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
|
|
}
|
|
|
|
|
|
void HydraActorManager::SetPosition(HydraID actorID, glm::dvec3 position)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
|
|
pos_comp.position = position;
|
|
|
|
if(!pos_comp.needs_update)
|
|
{
|
|
ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
|
|
}
|
|
}
|
|
|
|
void HydraActorManager::SetOrientation(HydraID actorID, float x, float y, float z)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
|
|
pos_comp.orientation = glm::vec3(x, y, z);
|
|
if(!pos_comp.needs_update)
|
|
{
|
|
ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
|
|
}
|
|
}
|
|
|
|
void HydraActorManager::SetLinearVelocity(HydraID actor_id, glm::vec3 velocity)
|
|
{
|
|
HydraECS* ecs = GetEngine()->ECS();
|
|
if (ecs->HasComponent<HydraPhysicsComponent>(actor_id))
|
|
{
|
|
std::shared_ptr<HydraPhysicsSystem> phys_sys = ecs->GetSystem<HydraPhysicsSystem>();
|
|
phys_sys->SetLinearVelocity(actor_id, velocity);
|
|
}
|
|
}
|
|
|
|
void HydraActorManager::SetPositionAndOrientation(HydraID actorID, glm::dvec3 position, glm::vec3 euler_angles, bool ignore_physics)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
if(ecs->HasComponent<HydraPositionComponent>(actorID))
|
|
{
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
|
|
pos_comp.position = position;
|
|
pos_comp.orientation = glm::vec3(euler_angles.x,euler_angles.y,euler_angles.z);
|
|
|
|
if(!pos_comp.needs_update)
|
|
{
|
|
ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID, ignore_physics);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
std::cout << "HERE";
|
|
}
|
|
|
|
}
|
|
|
|
void HydraActorManager::SetScale(HydraID actor_id, glm::dvec3 scaling)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
|
|
pos_comp.scale = glm::vec3(scaling);
|
|
|
|
|
|
// if (ecs->HasComponent<HydraECSPhysicsComponent>(actorID))
|
|
// {
|
|
// HydraECSPhysicsComponent &phys_comp = ecs->GetComponent<HydraECSPhysicsComponent>(actorID);
|
|
// phys_comp.physics_definition.pose = GetActorPose(actorID);
|
|
// }
|
|
if(!pos_comp.needs_update)
|
|
{
|
|
ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actor_id);
|
|
}
|
|
}
|
|
|
|
void HydraActorManager::SetRelationship(HydraID parent_id, HydraID child_id)
|
|
{
|
|
HydraActor *parent_actor = GetActor(parent_id);
|
|
HydraActor *child_actor = GetActor(child_id);
|
|
child_actor->m_parent_id = parent_id;
|
|
parent_actor->m_children.push_back(child_id);
|
|
}
|
|
|
|
void HydraActorManager::TranslateActor(HydraID actorID, glm::dvec3 translation)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
|
|
|
|
pos_comp.position = pos_comp.position + translation;
|
|
|
|
|
|
// if (ecs->HasComponent<HydraECSPhysicsComponent>(actorID))
|
|
// {
|
|
// HydraECSPhysicsComponent &phys_comp = ecs->GetComponent<HydraECSPhysicsComponent>(actorID);
|
|
// // const float* matrix = glm::value_ptr<float>(GetActorPose(actorID));
|
|
|
|
// // std::copy(matrix, matrix + 16, phys_comp.physics_definition.pose);
|
|
// phys_comp.physics_definition.pose = GetActorPose(actorID);
|
|
// }
|
|
ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
|
|
}
|
|
|
|
|
|
|
|
glm::mat4 HydraActorManager::GetActorPose(HydraID actorID)
|
|
{
|
|
|
|
HydraPositionComponent &pos = GetEngine()->ECS()->GetComponent<HydraPositionComponent>(actorID);
|
|
glm::mat4 model_matrix = pos.transform;
|
|
if (pos.needs_update)
|
|
{
|
|
glm::mat4 trans_matrix = glm::translate(pos.position);
|
|
glm::mat4 rot_matrix = glm::toMat4(glm::quat(pos.orientation));
|
|
model_matrix = trans_matrix * rot_matrix;
|
|
}
|
|
return model_matrix;
|
|
}
|
|
|
|
glm::vec3 HydraActorManager::GetActorOrientation(HydraID actorID)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
|
|
return pos_comp.orientation;
|
|
}
|
|
|
|
glm::vec3 HydraActorManager::GetActorVelocity(HydraID actorID)
|
|
{
|
|
|
|
return glm::dvec3(0, 0, 0);
|
|
}
|
|
glm::dvec3 HydraActorManager::GetActorPosition(HydraID actorID)
|
|
{
|
|
HydraECS *ecs = GetEngine()->ECS();
|
|
HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
|
|
|
|
return pos_comp.position;
|
|
}
|
|
|
|
|
|
HydraID HydraActorManager::GetParent(HydraID actor_id)
|
|
{
|
|
return m_actors[actor_id]->m_parent_id;
|
|
}
|
|
|
|
HydraID HydraActorManager::GetRoot(HydraID actor_id)
|
|
{
|
|
HydraID parent_id = GetParent(actor_id);
|
|
if(parent_id == INVALID_HYDRA_ID)
|
|
{
|
|
return actor_id;
|
|
}
|
|
return GetRoot(parent_id);
|
|
}
|