GameObject.hpp

Go to the documentation of this file.

#ifndef _GAMEOBJECT_H_
#define _GAMEOBJECT_H_
 
#include "Object.hpp"
#include <Core/Logger.hpp>
#include <ECS/Component.hpp>
#include <Utility/Container/List.hpp>
#include <Memory/RefPtr.hpp>
#include <type_traits>
#include <string>
 
namespace Sleak {
    namespace Math {class Vector3D;};
    class SceneBase;
    /// Scene entity holding components and an optional parent/child transform
    /// hierarchy. Scene owns the instance; destroy via Scene::DestroyObject().
    ///
    /// A GameObject on its own does nothing. Behavior comes from the
    /// components attached to it: a TransformComponent for placement, a
    /// MeshComponent and MaterialComponent to be drawn, a ColliderComponent
    /// and RigidbodyComponent to be simulated, and your own Component
    /// subclasses for gameplay.
    ///
    /// AddComponent<T>() constructs the component in place, forwarding
    /// extra arguments to its constructor after the owner pointer. Only one
    /// component of a given type is allowed per object: a second
    /// AddComponent<T>() logs a warning and does nothing. GetComponent<T>()
    /// resolves through `dynamic_cast`, so it also matches subclasses.
    ///
    /// The scene that received the object through SceneBase::AddObject()
    /// owns it. Never `delete` a GameObject. Use SceneBase::DestroyObject()
    /// for deferred destruction, which is what you want while iterating, or
    /// SceneBase::RemoveObject() for immediate destruction.
    ///
    /// A parent owns every child that was not itself added to a scene, so a
    /// hierarchy built with SetParent() (for example by ModelLoader) only
    /// needs its root added. Deleting a parent deletes those children too.
    ///
    /// Camera, Light, and its subclasses all derive from GameObject, so
    /// they are added and found the same way as anything else.
    ///
    /// @code{.cpp}
    /// auto* crate = Sleak::GameObject::CreateCube(
    ///     Sleak::Math::Vector3D(0.0f, 1.0f, 0.0f));
    /// crate->SetTag("Destructible");
    ///
    /// crate->AddComponent<Sleak::MaterialComponent>(
    ///     Sleak::RefPtr<Sleak::Material>(new Sleak::Material()));
    /// crate->AddComponent<Sleak::RigidbodyComponent>(
    ///     Sleak::BodyType::Dynamic);
    ///
    /// if (auto* t = crate->GetComponent<Sleak::TransformComponent>()) {
    ///     t->SetScale(Sleak::Math::Vector3D(2.0f, 2.0f, 2.0f));
    /// }
    ///
    /// AddObject(crate);          // the scene now owns it
    /// @endcode
    ///
    /// @see Component, SceneBase, TransformComponent, MeshComponent,
    ///      MaterialComponent, Camera
    /// @ingroup scene
    class ENGINE_API GameObject : public Object {
    public:
        GameObject(const std::string& name = "GameObject")
            : Object(name), m_isActive(true), bIsInitialized(false),
              m_pendingDestroy(false), m_parent(nullptr) {}
 
        ~GameObject() override;
 
        /// Constructs and attaches a component of type T. Warns and no-ops if one already exists.
        template<typename T, typename... Args>
        void AddComponent(Args&&... args) {
            static_assert(std::is_base_of<Component, T>::value, "T must derive from Component!");
 
            if (GetComponent<T>() != nullptr) {
                SLEAK_WARN("The component already exists!");
                return;
            }
 
            RefPtr<Component> newComponent = RefPtr<T>(new T(this, std::forward<Args>(args)...));
            if (bIsInitialized) InitializeComponent(newComponent.get());
            Components.add(std::move(newComponent));
        }
 
        /// Destroys and detaches the first component of type T, if present.
        template<typename T>
        void RemoveComponent() {
            static_assert(std::is_base_of<Component, T>::value, "T must derive from Component!");
 
            for (size_t i = 0; i < Components.GetSize(); ++i) {
                if (dynamic_cast<T*>(Components[i].get()) != nullptr) {
                    Components[i]->OnDestroy();
                    Components.erase(i);
                    break;
                }
            }
        }
 
        /// Finds the first attached component of type T, or nullptr.
        template <typename T>
        T* GetComponent() {
            static_assert(std::is_base_of_v<Component, T>,
                          "T must derive from Component!");
 
            for (size_t i = 0; i < Components.GetSize(); ++i) {
                Component* rawPtr = Components[i].get();
                if (!rawPtr) continue;
 
                T* component = dynamic_cast<T*>(rawPtr);
                if (component) return component;
            }
 
            return nullptr;
        }
 
        /// True if a component of type T is attached.
        template <typename T>
        bool HasComponent() {
            static_assert(std::is_base_of_v<Component, T>,
                          "T must derive from Component!");
            return GetComponent<T>() != nullptr;
        }
 
        /// Initializes the object, components and children; repeats no-op.
        virtual void Initialize();
        bool IsInitialized() const { return bIsInitialized; }
        virtual void Update(float deltaTime);
        virtual void FixedUpdate(float fixedDeltaTime);
        virtual void LateUpdate(float deltaTime);
 
        /// Enables or disables the object, firing OnEnable/OnDisable on its components.
        void SetActive(bool active);
        bool IsActive() const { return m_isActive; }
 
        void SetTag(const std::string& tag) { m_tag = tag; }
        const std::string& GetTag() const { return m_tag; }
 
        /// Reparents this object, updating both the old and new parent's child lists.
        void SetParent(GameObject* parent);
        GameObject* GetParent() const { return m_parent; }
        const List<GameObject*>& GetChildren() const { return m_children; }
        void AddChild(GameObject* child);
        void RemoveChild(GameObject* child);
        bool HasParent() const { return m_parent != nullptr; }
        bool HasChildren() const { return m_children.GetSize() > 0; }
        /// True once a scene took ownership through SceneBase::AddObject().
        bool IsOwnedByScene() const { return m_ownedByScene; }
 
        virtual bool IsLight() const { return false; }
 
        /// Flags the object for deferred destruction on the next scene pass.
        void MarkForDestroy() { m_pendingDestroy = true; }
        bool IsPendingDestroy() const { return m_pendingDestroy; }
 
        /// Built-in primitive factories, mainly for prototyping and debug scenes.
        static GameObject* CreatePlane(Math::Vector3D position, int width = 100, int height = 100);
        static GameObject* CreateCube(Math::Vector3D position);
        static GameObject* CreateSphere(Math::Vector3D position, int stack = 16, int slices = 16);
        static GameObject* CreateCapsule(Math::Vector3D position, int segments = 16, int rings = 8, float height = 1, float radius = 0.5);
        static GameObject* CreateCylinder(Math::Vector3D position, int segments = 16, float height = 1, float radius = 0.5);
        static GameObject* CreateTorus(Math::Vector3D position, int segments = 16, int rings = 8, float innerRadius = 8, float outerRadius = 9);
 
    protected:
        bool bIsInitialized;
 
    private:
        bool m_isActive;
        bool m_pendingDestroy;
        bool m_ownedByScene = false;
        std::string m_tag = "Untagged";
 
        List<RefPtr<Component>> Components;
 
        // Hierarchy
        GameObject* m_parent;
        List<GameObject*> m_children;
 
        /// Calls OnDestroy() on and drops every attached component.
        void DestroyComponents();
        /// Initializes a component once, then enables it if active.
        void InitializeComponent(Component* component);
 
        friend class SceneBase;
    };
}
 
#endif // _GAMEOBJECT_H_