FN_lazy_function_graph.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_linear_allocator.hh"
 
#include "FN_lazy_function.hh"
 
namespace blender::dot {
class DirectedEdge;
}
 
namespace blender::fn::lazy_function {
 
class Socket;
class InputSocket;
class OutputSocket;
class Node;
class Graph;
 
class Socket : NonCopyable, NonMovable {
 protected:
  Node *node_;
  const CPPType *type_;
  bool is_input_;
  int index_in_node_;
  int index_in_graph_;
 
  friend Graph;
 
 public:
  bool is_input() const;
  bool is_output() const;
 
  int index() const;
  int index_in_graph() const;
 
  InputSocket &as_input();
  OutputSocket &as_output();
  const InputSocket &as_input() const;
  const OutputSocket &as_output() const;
 
  const Node &node() const;
  Node &node();
 
  const CPPType &type() const;
 
  std::string name() const;
  std::string detailed_name() const;
};
 
class InputSocket : public Socket {
 private:
  OutputSocket *origin_;
  const void *default_value_ = nullptr;
 
  friend Graph;
 
 public:
  OutputSocket *origin();
  const OutputSocket *origin() const;
 
  const void *default_value() const;
  void set_default_value(const void *value);
};
 
class OutputSocket : public Socket {
 private:
  Vector<InputSocket *> targets_;
 
  friend Graph;
 
 public:
  Span<InputSocket *> targets();
  Span<const InputSocket *> targets() const;
};
 
class Node : NonCopyable, NonMovable {
 protected:
  const LazyFunction *fn_ = nullptr;
  Span<InputSocket *> inputs_;
  Span<OutputSocket *> outputs_;
  int index_in_graph_ = -1;
 
  friend Graph;
 
 public:
  bool is_interface() const;
  bool is_function() const;
  int index_in_graph() const;
 
  Span<const InputSocket *> inputs() const;
  Span<const OutputSocket *> outputs() const;
  Span<InputSocket *> inputs();
  Span<OutputSocket *> outputs();
 
  const InputSocket &input(int index) const;
  const OutputSocket &output(int index) const;
  InputSocket &input(int index);
  OutputSocket &output(int index);
 
  std::string name() const;
};
 
class FunctionNode final : public Node {
 public:
  const LazyFunction &function() const;
};
 
class InterfaceNode final : public Node {
 private:
  friend Node;
  friend Socket;
  friend Graph;
 
  Vector<std::string> socket_names_;
};
 
using GraphInputSocket = OutputSocket;
using GraphOutputSocket = InputSocket;
 
class Graph : NonCopyable, NonMovable {
 private:
  LinearAllocator<> allocator_;
  StringRefNull name_;
  Vector<Node *> nodes_;
 
  InterfaceNode *graph_input_node_ = nullptr;
  InterfaceNode *graph_output_node_ = nullptr;
 
  Vector<GraphInputSocket *> graph_inputs_;
  Vector<GraphOutputSocket *> graph_outputs_;
 
  int socket_num_ = 0;
 
 public:
  Graph(StringRef name = "unkown");
  ~Graph();
 
  StringRefNull name() const;
 
  Span<const Node *> nodes() const;
  Span<Node *> nodes();
 
  Span<const FunctionNode *> function_nodes() const;
  Span<FunctionNode *> function_nodes();
 
  Span<GraphInputSocket *> graph_inputs();
  Span<GraphOutputSocket *> graph_outputs();
 
  Span<const GraphInputSocket *> graph_inputs() const;
  Span<const GraphOutputSocket *> graph_outputs() const;
 
  FunctionNode &add_function(const LazyFunction &fn);
 
  GraphInputSocket &add_input(const CPPType &type, std::string name = "");
  GraphOutputSocket &add_output(const CPPType &type, std::string name = "");
 
  void add_link(OutputSocket &from, InputSocket &to);
 
  void clear_origin(InputSocket &socket);
 
  void update_node_indices();
  void update_socket_indices();
 
  int socket_num() const;
 
  bool node_indices_are_valid() const;
 
  class ToDotOptions {
   public:
    virtual std::string socket_name(const Socket &socket) const;
    virtual std::optional<std::string> socket_font_color(const Socket &socket) const;
    virtual void add_edge_attributes(const OutputSocket &from,
                                     const InputSocket &to,
                                     dot::DirectedEdge &dot_edge) const;
  };
 
