SceneGraph.cpp

Go to the documentation of this file.

#include "Engine/World/SceneGraph.h"
 
#include "Engine/Ecs/EcsData.h"
#include "Engine/Ecs/RegistryManager.h"
#include "Engine/World/Transform.h"
 
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
 
namespace EngineCore {
    SceneNode::SceneNode( entt::registry & reg, bool disableCaching ) :
        entity( reg.create() )
      , registry( &reg )
      , worldMatrix( 1.0f )
      , disableCaching( disableCaching )
    {
        reg.emplace<Ecs::LocalTransform>(entity, glm::mat4(1.f));
        reg.emplace<Ecs::TransformDirty>(entity);
        reg.emplace<Ecs::TransformDirtyRenderer>(entity);
    }
 
    SceneNode::~SceneNode() {
        if (registry && registry->valid(entity)) {
            registry->destroy(entity);
        }
    }

    Ecs::LocalTransform& SceneNode::getLocalTransform() {
        return registry->get<Ecs::LocalTransform>(entity);
    }
 
    const Ecs::LocalTransform& SceneNode::getLocalTransform() const {
        return registry->get<Ecs::LocalTransform>(entity);
    }
 
    void SceneNode::registerWithEcs()
    {
        registry->emplace<Ecs::SceneNodeRef>(entity, weak_from_this());
    }
 
    entt::entity SceneNode::getEntity() const {
        return entity;
    }

    void SceneNode::setWorldPosition(const glm::vec3 &newLocation) {
        if (parent == nullptr) {
            Ecs::TransformOperators::setPosition(getLocalTransform(), newLocation);
            markDirtyRecursive();
            return;
        }
 
        // Get current world transform components
        const glm::mat4& world = getWorldMatrix();
        glm::vec3 currentScale = Ecs::TransformOperators::getScale(world);
        glm::quat currentRotation = Ecs::TransformOperators::getRotation(world);
 
        // Build desired world matrix
        glm::mat4 desiredWorld = glm::translate(glm::mat4(1.f), newLocation)
                               * glm::mat4_cast(currentRotation)
                               * glm::scale(glm::mat4(1.f), currentScale);
 
        // Convert to local space
        glm::mat4 parentInverse = glm::inverse(parent->getWorldMatrix());
        getLocalTransform().matrix = parentInverse * desiredWorld;
 
        markDirtyRecursive();
    }
 
    void SceneNode::setWorldRotation(const glm::vec3 &newRotation) {
        setWorldRotation(glm::quat(glm::radians(newRotation)));
    }
 
    void SceneNode::setWorldRotation(const glm::quat &newRotation) {
        if (parent == nullptr) {
            Ecs::TransformOperators::setRotation(getLocalTransform(), newRotation);
            markDirtyRecursive();
            return;
        }
 
        const glm::mat4& world = getWorldMatrix();
        glm::vec3 currentPosition = Ecs::TransformOperators::getPosition(world);
        glm::vec3 currentScale = Ecs::TransformOperators::getScale(world);
 
        glm::mat4 desiredWorld = glm::translate(glm::mat4(1.f), currentPosition)
                               * glm::mat4_cast(newRotation)
                               * glm::scale(glm::mat4(1.f), currentScale);
 
        glm::mat4 parentInverse = glm::inverse(parent->getWorldMatrix());
        getLocalTransform().matrix = parentInverse * desiredWorld;
 
        markDirtyRecursive();
    }
 
    void SceneNode::rotateWorld(const glm::vec3 &deltaRotation) {
        rotateWorld(glm::quat(glm::radians(deltaRotation)));
    }
 
    void SceneNode::rotateWorld(const glm::quat &deltaRotation) {
        const glm::mat4& world = getWorldMatrix();
        glm::quat currentRotation = Ecs::TransformOperators::getRotation(world);
        glm::quat newRotation = deltaRotation * currentRotation;
        setWorldRotation(newRotation);
    }
 
    void SceneNode::setWorldScale(const glm::vec3 &newScale) {
        if (parent == nullptr) {
            Ecs::TransformOperators::setScale(getLocalTransform(), newScale);
            markDirtyRecursive();
            return;
        }
 
        const glm::mat4& world = getWorldMatrix();
        glm::vec3 currentPosition = Ecs::TransformOperators::getPosition(world);
        glm::quat currentRotation = Ecs::TransformOperators::getRotation(world);
 
        glm::mat4 desiredWorld = glm::translate(glm::mat4(1.f), currentPosition)
                               * glm::mat4_cast(currentRotation)
                               * glm::scale(glm::mat4(1.f), newScale);
 
        glm::mat4 parentInverse = glm::inverse(parent->getWorldMatrix());
        getLocalTransform().matrix = parentInverse * desiredWorld;
 
        markDirtyRecursive();
    }
 
    void SceneNode::setLocalModelMatrix( const glm::mat4 & newModelMatrix )
    {
        getLocalTransform().matrix = newModelMatrix;
        markDirtyRecursive();
    }
 
