Node.h

#pragma once
#include "Engine/Core/Path.h"
#include "Engine/Core/Types.h"
#include "Engine/Network/CookContext.h"
#include "Engine/Network/NodePacket.h"
#include "Engine/Network/NodeType.h"
#include "Engine/Parameter/NodeParameter.h"
#include <memory>
#include <optional>
#include <string>
 
namespace enzo::nt {
class Node
{
  public:
    Node(enzo::nt::NodeId nodeId, const nt::NodeType& nodeType, const Path& path);
    virtual ~Node() = default;
    Node(const Node&) = delete;
    Node& operator=(const Node&) = delete;
 
    void cook(nt::CookContext& context);
 
    std::shared_ptr<const enzo::NodePacket> getOutputPacket(unsigned int outputIndex) const;
 
    void setOutputPacket(unsigned int outputIndex, enzo::NodePacket packet);
 
    bool outputRequested(unsigned int outputIndex) const;
 
    std::vector<std::weak_ptr<prm::NodeParameter>> getParameters();
 
    std::weak_ptr<prm::NodeParameter> getParameter(std::string_view parameterName);
 
    bool isParameterEnabled(std::string_view parmName);
 
    bool isParameterHidden(std::string_view parmName);
 
    std::optional<std::string> getReferencedValue(const std::string& text);
 
    const std::vector<prm::Template>& getTemplates() const;
 
    std::string getName() const;
 
    const Path& getPath() const { return path_; }
 
    void setPath(const Path& path) { path_ = path; }
 
    const nt::NodeType& getType() const;
 
    void dirtyNode(bool dirtyDescendents = true);
 
    bool isDirty();
 
    bool takesInput() const;
 
    unsigned int getMaxOutputs() const;
 
    Vector2 getPosition() const { return position_; }
    void setPosition(Vector2 pos) { position_ = pos; }
 
    boost::signals2::signal<void(nt::NodeId nodeId, bool dirtyDescendents)> nodeDirtied;
 
    boost::signals2::signal<void(const std::string& parmName)> parameterChanged;
 
  private:
    void initParameters();
 
    bool isComparisonTrue(const std::string& conditionText);
 
    void onParameterChanged(const std::string& parmName);
 
    std::vector<std::shared_ptr<prm::NodeParameter>> parameters_;
    std::vector<std::shared_ptr<const enzo::NodePacket>> outputPackets_;
    enzo::nt::NodeId nodeId_;
    const enzo::nt::NodeType& nodeType_;
    // Full path locating this node within the network, its leaf is the node name
    Path path_;
    Vector2 position_{0.f, 0.f};
    bool dirty_ = true;
};
} // namespace enzo::nt