  std::string to_dot(const ToDotOptions &options = {}) const;
};
 
/* -------------------------------------------------------------------- */
inline bool Socket::is_input() const
{
  return is_input_;
}
 
inline bool Socket::is_output() const
{
  return !is_input_;
}
 
inline int Socket::index() const
{
  return index_in_node_;
}
 
inline int Socket::index_in_graph() const
{
  return index_in_graph_;
}
 
inline InputSocket &Socket::as_input()
{
  BLI_assert(this->is_input());
  return *static_cast<InputSocket *>(this);
}
 
inline OutputSocket &Socket::as_output()
{
  BLI_assert(this->is_output());
  return *static_cast<OutputSocket *>(this);
}
 
inline const InputSocket &Socket::as_input() const
{
  BLI_assert(this->is_input());
  return *static_cast<const InputSocket *>(this);
}
 
inline const OutputSocket &Socket::as_output() const
{
  BLI_assert(this->is_output());
  return *static_cast<const OutputSocket *>(this);
}
 
inline const Node &Socket::node() const
{
  return *node_;
}
 
inline Node &Socket::node()
{
  return *node_;
}
 
inline const CPPType &Socket::type() const
{
  return *type_;
}
 
/* -------------------------------------------------------------------- */
inline const OutputSocket *InputSocket::origin() const
{
  return origin_;
}
 
inline OutputSocket *InputSocket::origin()
{
  return origin_;
}
 
inline const void *InputSocket::default_value() const
{
  return default_value_;
}
 
inline void InputSocket::set_default_value(const void *value)
{
  default_value_ = value;
}
 
/* -------------------------------------------------------------------- */
inline Span<const InputSocket *> OutputSocket::targets() const
{
  return targets_;
}
 
inline Span<InputSocket *> OutputSocket::targets()
{
  return targets_;
}
 
/* -------------------------------------------------------------------- */
inline bool Node::is_interface() const
{
  return fn_ == nullptr;
}
 
inline bool Node::is_function() const
{
  return fn_ != nullptr;
}
 
inline int Node::index_in_graph() const
{
  return index_in_graph_;
}
 
inline Span<const InputSocket *> Node::inputs() const
{
  return inputs_;
}
 
inline Span<const OutputSocket *> Node::outputs() const
{
  return outputs_;
}
 
inline Span<InputSocket *> Node::inputs()
{
  return inputs_;
}
 
inline Span<OutputSocket *> Node::outputs()
{
  return outputs_;
}
 
inline const InputSocket &Node::input(const int index) const
{
  return *inputs_[index];
}
 
inline const OutputSocket &Node::output(const int index) const
{
  return *outputs_[index];
}
 
inline InputSocket &Node::input(const int index)
{
  return *inputs_[index];
}
 
inline OutputSocket &Node::output(const int index)
{
  return *outputs_[index];
}
 
/* -------------------------------------------------------------------- */
inline const LazyFunction &FunctionNode::function() const
{
  BLI_assert(fn_ != nullptr);
  return *fn_;
}
 
/* -------------------------------------------------------------------- */
inline StringRefNull Graph::name() const
{
  return name_;
}
 
inline Span<const Node *> Graph::nodes() const
{
  return nodes_;
}
 
inline Span<Node *> Graph::nodes()
{
  return nodes_;
}
 
inline Span<const FunctionNode *> Graph::function_nodes() const
{
  return nodes_.as_span().drop_front(2).cast<const FunctionNode *>();
}
 
inline Span<FunctionNode *> Graph::function_nodes()
{
  return nodes_.as_span().drop_front(2).cast<FunctionNode *>();
}
 
inline Span<GraphInputSocket *> Graph::graph_inputs()
{
  return graph_inputs_;
}
 
inline Span<GraphOutputSocket *> Graph::graph_outputs()
{
  return graph_outputs_;
}
 
inline Span<const GraphInputSocket *> Graph::graph_inputs() const
{
  return graph_inputs_;
}
 
inline Span<const GraphOutputSocket *> Graph::graph_outputs() const
{
  return graph_outputs_;
}
 
inline int Graph::socket_num() const
{
  return socket_num_;
}
 
}  // namespace blender::fn::lazy_function