tb_node.hpp

 
#ifndef TurtleBrains_Node_hpp
#define TurtleBrains_Node_hpp
 
#include <turtle_brains/core/tb_configuration.hpp>
#include <turtle_brains/core/tb_noncopyable.hpp>
#include <turtle_brains/core/tb_uuid.hpp>
#include <turtle_brains/core/tb_typed_integer.hpp>
#include <turtle_brains/core/tb_typed_range.hpp>
#include <turtle_brains/core/tb_component.hpp>
 
// 2023-10-15: Core technically shouldn't use anything except Core kit; but the Node is a pretty Core concept and Math
//   is probably fine for Core to be using in this case. Either Node should move if this become a problem, or Core
//   requires Math.
#include <turtle_brains/math/tb_vector.hpp>
#include <turtle_brains/math/tb_matrix.hpp>
 
#include <vector>
#include <functional>
 
namespace TurtleBrains::Core
{
    //TurtleBrains doesn't (yet) have a concept of Paused, but Godot had an interesting ActivePolicy:
    //enum class ActiveMode { Inherit, Always, Never, Pausable, WhenPaused };
 
    enum class Space { Local, World };
    enum class Recursive { No, Yes };
 
    enum class NodeKeyType { };
    using NodeKey = TypedUUID<NodeKeyType>;
 
    class Node;
    using NodePointer = std::unique_ptr<Node>;
 
    namespace NodeImplementation
    {
        template<typename NodeType> struct NodeHierarchyAccessor
        {
            using ContainerType = std::vector<std::reference_wrapper<NodeType>>;
 
            ContainerType mRecursedNodes;
 
            NodeHierarchyAccessor(NodeType& node, const Recursive recursive = Recursive::Yes) : //, const CallTiming callTiming = CallTiming::Before) :
                mRecursedNodes()
            {
                RecurseTree(mRecursedNodes, node, recursive);
            }
 
            static void RecurseTree(ContainerType& recursedNodes, NodeType& node, const Recursive recursive = Recursive::Yes);
 
            typename ContainerType::const_iterator begin(void) const { return mRecursedNodes.begin(); }
            typename ContainerType::const_iterator end(void) const { return mRecursedNodes.end(); }
            typename ContainerType::iterator begin(void) { return mRecursedNodes.begin(); }
            typename ContainerType::iterator end(void) { return mRecursedNodes.end(); }
        };
    };
 
    const NodePointer& GetRootNode(void);
    NodePointer& GetMutableRootNode(void);
    void SetRootNode(NodePointer&& rootNode);
 
    class Node : Noncopyable
    {
    public:
        enum class ChildIndexType : uint16 { };
 
        using ChildIndex = TypedInteger<ChildIndexType>;
        static constexpr ChildIndex InvalidChild(void) { return ChildIndex::Integer(~0); }
 
        explicit Node(const NodeKey& nodeKey = NodeKey::Invalid());
        virtual ~Node(void);
 
 
        inline bool HasParent(void) const { return nullptr != mParent; }
        inline Node& GetParent(void) const { return *mParent; }
 
        void ClearChildren(void);
 
        ChildIndex AddChild(const NodeKey& nodeKey = NodeKey::Invalid(), const String& name = "");
        ChildIndex AddChild(std::unique_ptr<Node>&& childNode);
 
        //    but the callee is responsible for keeping the added object alive until after it has been removed.
        ChildIndex AddChild(Node& childNode);
 
        inline const ChildIndex GetNumberOfChildren(void) const { return tbCore::RangedCast<ChildIndex::Integer>(mChildren.size()); }
        inline const Node& GetChild(const ChildIndex childIndex) const { return *mChildren[childIndex]; }
        inline Node& GetChild(const ChildIndex childIndex) { return *mChildren[childIndex]; }
 
        using ConstChildContainerAccessor = OtherTypedRange<ChildIndex, const Node&>;
        using ChildContainerAccessor = OtherTypedRange<ChildIndex, Node&>;
        inline ConstChildContainerAccessor AllChildren(void) const {
            return ConstChildContainerAccessor(std::bind(&Node::GetNumberOfChildren, this),
                std::bind(static_cast<const Node& (Node::*)(const ChildIndex) const>(&Node::GetChild), this, std::placeholders::_1));
        }
 
