diff --git a/source/blender/nodes/intern/geometry_nodes_lazy_function.cc b/source/blender/nodes/intern/geometry_nodes_lazy_function.cc index 7743b24d110..7b0561e182b 100644 --- a/source/blender/nodes/intern/geometry_nodes_lazy_function.cc +++ b/source/blender/nodes/intern/geometry_nodes_lazy_function.cc @@ -146,19 +146,7 @@ class NodeAnonymousAttributeID : public AnonymousAttributeID { class LazyFunctionForGeometryNode : public LazyFunction { private: const bNode &node_; - /** - * Index of a boolean input that indicates whether the output socket is used. - */ - const Span lf_input_for_output_bsocket_usage_; - /** - * Index of an attribute set input that indicates which anonymous attributes should be - * propagated to the output. - */ - const Span lf_input_for_attribute_propagation_to_output_; - /** - * Maps #bNodeSocket::index_in_tree to input/output indices of the current lazy-function. - */ - const Span lf_index_by_bsocket_; + const GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info_; /** * A bool for every output bsocket. If true, the socket just outputs a field containing an * anonymous attribute id. If only such outputs are requested by other nodes, the node itself @@ -177,19 +165,15 @@ class LazyFunctionForGeometryNode : public LazyFunction { public: LazyFunctionForGeometryNode(const bNode &node, - MutableSpan r_lf_input_for_output_bsocket_usage, - MutableSpan r_lf_input_for_attribute_propagation_to_output, - MutableSpan r_lf_index_by_bsocket) + GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info) : node_(node), - lf_input_for_output_bsocket_usage_(r_lf_input_for_output_bsocket_usage), - lf_input_for_attribute_propagation_to_output_( - r_lf_input_for_attribute_propagation_to_output), - lf_index_by_bsocket_(r_lf_index_by_bsocket), + own_lf_graph_info_(own_lf_graph_info), is_attribute_output_bsocket_(node.output_sockets().size(), false) { BLI_assert(node.typeinfo->geometry_node_execute != nullptr); debug_name_ = node.name; - lazy_function_interface_from_node(node, inputs_, outputs_, r_lf_index_by_bsocket); + lazy_function_interface_from_node( + node, inputs_, outputs_, own_lf_graph_info.mapping.lf_index_by_bsocket); const NodeDeclaration &node_decl = *node.declaration(); const aal::RelationsInNode *relations = node_decl.anonymous_attribute_relations(); @@ -212,7 +196,9 @@ class LazyFunctionForGeometryNode : public LazyFunction { if (output_bsocket.is_available() && !handled_field_outputs.contains(&output_bsocket)) { handled_field_outputs.append(&output_bsocket); const int lf_index = inputs_.append_and_get_index_as("Output Used", CPPType::get()); - r_lf_input_for_output_bsocket_usage[output_bsocket.index_in_all_outputs()] = lf_index; + own_lf_graph_info.mapping + .lf_input_index_for_output_bsocket_usage[output_bsocket.index_in_all_outputs()] = + lf_index; } } @@ -223,8 +209,8 @@ class LazyFunctionForGeometryNode : public LazyFunction { handled_geometry_outputs.append(&output_bsocket); const int lf_index = inputs_.append_and_get_index_as( "Propagate to Output", CPPType::get()); - r_lf_input_for_attribute_propagation_to_output[output_bsocket.index_in_all_outputs()] = - lf_index; + own_lf_graph_info.mapping.lf_input_index_for_attribute_propagation_to_output + [output_bsocket.index_in_all_outputs()] = lf_index; } } } @@ -268,7 +254,8 @@ class LazyFunctionForGeometryNode : public LazyFunction { bool used_non_attribute_output_exists = false; for (const int output_bsocket_index : node_.output_sockets().index_range()) { const bNodeSocket &output_bsocket = node_.output_socket(output_bsocket_index); - const int lf_index = lf_index_by_bsocket_[output_bsocket.index_in_tree()]; + const int lf_index = + own_lf_graph_info_.mapping.lf_index_by_bsocket[output_bsocket.index_in_tree()]; if (lf_index == -1) { continue; } @@ -307,12 +294,13 @@ class LazyFunctionForGeometryNode : public LazyFunction { return; } - GeoNodeExecParams geo_params{node_, - params, - context, - lf_input_for_output_bsocket_usage_, - lf_input_for_attribute_propagation_to_output_, - get_output_attribute_id}; + GeoNodeExecParams geo_params{ + node_, + params, + context, + own_lf_graph_info_.mapping.lf_input_index_for_output_bsocket_usage, + own_lf_graph_info_.mapping.lf_input_index_for_attribute_propagation_to_output, + get_output_attribute_id}; geo_eval_log::TimePoint start_time = geo_eval_log::Clock::now(); node_.typeinfo->geometry_node_execute(geo_params); @@ -347,14 +335,17 @@ class LazyFunctionForGeometryNode : public LazyFunction { { for (const bNodeSocket *bsocket : node_.output_sockets()) { { - const int lf_index = lf_input_for_output_bsocket_usage_[bsocket->index_in_all_outputs()]; + const int lf_index = + own_lf_graph_info_.mapping + .lf_input_index_for_output_bsocket_usage[bsocket->index_in_all_outputs()]; if (index == lf_index) { return StringRef("Use Output '") + bsocket->identifier + "'"; } } { const int lf_index = - lf_input_for_attribute_propagation_to_output_[bsocket->index_in_all_outputs()]; + own_lf_graph_info_.mapping.lf_input_index_for_attribute_propagation_to_output + [bsocket->index_in_all_outputs()]; if (index == lf_index) { return StringRef("Propagate to '") + bsocket->identifier + "'"; } @@ -858,6 +849,7 @@ class LazyFunctionForViewerInputUsage : public LazyFunction { class LazyFunctionForGroupNode : public LazyFunction { private: const bNode &group_node_; + const GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info_; bool has_many_nodes_ = false; std::optional lf_logger_; std::optional lf_side_effect_provider_; @@ -875,77 +867,66 @@ class LazyFunctionForGroupNode : public LazyFunction { * input is used. */ Map lf_output_for_input_bsocket_usage_; - /** - * For every output bsocket there is a corresponding boolean input that indicates whether the - * output is used. - */ - const Span lf_input_for_output_bsocket_usage_; - /** - * For every geometry output that can propagate attributes from an input, there is an attribute - * set input. It indicates which attributes should be propagated to the output. - */ - const Span lf_input_for_attribute_propagation_to_output_; LazyFunctionForGroupNode(const bNode &group_node, - const GeometryNodesLazyFunctionGraphInfo &lf_graph_info, - MutableSpan r_lf_input_for_output_bsocket_usage, - MutableSpan r_lf_input_for_attribute_propagation_to_output, - MutableSpan r_lf_index_by_bsocket) - : group_node_(group_node), - lf_input_for_output_bsocket_usage_(r_lf_input_for_output_bsocket_usage), - lf_input_for_attribute_propagation_to_output_( - r_lf_input_for_attribute_propagation_to_output) + const GeometryNodesLazyFunctionGraphInfo &group_lf_graph_info, + GeometryNodesLazyFunctionGraphInfo &own_lf_graph_info) + : group_node_(group_node), own_lf_graph_info_(own_lf_graph_info) { debug_name_ = group_node.name; allow_missing_requested_inputs_ = true; - lazy_function_interface_from_node(group_node, inputs_, outputs_, r_lf_index_by_bsocket); + lazy_function_interface_from_node( + group_node, inputs_, outputs_, own_lf_graph_info.mapping.lf_index_by_bsocket); for (lf::Input &input : inputs_) { input.usage = lf::ValueUsage::Maybe; } - has_many_nodes_ = lf_graph_info.num_inline_nodes_approximate > 1000; + has_many_nodes_ = group_lf_graph_info.num_inline_nodes_approximate > 1000; Vector graph_inputs; /* Add inputs that also exist on the bnode. */ - graph_inputs.extend(lf_graph_info.mapping.group_input_sockets); + graph_inputs.extend(group_lf_graph_info.mapping.group_input_sockets); /* Add a boolean input for every output bsocket that indicates whether that socket is used. */ for (const int i : group_node.output_sockets().index_range()) { - r_lf_input_for_output_bsocket_usage[group_node.output_socket(i).index_in_all_outputs()] = - graph_inputs.append_and_get_index(lf_graph_info.mapping.group_output_used_sockets[i]); + own_lf_graph_info.mapping.lf_input_index_for_output_bsocket_usage + [group_node.output_socket(i).index_in_all_outputs()] = graph_inputs.append_and_get_index( + group_lf_graph_info.mapping.group_output_used_sockets[i]); inputs_.append_as("Output is Used", CPPType::get(), lf::ValueUsage::Maybe); } - graph_inputs.extend(lf_graph_info.mapping.group_output_used_sockets); + graph_inputs.extend(group_lf_graph_info.mapping.group_output_used_sockets); /* Add an attribute set input for every output geometry socket that can propagate attributes * from inputs. */ for (auto [output_index, lf_socket] : - lf_graph_info.mapping.attribute_set_by_geometry_output.items()) { + group_lf_graph_info.mapping.attribute_set_by_geometry_output.items()) { const int lf_index = inputs_.append_and_get_index_as( "Attribute Set", CPPType::get(), lf::ValueUsage::Maybe); graph_inputs.append(lf_socket); - r_lf_input_for_attribute_propagation_to_output[group_node_.output_socket(output_index) - .index_in_all_outputs()] = lf_index; + own_lf_graph_info.mapping.lf_input_index_for_attribute_propagation_to_output + [group_node_.output_socket(output_index).index_in_all_outputs()] = lf_index; } Vector graph_outputs; /* Add outputs that also exist on the bnode. */ - graph_outputs.extend(lf_graph_info.mapping.standard_group_output_sockets); + graph_outputs.extend(group_lf_graph_info.mapping.standard_group_output_sockets); /* Add a boolean output for every input bsocket that indicates whether that socket is used. */ for (const int i : group_node.input_sockets().index_range()) { - const InputUsageHint &input_usage_hint = lf_graph_info.mapping.group_input_usage_hints[i]; + const InputUsageHint &input_usage_hint = + group_lf_graph_info.mapping.group_input_usage_hints[i]; if (input_usage_hint.type == InputUsageHintType::DynamicSocket) { - const lf::InputSocket *lf_socket = lf_graph_info.mapping.group_input_usage_sockets[i]; + const lf::InputSocket *lf_socket = + group_lf_graph_info.mapping.group_input_usage_sockets[i]; lf_output_for_input_bsocket_usage_.add_new(i, graph_outputs.append_and_get_index(lf_socket)); outputs_.append_as("Input is Used", CPPType::get()); } } - lf_logger_.emplace(lf_graph_info); + lf_logger_.emplace(group_lf_graph_info); lf_side_effect_provider_.emplace(); - graph_executor_.emplace(lf_graph_info.graph, + graph_executor_.emplace(group_lf_graph_info.graph, std::move(graph_inputs), std::move(graph_outputs), &*lf_logger_, @@ -1012,14 +993,17 @@ class LazyFunctionForGroupNode : public LazyFunction { } for (const bNodeSocket *bsocket : group_node_.output_sockets()) { { - const int lf_index = lf_input_for_output_bsocket_usage_[bsocket->index_in_all_outputs()]; + const int lf_index = + own_lf_graph_info_.mapping + .lf_input_index_for_output_bsocket_usage[bsocket->index_in_all_outputs()]; if (i == lf_index) { return StringRef("Use Output '") + bsocket->identifier + "'"; } } { const int lf_index = - lf_input_for_attribute_propagation_to_output_[bsocket->index_in_all_outputs()]; + own_lf_graph_info_.mapping.lf_input_index_for_attribute_propagation_to_output + [bsocket->index_in_all_outputs()]; if (i == lf_index) { return StringRef("Propagate to '") + bsocket->identifier + "'"; } @@ -1641,11 +1625,7 @@ struct GeometryNodesLazyFunctionGraphBuilder { } auto lazy_function = std::make_unique( - bnode, - *group_lf_graph_info, - mapping_->lf_input_index_for_output_bsocket_usage, - mapping_->lf_input_index_for_attribute_propagation_to_output, - mapping_->lf_index_by_bsocket); + bnode, *group_lf_graph_info, *lf_graph_info_); lf::FunctionNode &lf_node = lf_graph_->add_function(*lazy_function); for (const int i : bnode.input_sockets().index_range()) { @@ -1690,11 +1670,7 @@ struct GeometryNodesLazyFunctionGraphBuilder { void handle_geometry_node(const bNode &bnode) { - auto lazy_function = std::make_unique( - bnode, - mapping_->lf_input_index_for_output_bsocket_usage, - mapping_->lf_input_index_for_attribute_propagation_to_output, - mapping_->lf_index_by_bsocket); + auto lazy_function = std::make_unique(bnode, *lf_graph_info_); lf::Node &lf_node = lf_graph_->add_function(*lazy_function); for (const bNodeSocket *bsocket : bnode.input_sockets()) {