Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

Is there a way to combine these functions or abstract them into a struct/class? I feel…

  1. User

    Is there a way to combine these functions or abstract them into a struct/class? I feel like there a lot of similarities between them. void ECS::TransferComponentData(Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex) { const ComponentBase* componentBase = componentMap[i]; const std::size_t componentDataSize = componentBase->GetSize();

    std::size_t currentSize = toArch->entityIds.size() * componentDataSize;
    
    componentBase->MoveData(&fromArch->componentData[j][entityIndex * componentDataSize],
        &toArch->componentData[i][currentSize]);
    componentBase->DestroyData(&fromArch->componentData[j][entityIndex * componentDataSize]);
    

    }

    void ECS::SwapComponentData(const size_t compTypeIndex, Archetype* arch, size_t index, size_t entityIndex) { const ComponentBase* componentBase = componentMap[compTypeIndex]; const std::size_t componentSize = componentBase->GetSize();

    const auto lastEntity = arch->entityIds.size() - 1;
    
    componentBase->MoveData(&arch->componentData[index][lastEntity * componentSize],
        &arch->componentData[index][entityIndex * componentSize]);
    componentBase->DestroyData(&arch->componentData[index][lastEntity * componentSize]);
    

    }

    void ECS::RemoveAndAllocateComponentData(const size_t compTypeIndex, Archetype* fromArchetype, Archetype* toArchetype, size_t i, size_t j, size_t entityIndex) { const ComponentBase* const componentBase = componentMap[compTypeIndex]; const std::size_t componentDataSize = componentBase->GetSize();

    size_t currentSize = toArchetype->entityIds.size() * componentDataSize;
    const size_t lastEntity = fromArchetype->entityIds.size() - 1;
    
    componentBase->MoveData(&fromArchetype->componentData[j][entityIndex * componentDataSize],
        &toArchetype->componentData[i][currentSize]);
    
    if (entityIndex != lastEntity) {
        componentBase->MoveData(&fromArchetype->componentData[j][lastEntity * componentDataSize],
            &fromArchetype->componentData[j][entityIndex * componentDataSize]);
    }
    
    componentBase->DestroyData(&fromArchetype->componentData[j][lastEntity * componentDataSize]);
    

    }

  2. Assistant

    Yes, there are similarities between these functions, and they can be abstracted into a class. Here is an example:

    class ComponentDataHandler {
    public:
        static void TransferComponentData(const ComponentBase* componentBase, Archetype* fromArch, Archetype* toArch, size_t fromIndex, size_t toIndex) {
            std::size_t componentDataSize = componentBase->GetSize();
            std::size_t currentSize = toArch->entityIds.size() * componentDataSize;
    
            componentBase->MoveData(&fromArch->componentData[fromIndex], &toArch->componentData[toIndex]);
            componentBase->DestroyData(&fromArch->componentData[fromIndex]);
        }
    
        static void SwapComponentData(const ComponentBase* componentBase, Archetype* arch, size_t index, size_t lastEntityIndex, size_t entityIndex) {
            std::size_t componentSize = componentBase->GetSize();
    
            componentBase->MoveData(&arch->componentData[index] + lastEntityIndex * componentSize, &arch->componentData[index] + entityIndex * componentSize);
            componentBase->DestroyData(&arch->componentData[index] + lastEntityIndex * componentSize);
        }
    
        static void RemoveAndAllocateComponentData(const ComponentBase* componentBase, Archetype* fromArchetype, Archetype* toArchetype, size_t fromIndex, size_t toIndex, size_t lastEntityIndex, size_t entityIndex) {
            std::size_t componentDataSize = componentBase->GetSize();
            size_t currentSize = toArchetype->entityIds.size() * componentDataSize;
    
            componentBase->MoveData(&fromArchetype->componentData[fromIndex] + entityIndex * componentDataSize, &toArchetype->componentData[toIndex] + currentSize);
    
            if (entityIndex != lastEntityIndex) {
                componentBase->MoveData(&fromArchetype->componentData[fromIndex] + lastEntityIndex * componentDataSize, &fromArchetype->componentData[fromIndex] + entityIndex * componentDataSize);
            }
    
            componentBase->DestroyData(&fromArchetype->componentData[fromIndex] + lastEntityIndex * componentDataSize);
        }
    };
    

    Now you can use this class to call the methods inside the class ECS.

    void ECS::TransferComponentData(Archetype* fromArch, Archetype* toArch, size_t i, size_t j, size_t entityIndex) {
        const ComponentBase* componentBase = componentMap[i];
        ComponentDataHandler::TransferComponentData(componentBase, fromArch, toArch, j * componentBase->GetSize(), toArch->entityIds.size() * componentBase->GetSize());
    }
    
    void ECS::SwapComponentData(const size_t compTypeIndex, Archetype* arch, size_t index, size_t entityIndex) {
        const ComponentBase* componentBase = componentMap[compTypeIndex];
        ComponentDataHandler::SwapComponentData(componentBase, arch, index * componentBase->GetSize(), (arch->entityIds.size() - 1) * componentBase->GetSize(), entityIndex * componentBase->GetSize());
    }
    
    void ECS::RemoveAndAllocateComponentData(const size_t compTypeIndex, Archetype* fromArchetype, Archetype* toArchetype, size_t i, size_t j, size_t entityIndex) {
        const ComponentBase* const componentBase = componentMap[compTypeIndex];
        ComponentDataHandler::RemoveAndAllocateComponentData(componentBase, fromArchetype, toArchetype, j * componentBase->GetSize(), i * componentBase->GetSize(), (fromArchetype->entityIds.size() - 1) * componentBase->GetSize(), entityIndex * componentBase->GetSize());
    }
    

    This way, you have abstracted the common functionality into the ComponentDataHandler class and removed repetitive code.