NOD_socket_usage_inference.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2024 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <optional>
 
#include "BLI_array.hh"
#include "BLI_generic_pointer.hh"
 
#include "BKE_node.hh"
 
#include "NOD_geometry_nodes_execute.hh"
#include "NOD_socket_usage_inference_fwd.hh"
#include "NOD_socket_value_inference.hh"
 
struct bNodeTree;
struct bNodeSocket;
struct IDProperty;
 
namespace blender::nodes::socket_usage_inference {
 
class SocketUsageInferencerImpl;

class SocketUsageInferencer {
 private:
  SocketUsageInferencerImpl &impl_;
 
  friend class InputSocketUsageParams;
 
 public:
  SocketUsageInferencer(const bNodeTree &tree,
                        ResourceScope &scope,
                        SocketValueInferencer &value_inferencer,
                        bke::ComputeContextCache &compute_context_cache,
                        bool ignore_top_level_node_muting = false);
 
  bool is_socket_used(const SocketInContext &socket);
  bool is_group_input_used(int input_i);
 
  bool is_disabled_output(const SocketInContext &socket);
  bool is_disabled_group_output(int output_i);

  void mark_top_level_node_outputs_as_used();
};
 
class InputSocketUsageParams {
 private:
  SocketUsageInferencer &inferencer_;
  const ComputeContext *compute_context_ = nullptr;
 
 public:
  const bNodeTree &tree;
  const bNode &node;
  const bNodeSocket &socket;
 
  InputSocketUsageParams(SocketUsageInferencer &inferencer,
                         const ComputeContext *compute_context,
                         const bNodeTree &tree,
                         const bNode &node,
                         const bNodeSocket &socket);

  InferenceValue get_input(StringRef identifier) const;

  std::optional<bool> any_output_is_used() const;

  bool menu_input_may_be(StringRef identifier, int enum_value) const;
};

Array<SocketUsage> infer_all_sockets_usage(const bNodeTree &tree);

void infer_group_interface_usage(
    const bNodeTree &group,
    Span<InferenceValue> group_input_values,
    MutableSpan<SocketUsage> r_input_usages,
    std::optional<MutableSpan<SocketUsage>> r_output_usages = std::nullopt);

void infer_group_interface_inputs_usage(const bNodeTree &group,
                                        Span<const bNodeSocket *> input_sockets,
                                        MutableSpan<SocketUsage> r_input_usages);

void infer_group_interface_usage(
    const bNodeTree &group,
    const IDProperty *properties,
    MutableSpan<SocketUsage> r_input_usages,
    std::optional<MutableSpan<SocketUsage>> r_output_usages = std::nullopt);
 
}  // namespace blender::nodes::socket_usage_inference