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 "BLI_compute_context.hh"
#include "BLI_math_quaternion_types.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;
 
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;
};
 
struct GeoNodesCallData {
  const bNodeTree *root_ntree = nullptr;
  geo_eval_log::GeoModifierLog *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 GeoNodesLFUserData : public lf::UserData {
  const GeoNodesCallData *call_data = nullptr;
  const ComputeContext *compute_context = nullptr;
  bool log_socket_values = true;
 
  destruct_ptr<lf::LocalUserData> get_local(LinearAllocator<> &allocator) override;
};
 
struct GeoNodesLFLocalUserData : public lf::LocalUserData {
 private:
  mutable std::optional<geo_eval_log::GeoTreeLogger *> tree_logger_;
 
 public:
  GeoNodesLFLocalUserData(GeoNodesLFUserData & /*user_data*/) {}
 
  geo_eval_log::GeoTreeLogger *try_get_tree_logger(const GeoNodesLFUserData &user_data) const
  {
    if (!tree_logger_.has_value()) {
      this->ensure_tree_logger(user_data);
    }
    return *tree_logger_;
  }
 
 private:
  void ensure_tree_logger(const GeoNodesLFUserData &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_attribute_propagation_to_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;
    } attributes_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);
 
void set_default_remaining_node_outputs(lf::Params &params, const bNode &node);
 
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);
 
struct FoundNestedNodeID {
  int id;
  bool is_in_simulation = false;
  bool is_in_loop = false;
};
 
std::optional<FoundNestedNodeID> find_nested_node_id(const GeoNodesLFUserData &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<GeoNodesLFUserData &>(*context_.user_data);
    auto &local_user_data = static_cast<GeoNodesLFLocalUserData &>(*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<GeoNodesLFUserData &>(*context_.user_data);
    auto &local_user_data = static_cast<GeoNodesLFLocalUserData &>(*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});
    }
  }
};
 
}  // namespace blender::nodes