144 lines
4.4 KiB
C++
144 lines
4.4 KiB
C++
#include <Entity/EntityManager.h>
|
|
|
|
#include <Core/Common/EnumUtils.h>
|
|
#include <Core/Common/serialization.h>
|
|
#include <Data/World.h>
|
|
#include <Entity/Entity.h>
|
|
#include <Entity/entity_types.h>
|
|
#include <game.h>
|
|
#include <Graphics/MeshRenderer.h>
|
|
|
|
EntityID EntityManager::ID = 0;
|
|
|
|
void InitEntityManager(NonNullPtr<World> world)
|
|
{
|
|
EntityManager* newManager = ArenaPushStruct<EntityManager>(world->WorldArena);
|
|
world->EntityManager = newManager;
|
|
|
|
newManager->Entities.Create(world->WorldArena JULIET_DEBUG_PARAM("Entities"));
|
|
|
|
ArenaParams by_type_params{ .ReserveSize = Kilobytes(1),
|
|
.CommitSize = Kilobytes(1),
|
|
.Name = "" JULIET_DEBUG_ONLY(, .CanReserveMore = false) };
|
|
for (uint8 i = 0; i < ENTITY(Count); ++i)
|
|
{
|
|
by_type_params.Name = kEntity_type_names[i];
|
|
newManager->by_type[i].arena = ArenaAllocate(by_type_params);
|
|
newManager->by_type[i].array = nullptr;
|
|
}
|
|
}
|
|
|
|
void ShutdownEntityManager()
|
|
{
|
|
auto& manager = GetEntityManager();
|
|
for (typed_entity_array& type : manager.by_type)
|
|
{
|
|
ArenaRelease(type.arena);
|
|
}
|
|
|
|
manager.Entities.Destroy();
|
|
}
|
|
|
|
EntityManager& GetEntityManager()
|
|
{
|
|
NonNullPtr entityManager = GetGameState()->World->EntityManager;
|
|
return *entityManager;
|
|
}
|
|
|
|
EntityTemplate* RegisterEntity(EntityManager& manager, Entity* base, DerivedType entity)
|
|
{
|
|
base->ID = EntityManager::ID++;
|
|
base->derived = entity;
|
|
|
|
manager.Entities.PushBack(*base);
|
|
|
|
auto* ptr = (EntityTemplate*)ArenaPushSize(manager.by_type[base->derived_kind->kind].arena,
|
|
base->derived_kind->size_of, base->derived_kind->alignment,
|
|
false JULIET_DEBUG_PARAM(kEntity_type_names[base->derived_kind->kind]));
|
|
MemCopy(ptr, entity, base->derived_kind->size_of);
|
|
manager.by_type[base->derived_kind->kind].count += 1;
|
|
|
|
ptr->base = manager.Entities.Back();
|
|
|
|
if (manager.by_type[base->derived_kind->kind].array == nullptr)
|
|
{
|
|
manager.by_type[base->derived_kind->kind].array = ptr;
|
|
}
|
|
|
|
return ptr;
|
|
}
|
|
|
|
Entity* allocate_entity(EntityManager& manager, NonNullPtr<const Class> derived_type_class)
|
|
{
|
|
Assert(derived_type_class->kind < ENTITY(Count));
|
|
Assert(derived_type_class->size_of >= sizeof(EntityTemplate));
|
|
Assert(derived_type_class->alignment > 0);
|
|
Assert(derived_type_class->initialize_fct);
|
|
|
|
Entity base_template = {};
|
|
base_template.derived_kind = derived_type_class;
|
|
base_template.is_dirty = true;
|
|
|
|
manager.Entities.PushBack(base_template);
|
|
Entity* base_ptr = manager.Entities.Back();
|
|
Assert(base_ptr);
|
|
|
|
typed_entity_array& typed_array = manager.by_type[derived_type_class->kind];
|
|
Assert(typed_array.arena);
|
|
|
|
void* derived = ArenaPushSize(typed_array.arena, derived_type_class->size_of, derived_type_class->alignment,
|
|
false JULIET_DEBUG_PARAM(kEntity_type_names[derived_type_class->kind]));
|
|
Assert(derived);
|
|
derived_type_class->initialize_fct(derived);
|
|
|
|
auto* derived_template = (EntityTemplate*)derived;
|
|
|
|
base_ptr->derived = derived;
|
|
derived_template->base = base_ptr;
|
|
|
|
if (typed_array.array == nullptr)
|
|
{
|
|
typed_array.array = derived_template;
|
|
}
|
|
typed_array.count += 1;
|
|
|
|
return base_ptr;
|
|
}
|
|
|
|
void UpdateEntityManager(EntityManager& manager)
|
|
{
|
|
// Todo : inert by definition dont move, but this is for test
|
|
auto& by_type = manager.by_type[ENTITY(Inert)];
|
|
for (index_t i = 0; i < by_type.count; ++i)
|
|
{
|
|
Inert* inert = reinterpret_cast<Inert*>(by_type.array) + i;
|
|
if (inert->MeshInstance != indexMax)
|
|
{
|
|
SetMeshInstanceTransform(inert->MeshInstance,
|
|
MatrixTranslation(inert->base->position.x, inert->base->position.y,
|
|
inert->base->position.z));
|
|
}
|
|
}
|
|
}
|
|
|
|
Entity* deserialize_entity(Archive& ar, EntityManager& manager)
|
|
{
|
|
Assert(ar.loading);
|
|
|
|
String class_name;
|
|
SERIALIZE(ar, Class, class_name);
|
|
|
|
NonNullPtr<const Class> class_ptr = find_class_by_name(class_name);
|
|
|
|
NonNullPtr<Entity> entity_base = allocate_entity(manager, class_ptr);
|
|
|
|
serialize(ar, entity_base);
|
|
|
|
if (entity_base->ID >= EntityManager::ID)
|
|
{
|
|
EntityManager::ID = entity_base->ID + 1;
|
|
}
|
|
|
|
entity_base->is_dirty = false;
|
|
}
|