Node.h

#pragma once
 
// Standard.
#include <vector>
#include <memory>
#include <mutex>
#include <atomic>
#include <unordered_map>
 
// Custom.
#include "io/Serializable.h"
#include "input/KeyboardKey.hpp"
#include "gccontainers/GcVector.hpp"
#include "game/node/callback/NodeNotificationBroadcaster.hpp"
 
// External.
#include "GcPtr.h"
 
#include "Node.generated.h"
 
namespace ne RNAMESPACE() {
    class GameInstance;
    class World;
    class Timer;
 
    enum class TickGroup { FIRST, SECOND };
 
    class RCLASS(Guid("2a721c37-3c22-450c-8dad-7b6985cbbd61")) Node : public Serializable {
        // GameManager will propagate functions to all nodes in the world such as `onBeforeNewFrame`.
        friend class GameManager;
 
        // World is able to spawn root node.
        friend class World;
 
    public:
        enum class AttachmentRule {
            RESET_RELATIVE, //< After the new child node was attached, resets its relative location
                            //< or rotation to 0 and relative scale to 1.
            KEEP_RELATIVE,  //< After the new child node was attached, its relative location/rotation/scale
                            //< will stay the same, but world location/rotation/scale might change.
            KEEP_WORLD,     //< After the new child node was attached, its relative
                            //< location/rotation/scale will be recalculated so that its
                            //< world location/rotation/scale will stay the same (as before attached).
        };
 
        static size_t getAliveNodeCount();
 
        Node();
 
        Node(const std::string& sName);
 
        Node(const Node&) = delete;
        Node& operator=(const Node&) = delete;
        Node(Node&&) = delete;
        Node& operator=(Node&&) = delete;
 
        virtual ~Node() override;
 
        static std::variant<sgc::GcPtr<Node>, Error>
        deserializeNodeTree(const std::filesystem::path& pathToFile);
 
        void setNodeName(const std::string& sName);
 
        void detachFromParentAndDespawn();
 
        void addChildNode(
            const sgc::GcPtr<Node>& pNode,
            AttachmentRule locationRule = AttachmentRule::KEEP_WORLD,
            AttachmentRule rotationRule = AttachmentRule::KEEP_WORLD,
            AttachmentRule scaleRule = AttachmentRule::KEEP_WORLD);
 
        void setSerialize(bool bSerialize);
 
        [[nodiscard]] std::optional<Error>
        serializeNodeTree(const std::filesystem::path& pathToFile, bool bEnableBackup);
 
        std::string getNodeName() const;
 
        sgc::GcPtr<Node> getWorldRootNode();
 
        std::pair<std::recursive_mutex, sgc::GcPtr<Node>>* getParentNode();
 
        std::pair<std::recursive_mutex, sgc::GcVector<sgc::GcPtr<Node>>>* getChildNodes();
 
        template <typename NodeType>
            requires std::derived_from<NodeType, Node>
        sgc::GcPtr<NodeType> getParentNodeOfType(const std::string& sParentNodeName = "");
 
        template <typename NodeType>
            requires std::derived_from<NodeType, Node>
        sgc::GcPtr<NodeType> getChildNodeOfType(const std::string& sChildNodeName = "");
 
        static GameInstance* getGameInstance();
 
        TickGroup getTickGroup() const;
 
        std::optional<size_t> getNodeId() const;
 
        bool isCalledEveryFrame();
 
        bool isReceivingInput();
 
        bool isSpawned();
 
        bool isParentOf(Node* pNode);
 
        bool isChildOf(Node* pNode);
 
        bool isSerialized() const;
 
    protected:
        void setIsCalledEveryFrame(bool bEnable);
 
        void setTickGroup(TickGroup tickGroup);
 
        void setIsReceivingInput(bool bEnable);
 
        Timer* createTimer(const std::string& sTimerName);
 
