NOD_geometry_nodes_lazy_function.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include <variant>
 
#include "FN_lazy_function_graph.hh"
#include "FN_lazy_function_graph_executor.hh"
 
#include "NOD_geometry_nodes_log.hh"
#include "NOD_multi_function.hh"
#include "NOD_nested_node_id.hh"
 
#include "BLI_compute_context.hh"
#include "BLI_math_quaternion_types.hh"
#include "BLI_multi_value_map.hh"
 
#include "BKE_bake_items.hh"
#include "BKE_node_tree_zones.hh"
 
struct Object;
struct Depsgraph;
struct Scene;
 
namespace blender::nodes {
 
using lf::LazyFunction;
using mf::MultiFunction;
using ReferenceSetIndex = int;

namespace sim_input {

struct PassThrough {};

struct OutputCopy {
  float delta_time;
  bke::bake::BakeStateRef state;
};

struct OutputMove {
  float delta_time;
  bke::bake::BakeState state;
};
 
using Behavior = std::variant<PassThrough, OutputCopy, OutputMove>;
 
}  // namespace sim_input

namespace sim_output {

struct PassThrough {};

struct StoreNewState {
  std::function<void(bke::bake::BakeState state)> store_fn;
};

struct ReadSingle {
  bke::bake::BakeStateRef state;
};

struct ReadInterpolated {
  float mix_factor;
  bke::bake::BakeStateRef prev_state;
  bke::bake::BakeStateRef next_state;
};

struct ReadError {
  std::string message;
};
 
using Behavior = std::variant<PassThrough, StoreNewState, ReadSingle, ReadInterpolated, ReadError>;
 
}  // namespace sim_output

struct SimulationZoneBehavior {
  sim_input::Behavior input;
  sim_output::Behavior output;
  bke::bake::BakeDataBlockMap *data_block_map = nullptr;
};
 
class GeoNodesSimulationParams {
 public:
  virtual SimulationZoneBehavior *get(const int zone_id) const = 0;
};
 
struct BakeNodeBehavior {
  sim_output::Behavior behavior;
  bke::bake::BakeDataBlockMap *data_block_map = nullptr;
};
 
class GeoNodesBakeParams {
 public:
  virtual BakeNodeBehavior *get(const int id) const = 0;
};
 
struct GeoNodesSideEffectNodes {
  MultiValueMap<ComputeContextHash, const lf::FunctionNode *> nodes_by_context;
  MultiValueMap<std::pair<ComputeContextHash, int32_t>, int> iterations_by_iteration_zone;
};

struct GeoNodesModifierData {
  const Object *self_object = nullptr;
  Depsgraph *depsgraph = nullptr;
};
 
struct GeoNodesOperatorDepsgraphs {
  const Depsgraph *active = nullptr;
  Depsgraph *extra = nullptr;
 
  ~GeoNodesOperatorDepsgraphs();

  const ID *get_evaluated_id(const ID &id_orig) const;
};
 
struct GeoNodesOperatorData {
  eObjectMode mode;
  const Object *self_object_orig = nullptr;
  const GeoNodesOperatorDepsgraphs *depsgraphs = nullptr;
  Scene *scene_orig = nullptr;
  int2 mouse_position;
  int2 region_size;
 
  float3 cursor_position;
  math::Quaternion cursor_rotation;
 
  float4x4 viewport_winmat;
  float4x4 viewport_viewmat;
  bool viewport_is_perspective;
 
  int active_point_index = -1;
  int active_edge_index = -1;
  int active_face_index = -1;
  int active_layer_index = -1;
};
 
struct GeoNodesCallData {
  const bNodeTree *root_ntree = nullptr;
  geo_eval_log::GeoNodesLog *eval_log = nullptr;
  GeoNodesSimulationParams *simulation_params = nullptr;
  GeoNodesBakeParams *bake_params = nullptr;
  const GeoNodesSideEffectNodes *side_effect_nodes = nullptr;
  const Set<ComputeContextHash> *socket_log_contexts = nullptr;

  GeoNodesModifierData *modifier_data = nullptr;
  GeoNodesOperatorData *operator_data = nullptr;

  const Object *self_object() const;
};

struct GeoNodesUserData : public fn::UserData {
  const GeoNodesCallData *call_data = nullptr;
  const ComputeContext *compute_context = nullptr;
  bool log_socket_values = true;
 
  destruct_ptr<fn::LocalUserData> get_local(LinearAllocator<> &allocator) override;
};
 
struct GeoNodesLocalUserData : public fn::LocalUserData {
 private:
  mutable std::optional<geo_eval_log::GeoTreeLogger *> tree_logger_;
 
