SpatialNode.h

#pragma once
 
// Custom.
#include "game/node/Node.h"
#include "math/GLMath.hpp"
#include "misc/Globals.h"
 
#include "SpatialNode.generated.h"
 
namespace ne RNAMESPACE() {
    class RCLASS(Guid("150d647c-f385-4a11-b585-d059d2be88aa")) SpatialNode : public Node {
        // Calls `applyAttachmentRule`.
        friend class Node;
 
    public:
        SpatialNode();
 
        SpatialNode(const std::string& sNodeName);
 
        virtual ~SpatialNode() override = default;
 
        void setRelativeLocation(const glm::vec3& location);
 
        void setRelativeRotation(const glm::vec3& rotation);
 
        void setRelativeScale(const glm::vec3& scale);
 
        void setWorldLocation(const glm::vec3& location);
 
        void setWorldRotation(const glm::vec3& rotation);
 
        void setWorldScale(const glm::vec3& scale);
 
        inline glm::vec3 getRelativeLocation() const { return relativeLocation; }
 
        inline glm::vec3 getRelativeRotation() const { return relativeRotation; }
 
        inline glm::vec3 getRelativeScale() const { return relativeScale; }
 
        glm::mat4x4 getRelativeRotationMatrix();
 
        glm::vec3 getWorldLocation();
 
        glm::vec3 getWorldRotation();
 
        glm::quat getWorldRotationQuaternion();
 
        glm::vec3 getWorldScale();
 
        glm::vec3 getWorldForwardDirection();
 
        glm::vec3 getWorldRightDirection();
 
        glm::vec3 getWorldUpDirection();
 
        glm::mat4x4 getWorldMatrix();
 
        std::pair<std::recursive_mutex, sgc::GcPtr<SpatialNode>>* getClosestSpatialParent();
 
    protected:
        virtual void onAfterDeserialized() override;
 
        virtual void onSpawning() override;
 
        virtual void onAfterAttachedToNewParent(bool bThisNodeBeingAttached) override;
 
        virtual void onWorldLocationRotationScaleChanged() {};
 
    private:
        void applyAttachmentRule(
            Node::AttachmentRule locationRule,
            const glm::vec3& worldLocationBeforeAttachment,
            Node::AttachmentRule rotationRule,
            const glm::vec3& worldRotationBeforeAttachment,
            Node::AttachmentRule scaleRule,
            const glm::vec3& worldScaleBeforeAttachment);
 
        void recalculateWorldMatrix(bool bNotifyChildren = true);
 
        void recalculateLocalMatrix();
 
        void recalculateWorldMatrixForNodeAndNotifyChildren(Node* pNode);
 
#if defined(DEBUG)
        void warnIfExceedingWorldBounds();
#endif
 
        struct WorldMatrixInformation {
            WorldMatrixInformation() = default;
 
            glm::vec3 worldLocation = glm::vec3(0.0F, 0.0F, 0.0F);
 
            glm::vec3 worldRotation = glm::vec3(0.0F, 0.0F, 0.0F);
 
            glm::vec3 worldScale = glm::vec3(1.0F, 1.0F, 1.0F);
 
            glm::vec3 worldForward = Globals::WorldDirection::forward;
 
            glm::vec3 worldRight = Globals::WorldDirection::right;
 
            glm::vec3 worldUp = Globals::WorldDirection::up;
 
            glm::quat worldRotationQuaternion = glm::identity<glm::quat>();
 
            glm::mat4x4 worldMatrix = glm::identity<glm::mat4x4>();
 
            bool bInOnWorldLocationRotationScaleChanged = false;
        };
 
        struct LocalSpaceInformation {
            LocalSpaceInformation() = default;
 
            glm::mat4x4 relativeRotationMatrix = glm::identity<glm::mat4x4>();
 
            glm::quat relativeRotationQuaternion = glm::identity<glm::quat>();
        };
 
        RPROPERTY(Serialize)
        glm::vec3 relativeLocation = glm::vec3(0.0F, 0.0F, 0.0F);
 
        RPROPERTY(Serialize)
        glm::vec3 relativeRotation = glm::vec3(0.0F, 0.0F, 0.0F);
 
        RPROPERTY(Serialize)
        glm::vec3 relativeScale = glm::vec3(1.0F, 1.0F, 1.0F);
 
        std::pair<std::recursive_mutex, sgc::GcPtr<SpatialNode>> mtxSpatialParent{};
 
        std::pair<std::recursive_mutex, LocalSpaceInformation> mtxLocalSpace{};
 
        std::pair<std::recursive_mutex, WorldMatrixInformation> mtxWorldMatrix{};
 
        ne_SpatialNode_GENERATED
    };
} // namespace ne RNAMESPACE()
 
File_SpatialNode_GENERATED