NOD_node_in_compute_context.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2024 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_compute_context.hh"
#include "BLI_hash.hh"
#include "BLI_struct_equality_utils.hh"
 
#include "BKE_node_runtime.hh"
 
struct bNode;
struct bNodeSocket;
 
namespace blender::nodes {
 
struct NodeInContext;
struct SocketInContext;

struct NodeInContext {
  const ComputeContext *context = nullptr;
  const bNode *node = nullptr;
 
  uint64_t hash() const;
  ComputeContextHash context_hash() const;
  const bNode *operator->() const;
  const bNode &operator*() const;
  operator bool() const;
 
  SocketInContext input_socket(int index) const;
  SocketInContext output_socket(int index) const;

  BLI_STRUCT_EQUALITY_OPERATORS_2(NodeInContext, context_hash(), node)
};

struct SocketInContext {
  const ComputeContext *context = nullptr;
  const bNodeSocket *socket = nullptr;
 
  uint64_t hash() const;
  ComputeContextHash context_hash() const;
  const bNodeSocket *operator->() const;
  const bNodeSocket &operator*() const;
  operator bool() const;
 
  NodeInContext owner_node() const;

  BLI_STRUCT_EQUALITY_OPERATORS_2(SocketInContext, context_hash(), socket)
};

struct TreeInContext {
  const ComputeContext *context = nullptr;
  const bNodeTree *tree = nullptr;
 
  uint64_t hash() const;
  ComputeContextHash context_hash() const;
  const bNodeTree *operator->() const;
  const bNodeTree &operator*() const;
  operator bool() const;
};
 
/* -------------------------------------------------------------------- */
 
inline uint64_t NodeInContext::hash() const
{
  return get_default_hash(this->context_hash(), this->node);
}
 
inline ComputeContextHash NodeInContext::context_hash() const
{
  return context ? context->hash() : ComputeContextHash{};
}
 
inline const bNode *NodeInContext::operator->() const
{
  return this->node;
}
 
inline const bNode &NodeInContext::operator*() const
{
  return *this->node;
}
 
inline NodeInContext::operator bool() const
{
  return this->node != nullptr;
}
 
inline SocketInContext NodeInContext::input_socket(const int index) const
{
  return {this->context, &this->node->input_socket(index)};
}
 
inline SocketInContext NodeInContext::output_socket(const int index) const
{
  return {this->context, &this->node->output_socket(index)};
}

 
/* -------------------------------------------------------------------- */
 
inline uint64_t SocketInContext::hash() const
{
  return get_default_hash(this->context_hash(), this->socket);
}
 
inline ComputeContextHash SocketInContext::context_hash() const
{
  return context ? context->hash() : ComputeContextHash{};
}
 
inline const bNodeSocket *SocketInContext::operator->() const
{
  return this->socket;
}
 
inline const bNodeSocket &SocketInContext::operator*() const
{
  return *this->socket;
}
 
inline SocketInContext::operator bool() const
{
  return this->socket != nullptr;
}
 
inline NodeInContext SocketInContext::owner_node() const
{
  return {this->context, &this->socket->owner_node()};
}

 
/* -------------------------------------------------------------------- */
 
inline uint64_t TreeInContext::hash() const
{
  return get_default_hash(this->context_hash(), this->tree);
}
 
inline ComputeContextHash TreeInContext::context_hash() const
{
  return context ? context->hash() : ComputeContextHash{};
}
 
inline const bNodeTree *TreeInContext::operator->() const
{
  return this->tree;
}
 
inline const bNodeTree &TreeInContext::operator*() const
{
  return *this->tree;
}
 
inline TreeInContext::operator bool() const
{
  return this->tree != nullptr;
}

 
}  // namespace blender::nodes