SceneGraph.h

#pragma once
#include "Engine/Ecs/RegistryManager.h"
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <memory>
#include <vector>
 
namespace Engine::Ecs
{
    struct Transform;
}  // namespace Engine::Ecs
 
namespace Engine::Entities {
    enum class AttachmentTransformRule
    {
        KeepWorld,  
        KeepLocal,  
    };

    class SceneNode : public std::enable_shared_from_this<SceneNode> {
        friend class SceneGraph;
        friend class NodeFactory;
    protected:
        explicit SceneNode(entt::registry& registry, bool disableCaching = false);
 
    public:
        ~SceneNode();

        Ecs::Transform& getLocalTransform();

        const Ecs::Transform& getLocalTransform() const;

        void registerWithEcs();

        entt::entity getEntity() const;

        void setWorldPosition(const glm::vec3& newLocation);

        void setWorldRotation(const glm::vec3& newRotation);

        void setWorldRotation(const glm::quat& newRotation);

        void rotateWorld(const glm::vec3& deltaRotation);

        void rotateWorld(const glm::quat& deltaRotation);

        void setWorldScale(const glm::vec3& newScale);

        void setLocalModelMatrix(const glm::mat4& newModelMatrix);

        void setWorldModelMatrix(const glm::mat4& newModelMatrix);

        void addChild(const std::shared_ptr<SceneNode> &newChild);

        void addChildren(std::vector<std::shared_ptr<SceneNode>> newChildren);

        void clearChildren();

        void removeChild(const std::shared_ptr<SceneNode> &child);

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

        void detachFromParent();

        const glm::mat4& getWorldMatrix() const;

        bool isWorldMatrixDirty() const;

        bool isRoot() const;

        bool isDirectChildOf( const std::shared_ptr<SceneNode> & potentialParent ) const;

        std::vector<std::weak_ptr<SceneNode>> getChildren() const;

        void markDirtyRecursive() const;
    private:
 
        void updateWorldMatrix() const;
 
        std::weak_ptr<SceneNode> parent_;
        std::vector<std::shared_ptr<SceneNode>> children_;
        size_t indexInParent_ = 0;
 
        entt::entity entity_;
        entt::registry* registry;
 
        mutable glm::mat4 worldMatrix;
        bool disableCaching = false;
    };

    class RootNode : public SceneNode
    {
    public:
        explicit RootNode(entt::registry& registry);
    };

    class SceneGraph {
        std::shared_ptr<SceneNode> root_;
    public:
        explicit SceneGraph(const std::shared_ptr<SceneNode> &root);
        [[nodiscard]] const std::shared_ptr<SceneNode>& getRoot() const { return root_; }

        void reserveRootChildren(size_t additionalChildren);

        std::shared_ptr<SceneNode> createNode(const Ecs::Transform& transform,
            const std::shared_ptr<SceneNode> & parent,
                                              bool disableCaching = false);
    };

    class NodeFactory {
    public:
        static std::shared_ptr<SceneNode> createNode(const std::shared_ptr<SceneNode>& parent, bool disableCaching = false);

        static std::vector<std::shared_ptr<SceneNode>> createNodes(
            const std::shared_ptr<SceneNode>& parent,
            size_t count,
            bool disableCaching = false);

        static std::shared_ptr<RootNode> createRoot() {
            auto shared = std::make_shared<RootNode>(Ecs::RegistryManager::get());
            shared->registerWithEcs();
            return shared;
        }
    };
 
}