GameObject.h

#pragma once
 
#include "spark/core/Component.h"
#include "spark/core/Export.h"
#include "spark/core/details/AbstractGameObject.h"
 
#include "experimental/ser/SerializerScheme.h"
#include "spark/base/Macros.h"
#include "spark/rtti/HasRtti.h"
 
#include <vector>
 
namespace spark::core::components
{
    class Transform;
}
 
namespace spark::core
{
    class SPARK_CORE_EXPORT GameObject : public rtti::HasRtti, public details::AbstractGameObject<GameObject>
    {
        DECLARE_SPARK_RTTI(GameObject)
        SPARK_ALLOW_PRIVATE_SERIALIZATION
 
    public:
        template <typename T = GameObject, typename... Args> requires std::is_base_of_v<GameObject, T>
        static T* Instantiate(std::string name, GameObject* parent, Args&&... args);
 
        static void Destroy(GameObject* object, bool immediate = false);
 
        static GameObject* FindById(GameObject* root, const lib::Uuid& uuid);
 
        static GameObject* FindByName(GameObject* root, const std::string& name);
 
    public:
        explicit GameObject(std::string name, GameObject* parent = nullptr);
 
        GameObject(const GameObject& other) = delete;
        GameObject(GameObject&& other) noexcept = default;
        GameObject& operator=(const GameObject& other) = delete;
        GameObject& operator=(GameObject&& other) noexcept = default;
 
        [[nodiscard]] const lib::Uuid& uuid() const;
 
        [[nodiscard]] const std::string& name() const;
 
        [[nodiscard]] components::Transform* transform() const;
 
        void addComponent(Component* component, bool managed = false);
 
        template <typename T, typename... Args> requires std::is_base_of_v<Component, T>
        void addComponent(Args&&... args);
 
        void removeComponent(Component* component);
 
        template <typename T> requires std::is_base_of_v<Component, T>
        void removeComponent();
 
        template <typename T> requires std::is_base_of_v<Component, T>
        [[nodiscard]] bool hasComponent() const;
 
        [[nodiscard]] std::vector<Component*> components() const;
 
        template <typename T> requires std::is_base_of_v<Component, T>
        [[nodiscard]] std::vector<T*> componentsInChildren() const;
 
        template <typename T> requires std::is_base_of_v<Component, T>
        [[nodiscard]] T* component() const;
 
        template <typename T> requires std::is_base_of_v<Component, T>
        [[nodiscard]] T* componentInChildren() const;
 
        template <typename T> requires std::is_base_of_v<Component, T>
        [[nodiscard]] T* componentInParent() const;
 
        virtual void onSpawn() {}
 
        virtual void onUpdate(float dt) { SPARK_UNUSED(dt); }
 
        virtual void onDestroyed() {}
 
    public:
        bool isShown = true;
 
    private:
        lib::Uuid m_uuid;
        std::string m_name;
    };
}
 
IMPLEMENT_SPARK_RTTI(spark::core::GameObject)
 
#include "spark/core/impl/GameObject.h"