SceneGraph.h

Go to the documentation of this file.

#pragma once
#include "Engine/Ecs/RegistryManager.h"
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <memory>
#include <vector>
 
namespace Ecs {
    struct LocalTransform;
}
 
namespace EngineCore {
    class Transform;
}
 
namespace EngineCore {
    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::LocalTransform& getLocalTransform();
        const Ecs::LocalTransform& 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);

        const glm::mat4& getWorldMatrix() const;

        bool isWorldMatrixDirty() const;

        bool isRoot() const;

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

        void markDirtyRecursive();
    private:
 
        void updateWorldMatrix() const;
 
        std::shared_ptr<SceneNode> parent = nullptr;
        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 {
    private:
        std::shared_ptr<SceneNode> root;
    public:
        explicit SceneGraph(const std::shared_ptr<SceneNode> &root);
        const std::shared_ptr<SceneNode>& getRoot() const { return root; }

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

    class NodeFactory {
    public:
        static std::shared_ptr<SceneNode> createNode(const std::shared_ptr<SceneNode>& parent, const 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(bool disableCaching = false) {
            auto shared = std::make_shared<RootNode>(Ecs::RegistryManager::get());
            shared->registerWithEcs();
            return shared;
        }
    };
 
}