NOD_geometry_nodes_closure.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2025 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BKE_node.hh"
 
#include "NOD_geometry_nodes_closure_fwd.hh"
#include "NOD_geometry_nodes_closure_location.hh"
#include "NOD_socket_interface_key.hh"
 
#include "BLI_resource_scope.hh"
 
#include "FN_lazy_function.hh"
 
namespace blender::nodes {
 
class ClosureSignature {
 public:
  struct Item {
    SocketInterfaceKey key;
    const bke::bNodeSocketType *type = nullptr;
  };
 
  Vector<Item> inputs;
  Vector<Item> outputs;
 
  std::optional<int> find_input_index(const SocketInterfaceKey &key) const;
  std::optional<int> find_output_index(const SocketInterfaceKey &key) const;
};
 
struct ClosureFunctionIndices {
  struct {
    IndexRange main;
    IndexRange output_usages;
    Map<int, int> output_data_reference_sets;
  } inputs;
  struct {
    IndexRange main;
    IndexRange input_usages;
  } outputs;
};
 
class Closure : public ImplicitSharingMixin {
 private:
  std::shared_ptr<ClosureSignature> signature_;
  std::optional<ClosureSourceLocation> source_location_;
  std::shared_ptr<ClosureEvalLog> eval_log_;
  std::unique_ptr<ResourceScope> scope_;
  const fn::lazy_function::LazyFunction &function_;
  ClosureFunctionIndices indices_;
  Vector<const void *> default_input_values_;
 
 public:
  Closure(std::shared_ptr<ClosureSignature> signature,
          std::unique_ptr<ResourceScope> scope,
          const fn::lazy_function::LazyFunction &function,
          ClosureFunctionIndices indices,
          Vector<const void *> default_input_values,
          std::optional<ClosureSourceLocation> source_location,
          std::shared_ptr<ClosureEvalLog> eval_log)
      : signature_(signature),
        source_location_(source_location),
        eval_log_(eval_log),
        scope_(std::move(scope)),
        function_(function),
        indices_(indices),
        default_input_values_(std::move(default_input_values))
  {
  }
 
  const ClosureSignature &signature() const
  {
    return *signature_;
  }
 
  const ClosureFunctionIndices &indices() const
  {
    return indices_;
  }
 
  const fn::lazy_function::LazyFunction &function() const
  {
    return function_;
  }
 
  const std::optional<ClosureSourceLocation> &source_location() const
  {
    return source_location_;
  }
 
  const std::shared_ptr<ClosureEvalLog> &eval_log_ptr() const
  {
    return eval_log_;
  }
 
  const void *default_input_value(const int index) const
  {
    return default_input_values_[index];
  }
 
  void delete_self() override
  {
    MEM_delete(this);
  }
 
  void log_evaluation(const ClosureEvalLocation &location) const
  {
    if (!eval_log_) {
      return;
    }
    std::lock_guard lock{eval_log_->mutex};
    eval_log_->evaluations.append(location);
  }
};
 
}  // namespace blender::nodes