ComponentStore.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Exception.hpp"
#include "CeresEngine/Foundation/Container/MemoryView.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Entity/Component.hpp"
#include "CeresEngine/Entity/EntityID.hpp"
 
#include <cassert>
#include <type_traits>
 
namespace CeresEngine {
 
    class AbstractComponentStore {
    protected:
        size_t mSize = 0;
 
        size_t mCapacity = 0;
 
        size_t mChunkSize;
 
        size_t mElementSize;
 
        Vector<char*> mChunks;
 
    public:
        AbstractComponentStore(const size_t chunkSize, const size_t elementSize) : mChunkSize(chunkSize), mElementSize(elementSize) {}
 
        virtual ~AbstractComponentStore() noexcept;
 
    public:
        virtual AbstractComponent& create(EntityIndex entityIndex) = 0;
 
        virtual void destroy(EntityIndex entityIndex) = 0;
 
        virtual void copy(EntityIndex sourceEntityIndex, EntityIndex targetEntityIndex) = 0;
 
        [[nodiscard]] virtual AbstractComponent& get(EntityIndex entityIndex) = 0;
 
        [[nodiscard]] virtual const AbstractComponent& get(EntityIndex entityIndex) const = 0;
 
    public:
        [[nodiscard]] size_t getSize() const noexcept { return mSize; }
 
        [[nodiscard]] size_t getCapacity() const noexcept { return mCapacity; }
 
        [[nodiscard]] size_t getChunkSize() const noexcept { return mChunkSize; }
 
        [[nodiscard]] size_t getChunkCount() const noexcept { return mChunks.size(); }
 
    protected:
        [[nodiscard]] inline void* getRawPointer(const EntityIndex index) noexcept { return mChunks[index / mChunkSize] + (index % mChunkSize) * mElementSize; }
 
        [[nodiscard]] inline const void* getRawPointer(const EntityIndex index) const noexcept {
            return mChunks[index / mChunkSize] + (index % mChunkSize) * mElementSize;
        }
 
        void ensureMinimumSize(std::size_t size);
 
        void ensureMinimumCapacity(size_t minCapacity);
    };
 
    template<CComponent C> class ComponentStore final : public AbstractComponentStore {
    public:
        inline explicit ComponentStore(const size_t chunkSize) : AbstractComponentStore(chunkSize, (sizeof(C) / alignof(C) + 1) * alignof(C)) {}
 
        ~ComponentStore() noexcept final = default;
 
    public:
        template<typename... Args> inline C& create(const EntityIndex entityIndex, Args&&... args) noexcept(std::is_nothrow_constructible_v<C, Args...>) {
            ensureMinimumSize(entityIndex + 1);
            C* const component = getPointer(entityIndex);
            return *new(component) C(std::forward<Args>(args)...);
        }
 
        inline C& create(const EntityIndex entityIndex) final {
            if constexpr(std::is_default_constructible_v<C>) {
                ensureMinimumSize(entityIndex + 1);
                C* const component = getPointer(entityIndex);
                return *new(component) C();
            } else {
                throw RuntimeError("The component C is not default constructible!");
            }
        }
 
        inline void destroy(const EntityIndex entityIndex) final {
            C* const component = getPointer(entityIndex);
            component->~C();
        }
 
        inline void copy(const EntityIndex sourceEntityIndex, const EntityIndex targetEntityIndex) final {
            if constexpr(std::is_copy_constructible_v<C>) {
                ensureMinimumSize(targetEntityIndex + 1);
                const C* source = getPointer(sourceEntityIndex);
                C* const target = getPointer(targetEntityIndex);
                new(target) C(*source);
            } else {
                throw RuntimeError("Component is not copyable!");
            }
        }
 
        [[nodiscard]] inline C& get(const EntityIndex entityIndex) final { return *getPointer(entityIndex); }
 
        [[nodiscard]] inline const C& get(const EntityIndex entityIndex) const final { return *getPointer(entityIndex); }
 
    private:
        [[nodiscard]] inline C* getPointer(const EntityIndex index) noexcept { return reinterpret_cast<C*>(getRawPointer(index)); }
 
        [[nodiscard]] inline const C* getPointer(const EntityIndex index) const noexcept { return reinterpret_cast<const C*>(getRawPointer(index)); }
    };
 
} // namespace CeresEngine