        template <typename FunctionType>
        NodeNotificationBroadcaster<FunctionType>* createNotificationBroadcaster() {
            std::scoped_lock guard(mtxIsSpawned.first, mtxCreatedBroadcasters.first);
 
            // Create broadcaster.
            auto pNewBroadcaster = std::unique_ptr<NodeNotificationBroadcaster<FunctionType>>(
                new NodeNotificationBroadcaster<FunctionType>());
            const auto pRawBroadcaster = pNewBroadcaster.get();
 
            // Add to our array.
            mtxCreatedBroadcasters.second.push_back(std::move(pNewBroadcaster));
 
            if (mtxIsSpawned.second) {
                // Get node ID.
                if (!iNodeId.has_value()) [[unlikely]] {
                    Error error(std::format(
                        "node \"{}\" created a new broadcaster while being spawned but node's ID is empty",
                        sNodeName));
                    error.showError();
                    throw std::runtime_error(error.getFullErrorMessage());
                }
 
                // Notify broadcaster about node being spawned.
                pRawBroadcaster->onOwnerNodeSpawning(this);
            }
 
            return pRawBroadcaster;
        }
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, bool)>>>*
        getActionEventBindings();
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, float)>>>*
        getAxisEventBindings();
 
        std::recursive_mutex* getSpawnDespawnMutex();
 
        virtual void onMouseMove(double xOffset, double yOffset) {}
 
        virtual void onMouseScrollMove(int iOffset) {}
 
        virtual void onBeforeNewFrame(float timeSincePrevFrameInSec) {}
 
        virtual void onSpawning() {}
 
        virtual void onChildNodesSpawned() {}
 
        virtual void onDespawning() {}
 
        virtual void onBeforeDetachedFromParent(bool bThisNodeBeingDetached) {}
 
        virtual void onAfterAttachedToNewParent(bool bThisNodeBeingAttached) {}
 
    private:
        struct SerializableObjectInformationWithGcPointer : public SerializableObjectInformation {
            SerializableObjectInformationWithGcPointer(
                Serializable* pObject,
                const std::string& sObjectUniqueId,
                const std::unordered_map<std::string, std::string>& customAttributes = {},
                Serializable* pOriginalObject = nullptr,
                sgc::GcPtr<Node> pDeserializedOriginalObject = nullptr)
                : SerializableObjectInformation(pObject, sObjectUniqueId, customAttributes, pOriginalObject) {
                this->pDeserializedOriginalObject = pDeserializedOriginalObject;
            }
 
            sgc::GcPtr<Node> pDeserializedOriginalObject = nullptr;
        };
 
        bool enableTimer(Timer* pTimer, bool bEnable);
 
        void onInputActionEvent(unsigned int iActionId, KeyboardModifiers modifiers, bool bIsPressedDown);
 
        void onInputAxisEvent(unsigned int iAxisEventId, KeyboardModifiers modifiers, float input);
 
        void spawn();
 
        void despawn();
 
        void notifyAboutAttachedToNewParent(bool bThisNodeBeingAttached);
 
        void notifyAboutDetachingFromParent(bool bThisNodeBeingDetached);
 
        World* findValidWorld();
 
        std::variant<std::vector<SerializableObjectInformationWithGcPointer>, Error>
        getInformationForSerialization(size_t& iId, std::optional<size_t> iParentId);
 
        bool isTreeDeserializedFromOneFile(const std::string& sPathRelativeToRes);
 
        void lockChildren();
 
        void unlockChildren();
 
        RPROPERTY(Serialize)
        std::string sNodeName;
 
        std::pair<std::recursive_mutex, sgc::GcVector<sgc::GcPtr<Node>>> mtxChildNodes;
 
        std::pair<std::recursive_mutex, sgc::GcPtr<Node>> mtxParentNode;
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, bool)>>>
            mtxBindedActionEvents;
 
        std::pair<
            std::recursive_mutex,
            std::unordered_map<unsigned int, std::function<void(KeyboardModifiers, float)>>>
            mtxBindedAxisEvents;
 
        std::pair<std::recursive_mutex, std::vector<std::unique_ptr<Timer>>> mtxCreatedTimers;
 
        std::pair<std::recursive_mutex, std::vector<std::unique_ptr<NodeNotificationBroadcasterBase>>>
            mtxCreatedBroadcasters;
 
        std::pair<std::recursive_mutex, bool> mtxIsSpawned;
 
        std::pair<std::recursive_mutex, bool> mtxIsCalledEveryFrame;
 
        std::pair<std::recursive_mutex, bool> mtxIsReceivingInput;
 
        World* pWorld = nullptr;
 
        TickGroup tickGroup = TickGroup::FIRST;
 
        std::optional<size_t> iNodeId;
 
        bool bSerialize = true;
 
        static inline const auto sParentNodeIdAttributeName = "parent_node_id";
 
        static inline const auto sExternalNodeTreePathAttributeName =
            "external_node_tree_path_relative_to_res";
 
        ne_Node_GENERATED
    };
 
    template <typename NodeType>
        requires std::derived_from<NodeType, Node>
    sgc::GcPtr<NodeType> Node::getParentNodeOfType(const std::string& sParentNodeName) {
        std::scoped_lock guard(mtxParentNode.first);
 
        // Check if have a parent.
        if (mtxParentNode.second == nullptr) {
            return nullptr;
        }
 
        // Check parent's type and optionally name.
        sgc::GcPtr<NodeType> pCastedParentNode = dynamic_cast<NodeType*>(mtxParentNode.second.get());
        if (pCastedParentNode != nullptr &&
            (sParentNodeName.empty() || mtxParentNode.second->getNodeName() == sParentNodeName)) {
            // Found the node.
            return pCastedParentNode;
        }
 
        // Ask parent nodes of that node.
        return mtxParentNode.second->getParentNodeOfType<NodeType>(sParentNodeName);
    }
 
    template <typename NodeType>
        requires std::derived_from<NodeType, Node>
    sgc::GcPtr<NodeType> Node::getChildNodeOfType(const std::string& sChildNodeName) {
        std::scoped_lock guard(mtxChildNodes.first);
 
        // Iterate over child nodes.
        for (auto& pChildNode : mtxChildNodes.second) {
            // Check if this is the node we are looking for.
            sgc::GcPtr<NodeType> pCastedChildNode = dynamic_cast<NodeType*>(pChildNode.get());
            if (pCastedChildNode != nullptr &&
                (sChildNodeName.empty() || pChildNode->getNodeName() == sChildNodeName)) {
                // Found the node.
                return pCastedChildNode;
            }
 
            // Ask child nodes of that node.
            const auto pNode = pChildNode->getChildNodeOfType<NodeType>(sChildNodeName);
            if (pNode == nullptr) {
                // Check the next child node.
                continue;
            }
 
            // Found the node.
            return pNode;
        }
 
        return nullptr;
    }
} // namespace ne RNAMESPACE()
 
File_Node_GENERATED