        inline ChildContainerAccessor AllChildren(void) {
            return ChildContainerAccessor(std::bind(&Node::GetNumberOfChildren, this),
                std::bind(static_cast<Node& (Node::*)(const ChildIndex)>(&Node::GetChild), this, std::placeholders::_1));
        }
 
        inline NodeImplementation::NodeHierarchyAccessor<const Node> RecurseTree(const NodeKey& nodeKey, Recursive recursive = Recursive::Yes) const
        {
            const Node* startNode = (nodeKey == GetKey()) ? this : FindChildByKey(nodeKey, recursive);
            tb_error_if(nullptr == startNode, "Expected to find the startNode for RecurseTree().");
            return NodeImplementation::NodeHierarchyAccessor<const Node>(*startNode, recursive);
        }
 
        inline NodeImplementation::NodeHierarchyAccessor<const Node> RecurseTree(Recursive recursive = Recursive::Yes) const
        {
            return NodeImplementation::NodeHierarchyAccessor<const Node>(*this, recursive);
        }
 
        inline NodeImplementation::NodeHierarchyAccessor<Node> RecurseTree(const NodeKey& nodeKey, Recursive recursive = Recursive::Yes)
        {
            // 2024-10-12: Hmmm. This is Recursive::Yes instead of using the recursive value because we used it in
            //   the TrackBuilder::PrimaryEditorMode::SyncSelectionDots() which may or may not be recursive; but
            //   does need to find a child on the root recursively, before recursing. Feels a little odd, but was
            //   aiming for the most usable API, and this seems to be the usage of that situation at the cost of a
            //   potential performance trap?
            Node* startNode = (nodeKey == GetKey()) ? this : FindChildByKey(nodeKey, Recursive::Yes);
            tb_error_if(nullptr == startNode, "Expected to find the startNode for RecurseTree().");
            return NodeImplementation::NodeHierarchyAccessor<Node>(*this, recursive);
        }
 
        inline NodeImplementation::NodeHierarchyAccessor<Node> RecurseTree(Recursive recursive = Recursive::Yes)
        {
            return NodeImplementation::NodeHierarchyAccessor<Node>(*this, recursive);
        }
 
        //Do want support for "child/path/to/other" type of searching, and stay consistent (or also add support) with
        //  the DynamicStructure GetMember()    "child.path.to.other"    "garage.racecar.wheel"   "garage/racecar/wheel"
        //  we DO want to support that, but we DON'T yet (2024-10-12)
        const Node* FindChildByName(const String& childName, Recursive recursive = Recursive::No) const;
        Node* FindChildByName(const String& childName, Recursive recursive = Recursive::No);
        const Node* FindChildByKey(const NodeKey& childNodeKey, Recursive recursive = Recursive::No) const;
        Node* FindChildByKey(const NodeKey& childNodeKey, Recursive recursive = Recursive::No);
        //Node* FindChildByTag(const String& tag, Recursive recursive = Recursive::No);
 
        // @note This function is never recursive, and returns the first child with matching name.
        ChildIndex FindChildIndexByName(const String& childName) const;
 
        // @note This function is never recursive, and returns the first child with matching nodeKey.
        ChildIndex FindChildIndexByKey(const NodeKey& childNodeKey) const;
 
 
        void RemoveAllComponents(void);
        Component* AddComponent(ComponentPointer&& component);
 
        template<typename ComponentType> ComponentType* AddComponent(void)
        {
            ComponentPointer componentPointer = ComponentCreator::CreateComponent<ComponentType>(*this);
            if (nullptr == componentPointer)
            {
                return nullptr;
            }
 
            return dynamic_cast<ComponentType*>(AddComponent(std::move(componentPointer)));
        }
 
        const Component* GetComponent(const ComponentKey& componentKey) const;
        Component* GetComponent(const ComponentKey& componentKey);
        const Component* GetComponentByType(const ComponentTypeKey& componentTypeKey) const;
        Component* GetComponentByType(const ComponentTypeKey& componentTypeKey);
 
        template<typename ComponentType> const ComponentType* GetComponent(void) const
        {
            return dynamic_cast<const ComponentType*>(GetComponentByType(ComponentType::ComponentTypeKey()));
        }
 
        template<typename ComponentType> ComponentType* GetComponent(void)
        {
            return dynamic_cast<ComponentType*>(GetComponentByType(ComponentType::ComponentTypeKey()));
        }
 
