NOD_derived_node_tree.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_function_ref.hh"
#include "BLI_linear_allocator.hh"
#include "BLI_vector_set.hh"
 
#include "BKE_node_runtime.hh"
 
namespace blender::nodes {
 
class DTreeContext;
class DerivedNodeTree;
 
class DNode;
class DSocket;
class DInputSocket;
class DOutputSocket;
 
class DTreeContext {
 private:
  /* Null when this context is for the root node group. Otherwise it points to the context one
   * level up. */
  DTreeContext *parent_context_;
  /* Null when this context is for the root node group. Otherwise it points to the group node in
   * the parent node group that contains this context. */
  const bNode *parent_node_;
  /* The current node tree. */
  const bNodeTree *btree_;
  /* The instance key of the parent node. bke::NODE_INSTANCE_KEY_BASE for root contexts. */
  bNodeInstanceKey instance_key_;
  /* All the children contexts of this context. */
  Map<const bNode *, DTreeContext *> children_;
  DerivedNodeTree *derived_tree_;
 
  friend DerivedNodeTree;
 
 public:
  const bNodeTree &btree() const;
  const DTreeContext *parent_context() const;
  const bNode *parent_node() const;
  const bNodeInstanceKey instance_key() const;
  const DTreeContext *child_context(const bNode &node) const;
  const DerivedNodeTree &derived_tree() const;
  bool is_root() const;
};
 
class DNode {
 private:
  const DTreeContext *context_ = nullptr;
  const bNode *bnode_ = nullptr;
 
 public:
  DNode() = default;
  DNode(const DTreeContext *context, const bNode *node);
 
  const DTreeContext *context() const;
  const bNode *bnode() const;
  const bNodeInstanceKey instance_key() const;
  const bNode *operator->() const;
  const bNode &operator*() const;
 
  BLI_STRUCT_EQUALITY_OPERATORS_2(DNode, context_, bnode_)
 
  operator bool() const;
 
  uint64_t hash() const;
 
  DInputSocket input(int index) const;
  DOutputSocket output(int index) const;
 
  DInputSocket input_by_identifier(StringRef identifier) const;
  DOutputSocket output_by_identifier(StringRef identifier) const;
};
 
class DSocket {
 protected:
  const DTreeContext *context_ = nullptr;
  const bNodeSocket *bsocket_ = nullptr;
 
 public:
  DSocket() = default;
  DSocket(const DTreeContext *context, const bNodeSocket *socket);
  DSocket(const DInputSocket &input_socket);
  DSocket(const DOutputSocket &output_socket);
 
  const DTreeContext *context() const;
  const bNodeSocket *bsocket() const;
  const bNodeSocket *operator->() const;
  const bNodeSocket &operator*() const;
 
  BLI_STRUCT_EQUALITY_OPERATORS_2(DSocket, context_, bsocket_)
 
  operator bool() const;
 
  uint64_t hash() const;
 
  DNode node() const;
};
 
class DInputSocket : public DSocket {
 public:
  DInputSocket() = default;
  DInputSocket(const DTreeContext *context, const bNodeSocket *socket);
  explicit DInputSocket(const DSocket &base_socket);
 
  DOutputSocket get_corresponding_group_node_output() const;
  Vector<DOutputSocket, 4> get_corresponding_group_input_sockets() const;
 
  void foreach_origin_socket(FunctionRef<void(DSocket)> origin_fn) const;
};
 
class DOutputSocket : public DSocket {
 public:
  DOutputSocket() = default;
  DOutputSocket(const DTreeContext *context, const bNodeSocket *socket);
  explicit DOutputSocket(const DSocket &base_socket);
 
  DInputSocket get_corresponding_group_node_input() const;
  DInputSocket get_active_corresponding_group_output_socket() const;
 
  struct TargetSocketPathInfo {
    Vector<DSocket, 16> sockets;
  };
 
  using ForeachTargetSocketFn =
      FunctionRef<void(DInputSocket, const TargetSocketPathInfo &path_info)>;
 
  void foreach_target_socket(ForeachTargetSocketFn target_fn) const;
 
 private:
  void foreach_target_socket(ForeachTargetSocketFn target_fn,
                             TargetSocketPathInfo &path_info) const;
};
 
class DerivedNodeTree {
 private:
  LinearAllocator<> allocator_;
  DTreeContext *root_context_;
  VectorSet<const bNodeTree *> used_btrees_;
 
 public:
  DerivedNodeTree(const bNodeTree &btree);
  ~DerivedNodeTree();
 
  const DTreeContext &root_context() const;
  Span<const bNodeTree *> used_btrees() const;
 
  const DTreeContext &active_context() const;
 
  bool has_link_cycles() const;
  bool has_undefined_nodes_or_sockets() const;
  void foreach_node(FunctionRef<void(DNode)> callback) const;
 
  std::string to_dot() const;
 
 private:
  DTreeContext &construct_context_recursively(DTreeContext *parent_context,
                                              const bNode *parent_node,
                                              const bNodeTree &btree,
                                              const bNodeInstanceKey instance_key);
  void destruct_context_recursively(DTreeContext *context);
 