 public:
  GeoNodesLocalUserData(GeoNodesUserData & /*user_data*/) {}

  geo_eval_log::GeoTreeLogger *try_get_tree_logger(const GeoNodesUserData &user_data) const
  {
    if (!tree_logger_.has_value()) {
      this->ensure_tree_logger(user_data);
    }
    return *tree_logger_;
  }
 
 private:
  void ensure_tree_logger(const GeoNodesUserData &user_data) const;
};

enum class InputUsageHintType {
  Never,
  DependsOnOutput,
  DynamicSocket,
};
 
struct InputUsageHint {
  InputUsageHintType type = InputUsageHintType::DependsOnOutput;
  Vector<int> output_dependencies;
};

struct GeometryNodeLazyFunctionGraphMapping {
  Vector<InputUsageHint> group_input_usage_hints;
  MultiValueMap<const lf::Socket *, const bNodeSocket *> bsockets_by_lf_socket_map;
  Map<const bNode *, const lf::FunctionNode *> group_node_map;
  Map<const bNode *, const lf::FunctionNode *> possible_side_effect_node_map;
  Map<const bke::bNodeTreeZone *, const lf::FunctionNode *> zone_node_map;
 
  /* Indexed by #bNodeSocket::index_in_all_outputs. */
  Array<int> lf_input_index_for_output_bsocket_usage;
  /* Indexed by #bNodeSocket::index_in_all_outputs. */
  Array<int> lf_input_index_for_reference_set_for_output;
  /* Indexed by #bNodeSocket::index_in_tree. */
  Array<int> lf_index_by_bsocket;
};

struct GeometryNodesGroupFunction {
  const LazyFunction *function = nullptr;
 
  struct {
    IndexRange main;
    IndexRange output_usages;
    struct {
      IndexRange range;
      Vector<int> geometry_outputs;
    } references_to_propagate;
  } inputs;
 
  struct {
    IndexRange main;
    IndexRange input_usages;
  } outputs;
};

struct GeometryNodesLazyFunctionGraphInfo {
  ResourceScope scope;
  GeometryNodesGroupFunction function;
  lf::Graph graph;
  Map<int, const lf::Graph *> debug_zone_body_graphs;
  GeometryNodeLazyFunctionGraphMapping mapping;
  int num_inline_nodes_approximate = 0;
};
 
std::unique_ptr<LazyFunction> get_simulation_output_lazy_function(
    const bNode &node, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info);
std::unique_ptr<LazyFunction> get_simulation_input_lazy_function(
    const bNodeTree &node_tree,
    const bNode &node,
    GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info);
std::unique_ptr<LazyFunction> get_switch_node_lazy_function(const bNode &node);
std::unique_ptr<LazyFunction> get_index_switch_node_lazy_function(
    const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info);
std::unique_ptr<LazyFunction> get_bake_lazy_function(
    const bNode &node, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info);
std::unique_ptr<LazyFunction> get_menu_switch_node_lazy_function(
    const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info);
std::unique_ptr<LazyFunction> get_menu_switch_node_socket_usage_lazy_function(const bNode &node);
std::unique_ptr<LazyFunction> get_warning_node_lazy_function(const bNode &node);
std::unique_ptr<LazyFunction> get_enable_output_node_lazy_function(
    const bNode &node, GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info);

void set_default_remaining_node_outputs(lf::Params &params, const bNode &node);
void set_default_value_for_output_socket(lf::Params &params,
                                         const int lf_index,
                                         const bNodeSocket &bsocket);
void construct_socket_default_value(const bke::bNodeSocketType &stype, void *r_value);
 
std::string make_anonymous_attribute_socket_inspection_string(const bNodeSocket &socket);
std::string make_anonymous_attribute_socket_inspection_string(StringRef node_name,
                                                              StringRef socket_name);
 
std::optional<FoundNestedNodeID> find_nested_node_id(const GeoNodesUserData &user_data,
                                                     const int node_id);

const GeometryNodesLazyFunctionGraphInfo *ensure_geometry_nodes_lazy_function_graph(
    const bNodeTree &btree);

class ScopedComputeContextTimer {
 private:
  lf::Context &context_;
  geo_eval_log::TimePoint start_;
 
 public:
  ScopedComputeContextTimer(lf::Context &entered_context) : context_(entered_context)
  {
    start_ = geo_eval_log::Clock::now();
  }
 
