AbstractGameObject.h

#pragma once
 
#include "experimental/ser/SerializerScheme.h"
#include "spark/patterns/Composite.h"
 
namespace spark::core
{
    class GameObject;
}
 
namespace spark::core::details
{
    template <typename Impl>
    struct GameObjectDeleter;
 
    template <typename Impl>
    class AbstractGameObject : public patterns::Composite<GameObject, GameObjectDeleter>
    {
        friend class spark::core::GameObject;
        SPARK_ALLOW_PRIVATE_SERIALIZATION
 
    public:
        explicit AbstractGameObject(GameObject* parent = nullptr);
        ~AbstractGameObject() override;
 
        AbstractGameObject(const AbstractGameObject& other) = delete;
        AbstractGameObject(AbstractGameObject&& other) noexcept = default;
        AbstractGameObject& operator=(const AbstractGameObject& other) = delete;
        AbstractGameObject& operator=(AbstractGameObject&& other) noexcept = default;
 
        void onSpawn();
 
        void onUpdate(float dt);
 
        void onDestroyed();
 
    private:
        bool m_initialized = false;
        std::unordered_map<rtti::RttiBase*, std::pair<Component*, bool>> m_components;
    };
 
    template <typename Impl>
    struct GameObjectDeleter
    {
        inline static std::vector<AbstractGameObject<GameObject>*> objectsToDestroy;
 
        static void DeleteMarkedObjects()
        {
            for (std::size_t i = 0; i < objectsToDestroy.size(); i++)
                delete objectsToDestroy[i];
            objectsToDestroy.clear();
        }
 
        void operator()(Impl* ptr, const bool immediate) const
        {
            static_cast<AbstractGameObject<GameObject>*>(ptr)->onDestroyed();
            if (immediate)
                delete ptr;
            else
                objectsToDestroy.push_back(ptr);
        }
 
        void operator()(Impl* ptr) const
        {
            operator()(ptr, true);
        }
    };
}
 
#include "spark/core/impl/AbstractGameObject.h"