        template<typename ComponentType> const std::vector<const ComponentType*> GetComponents(void) const
        {
            std::vector<const ComponentType*> components;
            components.reserve(mComponents.size());
 
            for (const ComponentPointer& component : mComponents)
            {
                if (nullptr == components.emplace_back(dynamic_cast<const ComponentType*>(component.get())))
                {
                    components.pop_back();
                }
            }
 
            return components;
        }
 
        template<typename ComponentType> std::vector<ComponentType*> GetComponents(void)
        {
            std::vector<ComponentType*> components;
            components.reserve(mComponents.size());
 
            for (ComponentPointer& component : mComponents)
            {
                if (nullptr == components.emplace_back(dynamic_cast<ComponentType*>(component.get())))
                {
                    components.pop_back();
                }
            }
 
            return components;
        }
 
        //std::vector<const Component*>
 
        inline size_t GetNumberOfComponents(void) const { return mComponents.size(); }
        const Component& GetComponent(const size_t componentIndex) const { return *mComponents[componentIndex]; }
        Component& GetMutableComponent(const size_t componentIndex) { return *mComponents[componentIndex]; }
 
        bool IsActive(void) const;
        inline bool IsActiveSelf(void) const { return mIsActive; }
 
        void SetActive(const bool active);
 
        inline const String& GetName(void) const { return mName; }
        inline void SetName(const String& name) { mName = name; }
 
        inline const NodeKey& GetKey(void) const { return mNodeKey; }
 
        const tbMath::Matrix4& GetObjectToWorld(void) const;
        void SetObjectToWorld(const tbMath::Matrix4& objectToWorld);
 
        const tbMath::Matrix4& GetObjectToParent(void) const;
        void SetObjectToParent(const tbMath::Matrix4& objectToParent);
 
        inline tbMath::Vector3 GetPosition(void) const { return mNodeToWorld.GetPosition(); }
        inline tbMath::Vector3 GetLocalPosition(void) const { return mNodeToParent.GetPosition(); }
 
        inline tbMath::Vector3 GetRight(void) const { return mNodeToWorld.GetBasis(0); }
        inline tbMath::Vector3 GetUp(void) const { return mNodeToWorld.GetBasis(1); }
        inline tbMath::Vector3 GetForward(void) const { return -mNodeToWorld.GetBasis(2); }
        tbMath::Vector3 GetScale(const Space space = Space::Local) const;
        void SetScale(const tbMath::Vector3& localScale);
 
        inline tbMath::Matrix3 GetOrientation(const Space space = Space::Local) const
        {
            return (Space::World == space) ? mNodeToWorld.GetOrientation() : mNodeToParent.GetOrientation();
        }
 
        void Rotate(const tbMath::Vector3& eulerAngles, const Space space = Space::Local);
        void Translate(const tbMath::Vector3& amount, const Space space = Space::Local);
 
        void Simulate(void);
        void Update(const float deltaTime);
        void Render(void) const;
 
    protected:
        virtual void OnAwake(void);
        virtual void OnDestroy(void);
 
        virtual void OnActivate(void);
        virtual void OnDeactivate(void);
 
        virtual void OnSimulate(void);
        virtual void OnUpdate(const float deltaTime);
        virtual void OnRender(void) const;
 
    private:
        void Activate(void);
        void Deactivate(void);
 
        void RecomputeTransforms(void);
 
        const NodeKey mNodeKey;
        String mName;
        tbMath::Matrix4 mNodeToWorld;
        tbMath::Matrix4 mNodeToParent;
 
        std::vector<Node*> mChildren;
        std::vector<NodePointer> mManagedChildren;
        std::vector<ComponentPointer> mComponents; //Always owned/managed.
        Node* mParent;
 
        bool mIsActive;
    };
 
    template<typename NodeType> void NodeImplementation::NodeHierarchyAccessor<NodeType>::RecurseTree(
        ContainerType& recursedNodes, NodeType& node, const Recursive recursive)
    {
        recursedNodes.push_back(node);
 
        if (Recursive::Yes == recursive)
        {
            for (NodeType& child : node.AllChildren())
            {
                RecurseTree(recursedNodes, child, recursive);
            }
        }
    }
 
}; /* namespace TurtleBrains::Core */
 
namespace tbCore = TurtleBrains::Core;
 
#endif /* TurtleBrains_Node_hpp */