  ~ScopedComputeContextTimer()
  {
    const geo_eval_log::TimePoint end = geo_eval_log::Clock::now();
    auto &user_data = static_cast<GeoNodesUserData &>(*context_.user_data);
    auto &local_user_data = static_cast<GeoNodesLocalUserData &>(*context_.local_user_data);
    if (geo_eval_log::GeoTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data))
    {
      tree_logger->execution_time += (end - start_);
    }
  }
};

class ScopedNodeTimer {
 private:
  const lf::Context &context_;
  const bNode &node_;
  geo_eval_log::TimePoint start_;
 
 public:
  ScopedNodeTimer(const lf::Context &context, const bNode &node) : context_(context), node_(node)
  {
    start_ = geo_eval_log::Clock::now();
  }
 
  ~ScopedNodeTimer()
  {
    const geo_eval_log::TimePoint end = geo_eval_log::Clock::now();
    auto &user_data = static_cast<GeoNodesUserData &>(*context_.user_data);
    auto &local_user_data = static_cast<GeoNodesLocalUserData &>(*context_.local_user_data);
    if (geo_eval_log::GeoTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data))
    {
      tree_logger->node_execution_times.append(*tree_logger->allocator,
                                               {node_.identifier, start_, end});
    }
  }
};
 
bool should_log_socket_values_for_context(const GeoNodesUserData &user_data,
                                          const ComputeContextHash hash);

class LazyFunctionForLogicalOr : public lf::LazyFunction {
 public:
  LazyFunctionForLogicalOr(const int inputs_num);
 
  void execute_impl(lf::Params &params, const lf::Context &context) const override;
};
 
struct ZoneFunctionIndices {
  struct {
    Vector<int> main;
    Vector<int> border_links;
    Vector<int> output_usages;
    Map<ReferenceSetIndex, int> reference_sets;
  } inputs;
  struct {
    Vector<int> main;
    Vector<int> border_link_usages;
    Vector<int> input_usages;
  } outputs;
};
 
struct ZoneBuildInfo {
  const LazyFunction *lazy_function = nullptr;

  ZoneFunctionIndices indices;
};

struct ZoneBodyFunction {
  const LazyFunction *function = nullptr;
  ZoneFunctionIndices indices;
};
 
LazyFunction &build_repeat_zone_lazy_function(ResourceScope &scope,
                                              const bNodeTree &btree,
                                              const bke::bNodeTreeZone &zone,
                                              ZoneBuildInfo &zone_info,
                                              const ZoneBodyFunction &body_fn);
 
LazyFunction &build_foreach_geometry_element_zone_lazy_function(ResourceScope &scope,
                                                                const bNodeTree &btree,
                                                                const bke::bNodeTreeZone &zone,
                                                                ZoneBuildInfo &zone_info,
                                                                const ZoneBodyFunction &body_fn);
 
LazyFunction &build_closure_zone_lazy_function(ResourceScope &scope,
                                               const bNodeTree &btree,
                                               const bke::bNodeTreeZone &zone,
                                               ZoneBuildInfo &zone_info,
                                               const ZoneBodyFunction &body_fn);
 
struct EvaluateClosureFunctionIndices {
  struct {
    Vector<int> main;
    Vector<int> output_usages;
    Map<int, int> reference_set_by_output;
  } inputs;
  struct {
    Vector<int> main;
    Vector<int> input_usages;
  } outputs;
};
 
struct EvaluateClosureFunction {
  const LazyFunction *lazy_function = nullptr;
  EvaluateClosureFunctionIndices indices;
};
 
EvaluateClosureFunction build_evaluate_closure_node_lazy_function(ResourceScope &scope,
                                                                  const bNode &bnode);
 
void initialize_zone_wrapper(const bke::bNodeTreeZone &zone,
                             ZoneBuildInfo &zone_info,
                             const ZoneBodyFunction &body_fn,
                             bool expose_all_reference_sets,
                             Vector<lf::Input> &r_inputs,
                             Vector<lf::Output> &r_outputs);
 
std::string zone_wrapper_input_name(const ZoneBuildInfo &zone_info,
                                    const bke::bNodeTreeZone &zone,
                                    const Span<lf::Input> inputs,
                                    const int lf_socket_i);
 
std::string zone_wrapper_output_name(const ZoneBuildInfo &zone_info,
                                     const bke::bNodeTreeZone &zone,
                                     const Span<lf::Output> outputs,
                                     const int lf_socket_i);

void report_from_multi_function(const mf::Context &context,
                                NodeWarningType type,
                                std::string message);
 
}  // namespace blender::nodes