Can you split the addComponent function into smaller functions? template<class C,…
- User
Can you split the addComponent function into smaller functions? template<class C, typename... Args> C* ECS::AddComponent(const uint32_t entityId, Args&&... args) { auto newComponentID = Component::GetTypeID();
if (componentMasks[entityId].HasComponent(newComponentID)) { return nullptr; // Component already exists for the entity } componentMasks[entityId].AddComponent(newComponentID); Archetype* newArchetype = nullptr; C* newComponent = nullptr; Record& record = entityArchetypeMap[entityId]; Archetype* oldArchetype = record.archetype; auto& newComponentMask = componentMasks[entityId]; newArchetype = GetArchetype(componentMasks[entityId]); // if the entity already has components if (oldArchetype) { auto oldComponentMask = oldArchetype->componentMask; std::size_t entityIndex = std::find( oldArchetype->entityIds.begin(), oldArchetype->entityIds.end() - 1, entityId ) - oldArchetype->entityIds.begin(); std::size_t index = 0; std::size_t j = 0; for (std::size_t i = 0; i < newComponentMask.GetBitsetMask().size() - 1; ++i) { if (newComponentMask.GetBitsetMask().test(i)) { const ComponentBase* const componentBase = componentMap[i]; const std::size_t newComponentDataSize = componentBase->GetSize(); std::size_t currentSize = newArchetype->entityIds.size() * newComponentDataSize; std::size_t newSize = currentSize + newComponentDataSize; if (newSize > newArchetype->componentDataSize[index]) { Reallocate(componentBase, newComponentDataSize, newArchetype, index); } if (oldComponentMask.HasComponent(i)) { TransferComponentData(componentBase, oldArchetype, newArchetype, index, j, entityIndex); ++j; } else { /*newComponent = */ new (&newArchetype->componentData[index][currentSize]) C(std::forward<Args>(args)...); } index++; } } auto lastEntity = oldArchetype->entityIds.size() - 1; // If the old archetype still has entities in if (!oldArchetype->entityIds.empty() && entityIndex < oldArchetype->entityIds.size()) { std::iter_swap(oldArchetype->entityIds.begin() + entityIndex, oldArchetype->entityIds.begin() + lastEntity); for (std::size_t i = 0, j = 0, index = 0; i < oldComponentMask.GetBitsetMask().size() - 1; ++i) { if (oldComponentMask.GetBitsetMask().test(i)) { const ComponentBase* const componentBase = componentMap[i]; SwapComponentData(componentBase, oldArchetype, index, entityIndex); ++index; } } // swap the entity leaving the archetype with the one at the end of the list before deleting the leaving entity by popping oldArchetype->entityIds.pop_back(); } } // If this is the first time we're adding a component to this entity else { // Get size of the new component const ComponentBase* const newComponentBase = componentMap[newComponentID]; const std::size_t& newComponentDataSize = newComponentBase->GetSize(); std::size_t currentSize = newArchetype->entityIds.size() * newComponentDataSize; std::size_t newSize = currentSize + newComponentDataSize; //Reallocate(newComponentBase, newArchetype, 0); if (newSize > newArchetype->componentDataSize[0]) { Reallocate(newComponentBase, newComponentDataSize, newArchetype, 0); } newComponent = new (&newArchetype->componentData[0][currentSize]) C(std::forward<Args>(args)...); } newArchetype->entityIds.push_back(entityId); record.index = newArchetype->entityIds.size() - 1; record.archetype = newArchetype; return newComponent;}void ECS::Reallocate(const ComponentBase* compbase, const size_t& newCompSize, Archetype* arch, size_t index) { arch->componentDataSize[index] *= 2; arch->componentDataSize[index] += newCompSize;
unsigned char* newData = new unsigned char[arch->componentDataSize[index]]; for (auto e = 0; e < arch->entityIds.size(); ++e) { compbase->MoveData(&arch->componentData[index][e * newCompSize], &newData[e * newCompSize]); compbase->DestroyData(&arch->componentData[index][e * newCompSize]); } delete[] arch->componentData[index]; arch->componentData[index] = newData;}
void ECS::TransferComponentData(const ComponentBase* compbase, Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex) { const std::size_t compSize = compbase->GetSize(); std::size_t currentSize = toArch->entityIds.size() * compSize;
compbase->MoveData(&fromArch->componentData[j][entityIndex * compSize], &toArch->componentData[i][currentSize]); compbase->DestroyData(&fromArch->componentData[j][entityIndex * compSize]);}
#include "ComponentMask.h"
typedef unsigned char* ComponentData; typedef std::vector ArchetypeId;
struct Archetype { ComponentMask componentMask; std::vector componentData; std::vector<uint32_t> entityIds; std::vectorstd::size_t componentDataSize; };
- Assistant
template<class C, typename... Args> C* ECS::AddComponent(const uint32_t entityId, Args&&... args) { // 1. Get the component type ID and check if the component already exists for the entity auto newComponentID = GetComponentTypeID();
if (HasComponentAlready(entityId, newComponentID)) { return nullptr; } // 2. Update the component mask for the entity and get the new archetype componentMasks[entityId].AddComponent(newComponentID); Archetype* newArchetype = GetArchetype(componentMasks[entityId]); // 3. Get and store the record of the entity Record& record = entityArchetypeMap[entityId]; Archetype* oldArchetype = record.archetype; C* newComponent = nullptr; // 4. If the entity has existing components, transfer or add the new component if (oldArchetype) { TransferOrAddNewComponent<C>(entityId, newArchetype, oldArchetype, std::forward<Args>(args)...); } // 5. If the entity has no existing components, allocate and add the new component else { newComponent = AllocateAndAddComponent<C>(newArchetype, std::forward<Args>(args)...); } // 6. Update the record and return the new component UpdateRecord(entityId, newArchetype, record); return newComponent;}
template uint32_t ECS::GetComponentTypeID() { auto newComponentID = Component::GetTypeID(); return newComponentID; }
bool ECS::HasComponentAlready(const uint32_t entityId, uint32_t componentTypeID) { return componentMasks[entityId].HasComponent(componentTypeID); }
template<class C, typename... Args> void ECS::TransferOrAddNewComponent(const uint32_t entityId, Archetype* newArchetype, Archetype* oldArchetype, Args&&... args) { std::size_t entityIndex = GetEntityIndex(oldArchetype, entityId); TransferExistingComponents(entityIndex, oldArchetype, newArchetype); AddNewComponent(entityIndex, oldArchetype, newArchetype, std::forward(args)...); }
template std::size_t ECS::GetEntityIndex(Archetype* archetype, uint32_t entityId) { return std::find( archetype->entityIds.begin(), archetype->entityIds.end() - 1, entityId ) - archetype->entityIds.begin(); }
template<class C, typename... Args> C* ECS::AllocateAndAddComponent(Archetype* archetype, Args&&... args) { const ComponentBase* const newComponentBase = componentMap[GetComponentTypeID()]; const std::size_t& newComponentDataSize = newComponentBase->GetSize();
std::size_t currentSize = archetype->entityIds.size() * newComponentDataSize; std::size_t newSize = currentSize + newComponentDataSize; if (newSize > archetype->componentDataSize[0]) { Reallocate(newComponentBase, newComponentDataSize, archetype, 0); } C* newComponent = new (&archetype->componentData[0][currentSize]) C(std::forward<Args>(args)...); return newComponent;}
void ECS::UpdateRecord(uint32_t entityId, Archetype* archetype, Record& record) { archetype->entityIds.push_back(entityId); record.index = archetype->entityIds.size() - 1; record.archetype = archetype; }
- User
Where's the transferexistingcomponents function?
- Assistant
Apologies for the oversight. Here is the
TransferExistingComponentsfunction:void ECS::TransferExistingComponents(std::size_t entityIndex, Archetype* oldArchetype, Archetype* newArchetype) { auto& newComponentMask = componentMasks[entityId]; auto oldComponentMask = oldArchetype->componentMask; std::size_t index = 0; std::size_t j = 0; for (std::size_t i = 0; i < newComponentMask.GetBitsetMask().size() - 1; ++i) { if (newComponentMask.GetBitsetMask().test(i)) { const ComponentBase* const componentBase = componentMap[i]; const std::size_t newComponentDataSize = componentBase->GetSize(); std::size_t currentSize = newArchetype->entityIds.size() * newComponentDataSize; std::size_t newSize = currentSize + newComponentDataSize; if (newSize > newArchetype->componentDataSize[index]) { Reallocate(componentBase, newComponentDataSize, newArchetype, index); } if (oldComponentMask.HasComponent(i)) { TransferComponentData(componentBase, oldArchetype, newArchetype, index, j, entityIndex); ++j; } index++; } } auto lastEntity = oldArchetype->entityIds.size() - 1; // If the old archetype still has entities in if (!oldArchetype->entityIds.empty() && entityIndex < oldArchetype->entityIds.size()) { std::iter_swap(oldArchetype->entityIds.begin() + entityIndex, oldArchetype->entityIds.begin() + lastEntity); for (std::size_t i = 0, j = 0, index = 0; i < oldComponentMask.GetBitsetMask().size() - 1; ++i) { if (oldComponentMask.GetBitsetMask().test(i)) { const ComponentBase* const componentBase = componentMap[i]; SwapComponentData(componentBase, oldArchetype, index, entityIndex); ++index; } } // swap the entity leaving the archetype with the one at the end of the list before deleting the leaving entity by popping oldArchetype->entityIds.pop_back(); } }This function transfers existing components from the old archetype to the new archetype and removes the entity from the old archetype if needed.
- User
template<class C, typename… Args> void ECS::TransferOrAddNewComponent(const uint32_t entityId, Archetype* newArchetype, Archetype* oldArchetype, Args&&… args) { std::size_t entityIndex = GetEntityIndex(oldArchetype, entityId); TransferExistingComponents(entityIndex, oldArchetype, newArchetype); AddNewComponent(entityIndex, oldArchetype, newArchetype, std::forward(args)…); } explains how addNewComponent works with the original function?
- Assistant
I apologize for the confusion in the previous implementation. Here's the corrected version of
TransferOrAddNewComponentfunction and theAddNewComponentfunction:template<class C, typename... Args> void ECS::TransferOrAddNewComponent(const uint32_t entityId, Archetype* newArchetype, Archetype* oldArchetype, Args&&... args) { std::size_t entityIndex = GetEntityIndex(oldArchetype, entityId); TransferExistingComponents(entityIndex, oldArchetype, newArchetype); AddNewComponent<C>(entityId, newArchetype, oldArchetype, std::forward<Args>(args)...); } template<class C, typename... Args> C* ECS::AddNewComponent(uint32_t entityId, Archetype* newArchetype, Archetype* oldArchetype, Args&&... args) { auto& newComponentMask = componentMasks[entityId]; C* newComponent = nullptr; std::size_t index = 0; for (std::size_t i = 0; i < newComponentMask.GetBitsetMask().size() - 1; ++i) { if (newComponentMask.GetBitsetMask().test(i)) { const ComponentBase* const componentBase = componentMap[i]; const std::size_t newComponentDataSize = componentBase->GetSize(); std::size_t currentSize = newArchetype->entityIds.size() * newComponentDataSize; std::size_t newSize = currentSize + newComponentDataSize; if (newSize > newArchetype->componentDataSize[index]) { Reallocate(componentBase, newComponentDataSize, newArchetype, index); } if (i == Component<C>::GetTypeID()) { newComponent = new (&newArchetype->componentData[index][currentSize]) C(std::forward<Args>(args)...); } index++; } } return newComponent; }In the
TransferOrAddNewComponentfunction, after transferring the existing components, we call theAddNewComponentfunction. TheAddNewComponentfunction iterates through the new component mask and checks if the current component ID matches the component type ID of the new component we want to add. If it matches, it allocates and constructs the new component at the correct position in the new archetype's component data. Finally, it returns the new component. - User
Can you do the same for the RemoveComponent function? template void ECS::RemoveComponent(const uint32_t entityId) { auto newComponentID = Component::GetTypeID();
if (!IsComponentRegistered<C>()) { return; }; if (!componentMasks[entityId].HasComponent(newComponentID)) { return; }; componentMasks[entityId].RemoveComponent(newComponentID); Record& record = entityArchetypeMap[entityId]; auto oldArchetype = record.archetype; if (!oldArchetype) { return; }; auto oldComponentMask = oldArchetype->componentMask; auto newArchetype = GetArchetype(componentMasks[entityId]); auto newComponentMask = newArchetype->componentMask; auto lastEntity = oldArchetype->entityIds.size() - 1; std::size_t entityIndex = GetEntityIndex(oldArchetype, entityId); std::size_t index = 0; std::size_t j = 0; for (std::size_t i = 0; i < newComponentMask.GetBitsetMask().size(); ++i) { //for (std::size_t i = oldComponentMask.GetBitsetMask().size() - 1, j = i - 1; j >= 0; --j) { if (newComponentMask.GetBitsetMask().test(i)) { const ComponentBase* const componentBase = componentMap[i]; const std::size_t newComponentDataSize = componentBase->GetSize(); std::size_t currentSize = newArchetype->entityIds.size() * newComponentDataSize; std::size_t newSize = currentSize + newComponentDataSize; if (newSize > newArchetype->componentDataSize[index]) { Reallocate(componentBase, newComponentDataSize, newArchetype, index); } if (oldComponentMask.HasComponent(i)) { RemoveAndAllocateComponentData(componentBase, oldArchetype, newArchetype, index, j, entityIndex); j++; } else { componentBase->MoveData(&oldArchetype->componentData[j][lastEntity * newComponentDataSize], &oldArchetype->componentData[j][entityIndex * newComponentDataSize]); ComponentBase* removeWrapper = componentMap[i]; removeWrapper->DestroyData( &oldArchetype->componentData[j][record.index * sizeof(C)]); } index++; } } //std::swap(oldArchetype->entityIds[entityIndex], oldArchetype->entityIds[lastEntity]); std::iter_swap(oldArchetype->entityIds.begin() + entityIndex, oldArchetype->entityIds.begin() + lastEntity); oldArchetype->entityIds.pop_back(); newArchetype->entityIds.push_back(entityId); record.index = newArchetype->entityIds.size() - 1; record.archetype = newArchetype;} void ECS::Reallocate(const ComponentBase* compbase, const size_t& newCompSize, Archetype* arch, size_t index) { arch->componentDataSize[index] *= 2; arch->componentDataSize[index] += newCompSize;
unsigned char* newData = new unsigned char[arch->componentDataSize[index]]; for (auto e = 0; e < arch->entityIds.size(); ++e) { compbase->MoveData(&arch->componentData[index][e * newCompSize], &newData[e * newCompSize]); compbase->DestroyData(&arch->componentData[index][e * newCompSize]); } delete[] arch->componentData[index]; arch->componentData[index] = newData;}void ECS::RemoveAndAllocateComponentData(const ComponentBase* compbase, Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex) { const std::size_t compSize = compbase->GetSize(); std::size_t currentSize = toArch->entityIds.size() * compSize; const auto lastEntity = fromArch->entityIds.size() - 1;
compbase->MoveData(&fromArch->componentData[j][entityIndex * compSize], &toArch->componentData[i][currentSize]); if (entityIndex != lastEntity) { compbase->MoveData(&fromArch->componentData[j][lastEntity * compSize], &fromArch->componentData[j][entityIndex * compSize]); } compbase->DestroyData(&fromArch->componentData[j][lastEntity * compSize]);}
- Assistant
I have split the
RemoveComponentfunction into smaller functions. Here's the updated version:template<class C> void ECS::RemoveComponent(const uint32_t entityId) { auto componentID = GetComponentTypeID<C>(); if (!IsComponentRegistered<C>() || !HasComponentAlready(entityId, componentID)) { return; } componentMasks[entityId].RemoveComponent(componentID); Record& record = entityArchetypeMap[entityId]; Archetype* oldArchetype = record.archetype; if (!oldArchetype) { return; } Archetype* newArchetype = GetArchetype(componentMasks[entityId]); std::size_t entityIndex = GetEntityIndex(oldArchetype, entityId); TransferComponentsAndRemove(entityIndex, oldArchetype, newArchetype); UpdateRecord(entityId, newArchetype, record); } template<class C> void ECS::TransferComponentsAndRemove(std::size_t entityIndex, Archetype* oldArchetype, Archetype* newArchetype) { auto oldComponentMask = oldArchetype->componentMask; auto newComponentMask = newArchetype->componentMask; std::size_t index = 0; std::size_t j = 0; for (std::size_t i = 0; i < newComponentMask.GetBitsetMask().size(); ++i) { if (newComponentMask.GetBitsetMask().test(i)) { const ComponentBase* const componentBase = componentMap[i]; const std::size_t componentDataSize = componentBase->GetSize(); if (oldComponentMask.HasComponent(i)) { RemoveAndAllocateComponentData(componentBase, oldArchetype, newArchetype, index, j, entityIndex); j++; } else { RemoveComponentData(componentBase, oldArchetype, index, entityIndex); } index++; } } std::iter_swap(oldArchetype->entityIds.begin() + entityIndex, oldArchetype->entityIds.end() - 1); oldArchetype->entityIds.pop_back(); } void ECS::RemoveAndAllocateComponentData(const ComponentBase* componentBase, Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex) { const std::size_t componentSize = componentBase->GetSize(); std::size_t currentSize = toArch->entityIds.size() * componentSize; const auto lastEntity = fromArch->entityIds.size() - 1; componentBase->MoveData(&fromArch->componentData[j][entityIndex * componentSize], &toArch->componentData[i][currentSize]); if (entityIndex != lastEntity) { componentBase->MoveData(&fromArch->componentData[j][lastEntity * componentSize], &fromArch->componentData[j][entityIndex * componentSize]); } componentBase->DestroyData(&fromArch->componentData[j][lastEntity * componentSize]); } void ECS::RemoveComponentData(const ComponentBase* componentBase, Archetype* archetype, size_t index, size_t entityIndex) { const std::size_t componentSize = componentBase->GetSize(); const auto lastEntity = archetype->entityIds.size() - 1; componentBase->MoveData(&archetype->componentData[index][lastEntity * componentSize], &archetype->componentData[index][entityIndex * componentSize]); componentBase->DestroyData(&archetype->componentData[index][lastEntity * componentSize]); }The
RemoveComponentfunction now callsTransferComponentsAndRemoveto transfer the remaining components and remove the target component. TheRemoveAndAllocateComponentDatafunction is used to transfer components that need to be moved to the new archetype, while theRemoveComponentDatafunction is used to remove the target component from the old archetype. Finally, theUpdateRecordfunction is called to update the entity's record. - User
When to and when not to use auto?
- Assistant
autois a convenient feature in C++ that allows the compiler to deduce the type of a variable automatically based on its initializer. However, it is important to know when to useautoand when not to use it. Here are some guidelines:When to use
auto:-
When the type is complex or long to write, such as iterators or lambda functions:
// Instead of writing the full type std::vector<int>::iterator it = myVector.begin(); // Use auto for simplicity auto it = myVector.begin(); -
When you want to avoid repeating the type information, such as when declaring a variable with a cast or with a function that returns the desired type:
// Instead of repeating the type MyClass obj = static_cast<MyClass>(someFunction()); // Use auto to avoid repetition auto obj = static_cast<MyClass>(someFunction()); -
When you are working with templates and the exact type is not known at compile-time.
template <typename T> void processVector(const std::vector<T>& vec) { for (auto& item : vec) { // Do something with item } }
When not to use
auto:-
When the type is not clear from the context, which can make the code harder to read and understand:
// It's not clear what type 'value' is auto value = someFunction();In this case, it's better to write the actual type to improve code readability:
int value = someFunction(); -
When you want to ensure a specific type, and using
automight lead to unintended type deduction:// You want 'value' to be a double, but someFunction() returns an int auto value = someFunction(); // 'value' will be deduced as an intIn this case, explicitly specify the desired type:
double value = someFunction(); -
When using
automight cause unintended conversions, especially when working with numerical types:auto result = 5 / 2; // result will be deduced as an int, not a doubleTo avoid this, specify the desired type or use a cast:
double result = 5.0 / 2;
In summary, use
autowhen it makes the code simpler, easier to read, or more generic (in the case of templates), but avoid it when it can make the code harder to understand or cause unintended type deductions or conversions. -