    void SceneNode::setWorldModelMatrix( const glm::mat4 & newModelMatrix )
    {
        if (parent == nullptr) {
            getLocalTransform().matrix = newModelMatrix;
            markDirtyRecursive();
            return;
        }
 
        glm::mat4 parentInverse = glm::inverse(parent->getWorldMatrix());
        getLocalTransform().matrix = parentInverse * newModelMatrix;
        markDirtyRecursive();
    }
 
    void SceneNode::addChild(const std::shared_ptr<SceneNode> &newChild) {
        newChild->indexInParent = children.size();
        children.push_back(newChild);
        newChild->parent = shared_from_this();
    }
 
    void SceneNode::addChildren(std::vector<std::shared_ptr<SceneNode>> newChildren) {
        size_t startIndex = children.size();
        children.insert(children.end(), newChildren.begin(), newChildren.end());
        for (size_t i = 0; i < newChildren.size(); ++i) {
            newChildren[i]->indexInParent = startIndex + i;
            newChildren[i]->parent = shared_from_this();
        }
    }
 
    void SceneNode::clearChildren() {
        for (const auto child : children) {
            child->parent = nullptr;
        }
        children.clear();
    }
 
    void SceneNode::removeChild(const std::shared_ptr<SceneNode> &child) {
        size_t idx = child->indexInParent;
        if (idx < children.size() - 1) {
            children[idx] = std::move(children.back());
            children[idx]->indexInParent = idx;
        }
        children.pop_back();
        child->parent = nullptr;
    }
 
    void SceneNode::updateWorldMatrix() const {
        if (parent != nullptr) {
            worldMatrix = parent->getWorldMatrix() * getLocalTransform().matrix;
        } else {
            worldMatrix = getLocalTransform().matrix;
        }
 
        // Sync to ECS for cache-friendly rendering reads
        registry->get_or_emplace<Ecs::WorldTransform>(entity).matrix = worldMatrix;
 
        if (!disableCaching) {
            registry->remove<Ecs::TransformDirty>(entity);
        }
    }
 
    const glm::mat4 & SceneNode::getWorldMatrix() const {
        if ( isWorldMatrixDirty() && !disableCaching) {
            updateWorldMatrix();
        } else if (disableCaching) {
            updateWorldMatrix();
        }
        return worldMatrix;
    }
 
    bool SceneNode::isRoot() const {
        return parent == nullptr;
    }
 
    std::vector<std::weak_ptr<SceneNode>> SceneNode::getChildren() const {
        std::vector<std::weak_ptr<SceneNode>> weakChildren;
        weakChildren.reserve(children.size());
        for (const auto& child : children) {
            weakChildren.push_back(child);
        }
        return weakChildren;
    }
 
    bool SceneNode::isWorldMatrixDirty() const {
        return registry->any_of<Ecs::TransformDirty>( entity );
    }
 
    void SceneNode::markDirtyRecursive() {
        registry->emplace_or_replace<Ecs::TransformDirty>( entity );
        registry->emplace_or_replace<Ecs::TransformDirtyRenderer>( entity );
        for (const auto& child : children) {
            child->markDirtyRecursive();
        }
    }
 
    RootNode::RootNode(entt::registry& registry) : SceneNode(registry, false) {
    }
 
    SceneGraph::SceneGraph(const std::shared_ptr<SceneNode> &root) : root(root) {
 
    }
 
    std::shared_ptr<SceneNode> SceneGraph::createNode(const Ecs::LocalTransform& transform, std::shared_ptr<SceneNode> parent,
                                                      bool disableCaching) {
        const std::shared_ptr<SceneNode> node = NodeFactory::createNode( parent, disableCaching );
        node->setWorldModelMatrix(transform.matrix);
        return node;
    }
 
    std::shared_ptr<SceneNode> NodeFactory::createNode(const std::shared_ptr<SceneNode> &parent,
        const bool disableCaching) {
        if (!parent) {
            throw std::invalid_argument("Parent node cannot be null when creating a new node");
        }
        auto& registry = Ecs::RegistryManager::get();
        auto node = std::shared_ptr<SceneNode>(new SceneNode(registry, disableCaching));
        parent->addChild(node);
        node->registerWithEcs();
        return node;
    }
 
    std::vector<std::shared_ptr<SceneNode>> NodeFactory::createNodes(const std::shared_ptr<SceneNode> &parent,
        size_t count, bool disableCaching) {
        if (!parent) {
            throw std::invalid_argument("Parent node cannot be null when creating nodes");
        }
        std::vector<std::shared_ptr<SceneNode>> nodes;
        nodes.reserve(count);
        auto& registry = Ecs::RegistryManager::get();
        for (size_t i = 0; i < count; ++i) {
            nodes.push_back(std::shared_ptr<SceneNode>(new SceneNode(registry, disableCaching)));
        }
        parent->addChildren(nodes);
        return nodes;
    }
}