Actor.h

#pragma once
#include "Engine/Entity/Entity.h"
#include "Engine/World/SceneGraph.h"
 
#include <memory>
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
 
namespace Engine::Components
{
    class Scene;
}  // namespace Engine::Components
 
namespace Engine
{
    class EngineKern;
 
    namespace Core
    {
        class PhysicsEngine;
    }  // namespace Core
}  // namespace Engine
 
namespace Engine::Entities
{
    class Scene;
    struct SpawnContext;
 
    namespace detail
    {
        template <typename T, typename... Args>
        struct ConstructibleWithSceneEntityFirstNodeRest : std::false_type
        {
        };

        template <typename T, typename First, typename... Rest>
        struct ConstructibleWithSceneEntityFirstNodeRest<T, First, Rest...>
          : std::bool_constant<std::is_constructible_v<
                T,
                Scene *,
                entt::entity &,
                First,
                std::shared_ptr<SceneNode>,
                Rest...>>
        {
        };
 
        template <typename T, typename... Args>
        concept ConstructibleWithActorContext =
            std::is_base_of_v<Components::Logic, T> &&
            ( ConstructibleWithSceneEntityFirstNodeRest<T, Args...>::value ||
              std::is_constructible_v<T, Scene *, entt::entity &, std::shared_ptr<SceneNode>, Args...> ||
              std::is_constructible_v<T, Scene *, entt::entity &, Args..., std::shared_ptr<SceneNode>> ||
              std::is_constructible_v<T, Scene *, std::shared_ptr<SceneNode>, Args...> ||
              std::is_constructible_v<T, Scene *, entt::entity &, Args...> ||
              std::is_constructible_v<T, Scene *, Args...> );
    }  // namespace detail

    class Actor : public Entity
    {
        friend class Scene;
 
    public:
        explicit Actor( const SpawnContext & context );

        ~Actor() override = default;
 
        using Entity::addComponent;

        template <typename T, typename... Args>
        requires detail::ConstructibleWithActorContext<T, Args...>
        T * addComponent( Args &&... args )
        {
            if constexpr ( detail::ConstructibleWithSceneEntityFirstNodeRest<T, Args...>::value )
            {
                return addComponentWithSceneEntityFirstNodeRest<T>( std::forward<Args>( args )... );
            }
            else if constexpr ( std::is_constructible_v<
                                    T,
                                    Scene *,
                                    entt::entity &,
                                    std::shared_ptr<SceneNode>,
                                    Args...> )
            {
                return Entity::addComponent<T>(
                    getOwningScene(), data_, getSceneNode(), std::forward<Args>( args )...
                );
            }
            else if constexpr ( std::is_constructible_v<
                                    T,
                                    Scene *,
                                    entt::entity &,
                                    Args...,
                                    std::shared_ptr<SceneNode>> )
            {
                return Entity::addComponent<T>(
                    getOwningScene(), data_, std::forward<Args>( args )..., getSceneNode()
                );
            }
            else if constexpr ( std::is_constructible_v<T, Scene *, std::shared_ptr<SceneNode>, Args...> )
            {
                return Entity::addComponent<T>(
                    getOwningScene(), getSceneNode(), std::forward<Args>( args )...
                );
            }
            else if constexpr ( std::is_constructible_v<T, Scene *, entt::entity &, Args...> )
            {
                return Entity::addComponent<T>( getOwningScene(), data_, std::forward<Args>( args )... );
            }
            else
            {
                return Entity::addComponent<T>( getOwningScene(), std::forward<Args>( args )... );
            }
        }

        virtual void beginPlay();

        void tick( double deltaTime ) override;

        virtual void endPlay();

        [[nodiscard]] virtual std::string getActorName() const;

        void destroyActor();

        void destroyActorImmediate();

        void attachTo(
            Actor& parent,
            AttachmentTransformRule rule = AttachmentTransformRule::KeepWorld
        );

        void attachTo(
            const std::shared_ptr<SceneNode>& parentNode,
            AttachmentTransformRule rule = AttachmentTransformRule::KeepWorld
        );

        void detach( AttachmentTransformRule rule = AttachmentTransformRule::KeepWorld );

        glm::vec3 getActorLocation() const;

        glm::vec3 getActorRotation() const;

        glm::quat getActorRotationQuat() const;

        glm::vec3 getActorScale() const;

        void setActorLocation( glm::vec3 newLocation ) const;
        void setActorRotation( glm::vec3 newRotation ) const;

        void rotateActor( glm::vec3 deltaRotation ) const;

        void setActorScale( glm::vec3 newScale ) const;

        glm::vec3 getForwardVector() const;

        glm::vec3 getRightVector() const;

        glm::vec3 getUpVector() const;

        glm::mat4 getWorldTransform() const;

        virtual bool drawImGui() const;
 
    protected:
        void onEngineBeginPlay() override;

        void onEngineEndPlay() override;

        void onEngineDestroyed() override;
 
        std::optional<std::shared_ptr<SceneNode>> sceneNode;  
 
    public:
        Scene * getOwningScene() const;

        [[nodiscard]] static EngineKern * getEngine();

        std::shared_ptr<SceneNode> getSceneNode() const;
 
    private:
        template <typename T, typename First, typename... Rest>
        T * addComponentWithSceneEntityFirstNodeRest( First && first, Rest &&... rest )
        {
            return Entity::addComponent<T>(
                getOwningScene(),
                data_,
                std::forward<First>( first ),
                getSceneNode(),
                std::forward<Rest>( rest )...
            );
        }
 
        Scene *                          owningScene_ = nullptr;
        std::weak_ptr<Components::Scene> rootComponent_;
        bool                             hasEndedPlay_ = false;
    };
 
}  // namespace Engine::Entities