NetworkManager.h

#pragma once
#include "Engine/Core/Types.h"
#include "Engine/Network/GeometryOperator.h"
#include "Engine/Network/UpdateLock.h"
#include "Engine/NetworkGraph/NetworkGraph.h"
#include "Engine/UndoRedo/UndoStack.h"
#include <memory>
#include <unordered_map>
 
namespace enzo {
class NetworkPath;
}
 
namespace enzo::nt {
class NetworkManager
{
  public:
    class OperatorRange
    {
        using Map = std::unordered_map<OpId, std::unique_ptr<GeometryOperator>>;
        Map& map_;
 
      public:
        class Iterator
        {
            Map::iterator it_;
 
          public:
            using value_type = std::pair<const OpId, GeometryOperator&>;
            using reference = value_type;
            using difference_type = std::ptrdiff_t;
            using iterator_category = std::forward_iterator_tag;
 
            Iterator(Map::iterator it) : it_(it) {}
            reference operator*() const { return {it_->first, *it_->second}; }
            Iterator& operator++()
            {
                ++it_;
                return *this;
            }
            Iterator operator++(int)
            {
                Iterator tmp = *this;
                ++it_;
                return tmp;
            }
            bool operator==(const Iterator& other) const { return it_ == other.it_; }
            bool operator!=(const Iterator& other) const { return it_ != other.it_; }
        };
 
        OperatorRange(Map& map) : map_(map) {}
        Iterator begin() { return Iterator(map_.begin()); }
        Iterator end() { return Iterator(map_.end()); }
        std::size_t size() const { return map_.size(); }
    };
 
    OperatorRange operators() { return OperatorRange(gopStore_); }
 
    NetworkManager(const NetworkManager& obj) = delete;
 
    static NetworkManager& getInstance();
 
    OpId
    createOperator(op::OpInfo opInfo, const std::string& path = "", Vector2 position = {0.f, 0.f});
 
    std::optional<OpId> getDisplayOp();
 
    enzo::nt::UpdateLock lockUpdates();
 
    void update();
 
    bool isValidOp(nt::OpId opId);
 
    GeometryOperator& getGeoOperator(nt::OpId opId);
 
    void setDisplayOp(OpId opId);
 
    void clearDisplayFlag();
 
    void setSelectedNode(OpId opId, bool selected, bool add = false);
 
    const std::vector<enzo::nt::OpId>& getSelectedNodes();
 
    void setSelectedNodes(std::vector<enzo::nt::OpId> opIds);
 
    void moveNode(OpId opId, Vector2 newPos, bool skipUndo = false);
 
    void deleteNode(OpId opId);
 
    void removeOperator(OpId opId, bool removeConnections = true);
 
    void restoreOperator(OpId opId, op::OpInfo opInfo);
 
    void clear();
 
    void cookOp(enzo::nt::OpId opId);
 
    nt::NetworkGraph& graph() { return graph_; }
 
    nt::Connection connectNodes(
        OpId inputOpId,
        unsigned int inputIndex,
        OpId outputOpId,
        unsigned int outputIndex
    );
 
    void disconnectNodes(const nt::Connection& connection);
 
    GeometryOperator* findOperator(const NetworkPath& path, OpId fromOp = nullOp);
 
    std::weak_ptr<prm::NodeParameter> findParameter(const NetworkPath& path, OpId fromOp = nullOp);
 
    // @brief A signal emitted when the display node is changed
    boost::signals2::signal<void(std::optional<nt::OpId>)> 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 selection of nodes changes
    boost::signals2::signal<void(std::vector<nt::OpId> selectedNodeIds)> selectedNodesChanged;
 
    // @brief A signal emitted when a new operator is created in the network
    boost::signals2::signal<void(nt::OpId)> operatorCreated;
 
    // @brief A signal emitted when an operator is about to be removed from the network
    boost::signals2::signal<void(nt::OpId)> operatorRemoved;
 
    // @brief A signal emitted when a connection is created between two operators
    boost::signals2::signal<void(nt::Connection)> connectionCreated;
 
    // @brief A signal emitted when a connection is removed between two operators
    boost::signals2::signal<void(nt::Connection)> connectionRemoved;
 
    // @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::OpId, Vector2)> nodePositionChanged;
    UndoStack& undoStack() { return undoStack_; }
 
    void _reset();
 
  private:
    NetworkManager() {};
 
    // functions
    void disconnectOperator(OpId opId);
 
    void onNodeDirtied(nt::OpId opId, bool dirtyDependents);
 
    // variables
    // store for geometry operators
    std::vector<enzo::nt::OpId> selectedNodes_;
    std::unordered_map<enzo::nt::OpId, std::unique_ptr<enzo::nt::GeometryOperator>> gopStore_;
    // the highest operator id currently stored
    enzo::nt::OpId maxOpId_ = 0;
    // operator selected for displaying in the viewport
    std::optional<OpId> displayOp_ = std::nullopt;
    // owns the network's wiring and dependencies
    nt::NetworkGraph graph_;
 
    UndoStack undoStack_;
};
 
inline enzo::nt::NetworkManager& nm() { return enzo::nt::NetworkManager::getInstance(); }
} // namespace enzo::nt