  void foreach_node_in_context_recursive(const DTreeContext &context,
                                         FunctionRef<void(DNode)> callback) const;
};
 
namespace derived_node_tree_types {
using nodes::DerivedNodeTree;
using nodes::DInputSocket;
using nodes::DNode;
using nodes::DOutputSocket;
using nodes::DSocket;
using nodes::DTreeContext;
}  // namespace derived_node_tree_types
 
/* -------------------------------------------------------------------- */
inline const bNodeTree &DTreeContext::btree() const
{
  return *btree_;
}
 
inline const DTreeContext *DTreeContext::parent_context() const
{
  return parent_context_;
}
 
inline const bNode *DTreeContext::parent_node() const
{
  return parent_node_;
}
 
inline const bNodeInstanceKey DTreeContext::instance_key() const
{
  return instance_key_;
}
 
inline const DTreeContext *DTreeContext::child_context(const bNode &node) const
{
  return children_.lookup_default(&node, nullptr);
}
 
inline const DerivedNodeTree &DTreeContext::derived_tree() const
{
  return *derived_tree_;
}
 
inline bool DTreeContext::is_root() const
{
  return parent_context_ == nullptr;
}
 
/* -------------------------------------------------------------------- */
inline DNode::DNode(const DTreeContext *context, const bNode *bnode)
    : context_(context), bnode_(bnode)
{
  BLI_assert(bnode == nullptr || bnode->runtime->owner_tree == &context->btree());
}
 
inline const DTreeContext *DNode::context() const
{
  return context_;
}
 
inline const bNode *DNode::bnode() const
{
  return bnode_;
}
 
inline DNode::operator bool() const
{
  return bnode_ != nullptr;
}
 
inline const bNode *DNode::operator->() const
{
  return bnode_;
}
 
inline const bNode &DNode::operator*() const
{
  BLI_assert(bnode_ != nullptr);
  return *bnode_;
}
 
inline uint64_t DNode::hash() const
{
  return get_default_hash(context_, bnode_);
}
 
inline DInputSocket DNode::input(int index) const
{
  return {context_, &bnode_->input_socket(index)};
}
 
inline DOutputSocket DNode::output(int index) const
{
  return {context_, &bnode_->output_socket(index)};
}
 
inline DInputSocket DNode::input_by_identifier(StringRef identifier) const
{
  return {context_, &bnode_->input_by_identifier(identifier)};
}
 
inline DOutputSocket DNode::output_by_identifier(StringRef identifier) const
{
  return {context_, &bnode_->output_by_identifier(identifier)};
}
 
/* -------------------------------------------------------------------- */
inline DSocket::DSocket(const DTreeContext *context, const bNodeSocket *bsocket)
    : context_(context), bsocket_(bsocket)
{
  BLI_assert(bsocket == nullptr ||
             bsocket->runtime->owner_node->runtime->owner_tree == &context->btree());
}
 
inline DSocket::DSocket(const DInputSocket &input_socket)
    : DSocket(input_socket.context_, input_socket.bsocket_)
{
}
 
inline DSocket::DSocket(const DOutputSocket &output_socket)
    : DSocket(output_socket.context_, output_socket.bsocket_)
{
}
 
inline const DTreeContext *DSocket::context() const
{
  return context_;
}
 
inline const bNodeSocket *DSocket::bsocket() const
{
  return bsocket_;
}
 
inline DSocket::operator bool() const
{
  return bsocket_ != nullptr;
}
 
inline const bNodeSocket *DSocket::operator->() const
{
  return bsocket_;
}
 
inline const bNodeSocket &DSocket::operator*() const
{
  BLI_assert(bsocket_ != nullptr);
  return *bsocket_;
}
 
inline uint64_t DSocket::hash() const
{
  return get_default_hash(context_, bsocket_);
}
 
inline DNode DSocket::node() const
{
  BLI_assert(bsocket_ != nullptr);
  return {context_, bsocket_->runtime->owner_node};
}
 
/* -------------------------------------------------------------------- */
inline DInputSocket::DInputSocket(const DTreeContext *context, const bNodeSocket *bsocket)
    : DSocket(context, bsocket)
{
}
 
inline DInputSocket::DInputSocket(const DSocket &base_socket) : DSocket(base_socket)
{
  BLI_assert(base_socket->is_input());
}
 
/* -------------------------------------------------------------------- */
inline DOutputSocket::DOutputSocket(const DTreeContext *context, const bNodeSocket *bsocket)
    : DSocket(context, bsocket)
{
}
 
inline DOutputSocket::DOutputSocket(const DSocket &base_socket) : DSocket(base_socket)
{
  BLI_assert(base_socket->is_output());
}
 
/* -------------------------------------------------------------------- */
inline const DTreeContext &DerivedNodeTree::root_context() const
{
  return *root_context_;
}
 
inline Span<const bNodeTree *> DerivedNodeTree::used_btrees() const
{
  return used_btrees_;
}
 
}  // namespace blender::nodes