NetworkManager.h

#pragma once
#include "Engine/Core/Types.h"
#include "Engine/Network/Network.h"
#include "Engine/Network/Node.h"
#include "Engine/Network/Scope.h"
#include "Engine/Network/UpdateLock.h"
#include "Engine/NetworkGraph/NetworkGraph.h"
#include "Engine/UndoRedo/UndoStack.h"
#include <optional>
#include <vector>
 
namespace enzo {
class NetworkPath;
}
 
namespace enzo::nt {
class NetworkManager
{
  public:
    nt::Network& network() { return network_; }
 
    auto nodes() { return network_.nodes(); }
 
    NetworkManager(const NetworkManager& obj) = delete;
 
    static NetworkManager& getInstance();
 
    NodeId createNode(
        const std::string& typeName,
        const Path& parent = Path("/"),
        const std::string& name = "",
        Vector2 position = {0.f, 0.f}
    );
 
    Node* getNodeAtPath(const Path& path) { return network_.getNodeAtPath(path); }
 
    Scope* getScope(const Path& path) { return network_.getScope(path); }
 
    std::vector<NodeId> getChildNodeIds(const Path& scope)
    {
        return network_.getChildNodeIds(scope);
    }
 
    std::optional<NodeId> getDisplayNode();
 
    enzo::nt::UpdateLock lockUpdates();
 
    void update();
 
    bool isValidNode(nt::NodeId nodeId);
 
    Node& getNode(nt::NodeId nodeId);
 
    void setDisplayNode(NodeId nodeId);
 
    void clearDisplayFlag();
 
    std::optional<NodeId> getPrimaryNode();
 
    void setPrimaryNode(NodeId nodeId);
 
    void clearPrimaryNode();
 
    floatT getFrame() const { return frame_; }
 
    void setFrame(floatT frame);
 
    intT getStartFrame() const { return startFrame_; }
 
    intT getEndFrame() const { return endFrame_; }
 
    void setStartFrame(intT frame);
 
    void setEndFrame(intT frame);
 
    floatT getFps() const { return fps_; }
 
    void setFps(floatT fps);
 
    floatT getTime() const { return (frame_ - 1) / fps_; }
 
    void setSelectedNode(NodeId nodeId, bool selected, bool add = false);
 
    const std::vector<enzo::nt::NodeId>& getSelectedNodes();
 
    void setSelectedNodes(std::vector<enzo::nt::NodeId> nodeIds);
 
    void moveNode(NodeId nodeId, Vector2 newPos, bool skipUndo = false);
 
    void deleteNode(NodeId nodeId);
 
    void createNodeWithId(
        NodeId nodeId,
        const nt::NodeType& nodeType,
        const Path& path,
        Vector2 position
    );
 
    void clear();
 
    void cook(enzo::nt::NodeId nodeId);
 
    nt::NetworkGraph& graph() { return network_.graph(); }
 
    unsigned int getInputCount(NodeId nodeId);
 
    nt::NodeLink connectNodes(
        NodeId inputNodeId,
        unsigned int inputIndex,
        NodeId outputNodeId,
        unsigned int outputIndex
    );
 
    void disconnectNodes(const nt::NodeLink& nodeLink);
 
    Node* findNode(const NetworkPath& path, NodeId fromNode = nullNode)
    {
        return network_.findNode(path, fromNode);
    }
 
    std::weak_ptr<prm::NodeParameter>
    findParameter(const NetworkPath& path, NodeId fromNode = nullNode)
    {
        return network_.findParameter(path, fromNode);
    }
 
    // @brief A signal emitted when the display node is changed
    boost::signals2::signal<void(std::optional<nt::NodeId>)> displayNodeChanged;
 
    // @brief A signal emitted when the geometry to be displayed is changed
    // This is different to #displayNodeChanged because the state of geometry
    // in a node can change based on parameters or other factors.
    boost::signals2::signal<void(std::shared_ptr<const enzo::NodePacket>)> displayGeoChanged;
 
    // @brief A signal emitted when the selected node's geometry is changed
    boost::signals2::signal<void(std::shared_ptr<const enzo::NodePacket>)> selectedGeoChanged;
 
    // @brief A signal emitted when the primary node changes
    boost::signals2::signal<void(std::optional<nt::NodeId>)> primaryNodeChanged;
 
    // @brief A signal emitted when the primary node's geometry changes
    boost::signals2::signal<void(std::shared_ptr<const enzo::NodePacket>)> primaryGeoChanged;
 
    // @brief A signal emitted when the selection of nodes changes
    boost::signals2::signal<void(std::vector<nt::NodeId> selectedNodeIds)> selectedNodesChanged;
 
    // @brief A signal emitted when a new node is created in the network
    boost::signals2::signal<void(nt::NodeId)> nodeCreated;
 
    // @brief A signal emitted when a node is about to be removed from the network
    boost::signals2::signal<void(nt::NodeId)> nodeRemoved;
 
    // @brief A signal emitted when a node link is created between two nodes
    boost::signals2::signal<void(nt::NodeLink)> nodeLinkCreated;
 
    // @brief A signal emitted when a node link is removed between two nodes
    boost::signals2::signal<void(nt::NodeLink)> nodeLinkRemoved;
 
    // @brief A signal emitted when the network is cleared
    boost::signals2::signal<void()> networkCleared;
 
    // @brief A signal emitted when a node's position changes programmatically (e.g. undo/redo)
    boost::signals2::signal<void(nt::NodeId, Vector2)> nodePositionChanged;
 
    // @brief A signal emitted when the scene moves to a different frame
    boost::signals2::signal<void(floatT frame)> frameChanged;
 
    // @brief A signal emitted when the playback range changes
    boost::signals2::signal<void(intT startFrame, intT endFrame)> frameRangeChanged;
 
    // @brief A signal emitted when the playback rate changes
    boost::signals2::signal<void(floatT fps)> fpsChanged;
    UndoStack& undoStack() { return undoStack_; }
 
    void _reset();
 
  private:
    NetworkManager() {};
 
    // functions
    void disconnectNode(NodeId nodeId);
 
    void openInputGap(NodeId nodeId, unsigned int fromIndex);
 
    void closeInputGap(NodeId nodeId, unsigned int fromIndex);
 
    void moveInput(const nt::NodeLink& nodeLink, unsigned int inputIndex);
 
    void onNodeDirtied(nt::NodeId nodeId, bool dirtyDependents);
 
    void dirtyUnits_(const std::vector<nt::Unit>& units);
 
    void dirtyTimeDependents_();
 
    void resetTime_();
 
    // variables
    // every node, its wiring, and the scopes they live in
    nt::Network network_;
    std::vector<enzo::nt::NodeId> selectedNodes_;
    // node selected for displaying in the viewport
    std::optional<NodeId> displayNode_ = std::nullopt;
    // the primary node that drives the parameter and geometry panes
    std::optional<NodeId> primaryNode_ = std::nullopt;
 
    // the frame the scene sits on, and the range playback runs over
    floatT frame_ = 1;
    intT startFrame_ = 1;
    intT endFrame_ = 240;
    floatT fps_ = 24;
 
    UndoStack undoStack_;
};
 
inline enzo::nt::NetworkManager& nm() { return enzo::nt::NetworkManager::getInstance(); }
} // namespace enzo::nt