32using bke::node_tree_reference_lifetimes::ReferenceSetInfo;
48 const lf::FunctionNode *body_node_;
52 : body_node_(&body_node)
57 const lf::Context &context)
const override
67 if (side_effect_nodes_in_closure.
is_empty()) {
83 const bNode &output_bnode_;
86 std::shared_ptr<ClosureSignature> closure_signature_;
92 std::weak_ptr<const GeometryNodesLazyFunctionGraphInfo> lf_graph_info_;
99 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> &lf_graph_info)
102 output_bnode_(*zone.output_node()),
103 zone_info_(zone_info),
105 lf_graph_info_(lf_graph_info)
107 debug_name_ =
"Closure Zone";
110 for (
const auto item : body_fn.
indices.
inputs.reference_sets.items()) {
114 BLI_assert(&reference_set.socket->owner_node() != zone_.input_node());
117 if (&reference_set.socket->owner_node() == zone_.output_node()) {
125 inputs_.append_and_get_index_as(
"Reference Set",
130 for (
const int i : zone_.border_links.index_range()) {
131 inputs_[zone_info.
indices.
inputs.border_links[i]].usage = lf::ValueUsage::Used;
136 closure_signature_ = std::make_shared<ClosureSignature>();
139 const bNodeSocket &bsocket = zone_.input_node()->output_socket(i);
140 closure_signature_->inputs.add({bsocket.
name, bsocket.
typeinfo});
143 const bNodeSocket &bsocket = zone_.output_node()->input_socket(i);
144 closure_signature_->outputs.add({bsocket.
name, bsocket.
typeinfo});
148 void execute_impl(lf::Params ¶ms,
const lf::Context &context)
const override
153 for (
const int i : zone_.border_links.index_range()) {
154 params.set_output(zone_info_.indices.outputs.border_link_usages[i],
true);
159 std::unique_ptr<ResourceScope> closure_scope = std::make_unique<ResourceScope>();
161 lf::Graph &lf_graph = closure_scope->construct<lf::Graph>(
"Closure Graph");
162 lf::FunctionNode &lf_body_node = lf_graph.add_function(*body_fn_.function);
168 const bNodeSocket &bsocket = zone_.input_node()->output_socket(i);
170 lf::GraphInputSocket &lf_graph_input = lf_graph.add_input(
172 lf_graph.add_link(lf_graph_input, lf_body_node.input(body_fn_.indices.inputs.main[i]));
174 lf::GraphOutputSocket &lf_graph_input_usage = lf_graph.add_output(
176 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.input_usages[i]),
177 lf_graph_input_usage);
181 closure_indices.
inputs.main = lf_graph.graph_inputs().index_range().take_back(
182 storage.input_items.items_num);
183 closure_indices.
outputs.input_usages = lf_graph.graph_outputs().index_range().take_back(
184 storage.input_items.items_num);
189 lf::GraphOutputSocket &lf_graph_output = lf_graph.add_output(
191 lf_graph.add_link(lf_body_node.output(body_fn_.indices.outputs.main[i]), lf_graph_output);
193 lf::GraphInputSocket &lf_graph_output_usage = lf_graph.add_input(
195 lf_graph.add_link(lf_graph_output_usage,
196 lf_body_node.input(body_fn_.indices.inputs.output_usages[i]));
198 closure_indices.
outputs.main = lf_graph.graph_outputs().index_range().take_back(
199 storage.output_items.items_num);
200 closure_indices.
inputs.output_usages = lf_graph.graph_inputs().index_range().take_back(
201 storage.output_items.items_num);
204 for (
const int i : zone_.border_links.index_range()) {
206 zone_info_.indices.inputs.border_links[i]);
208 std::move(*input_ptr));
212 captured_values.
append(&stored_ptr);
213 lf_body_node.input(body_fn_.indices.inputs.border_links[i]).set_default_value(&stored_ptr);
216 for (
const auto &item : body_fn_.indices.inputs.reference_sets.items()) {
218 btree_.runtime->reference_lifetimes_info->reference_sets[item.key];
222 if (&
node == zone_.output_node()) {
224 lf::GraphInputSocket &lf_graph_input = lf_graph.add_input(
226 StringRef(
"Reference Set: ") + reference_set.socket->name);
229 lf_body_node.input(body_fn_.indices.inputs.reference_sets.lookup(item.key)));
230 closure_indices.
inputs.output_data_reference_sets.add_new(reference_set.socket->index(),
231 lf_graph_input.index());
237 zone_info_.indices.inputs.reference_sets.lookup(item.key));
239 std::move(input_reference_set));
240 lf_body_node.input(body_fn_.indices.inputs.reference_sets.lookup(item.key))
241 .set_default_value(&stored);
248 output_bnode_.identifier, [&]() { return lf_graph.to_dot(); });
251 lf_graph.update_node_indices();
254 std::shared_ptr<const GeometryNodesLazyFunctionGraphInfo> lf_graph_info =
255 lf_graph_info_.lock();
258 closure_scope->add(std::move(lf_graph_info));
260 const auto &side_effect_provider =
262 lf::GraphExecutor &lf_graph_executor = closure_scope->construct<lf::GraphExecutor>(
263 lf_graph,
nullptr, &side_effect_provider,
nullptr);
266 output_bnode_.identifier,
267 user_data.compute_context->hash(),
271 std::move(closure_scope),
274 std::move(default_input_values),
276 std::make_shared<ClosureEvalLog>(),
277 std::move(captured_values))};
279 params.set_output(zone_info_.indices.outputs.main[0],
306 : btree_(bnode.owner_tree()), bnode_(bnode)
308 debug_name_ = bnode.
name;
309 for (
const int i : bnode.input_sockets().index_range().drop_back(1)) {
310 const bNodeSocket &bsocket = bnode.input_socket(i);
311 indices_.inputs.main.append(inputs_.append_and_get_index_as(
312 bsocket.name, CPPType::get<bke::SocketValueVariant>(), lf::ValueUsage::Maybe));
313 indices_.outputs.input_usages.append(
314 outputs_.append_and_get_index_as(
"Usage", CPPType::get<bool>()));
317 inputs_[indices_.inputs.main[0]].usage = lf::ValueUsage::Used;
318 for (
const int i : bnode.output_sockets().index_range().drop_back(1)) {
319 const bNodeSocket &bsocket = bnode.output_socket(i);
320 indices_.outputs.main.append(
321 outputs_.append_and_get_index_as(bsocket.name, CPPType::get<bke::SocketValueVariant>()));
322 indices_.inputs.output_usages.append(
323 inputs_.append_and_get_index_as(
"Usage", CPPType::get<bool>(), lf::ValueUsage::Maybe));
324 if (bke::node_tree_reference_lifetimes::can_contain_referenced_data(bsocket.type)) {
325 const int input_i = inputs_.append_and_get_index_as(
327 CPPType::get<bke::GeometryNodesReferenceSet>(),
328 lf::ValueUsage::Maybe);
329 indices_.inputs.reference_set_by_output.add(i, input_i);
347 if (s->graph_executor_storage) {
348 s->graph_executor->destruct_storage(s->graph_executor_storage);
353 void execute_impl(lf::Params ¶ms,
const lf::Context &context)
const override
361 if (!eval_storage.graph_executor) {
364 if (eval_storage.closure) {
365 if (user_data.is_stack_limit_reached()) {
370 tree_logger->node_warnings.append(
371 *tree_logger->allocator,
373 {NodeWarningType::Error,
374 TIP_(
"Stack limit reached. Closure becomes pass-through.")}});
383 btree_orig.
id.
session_uid, bnode_.identifier, user_data.compute_context->hash()};
384 eval_storage.closure->log_evaluation(eval_location);
394 const std::optional<ClosureSourceLocation> closure_source_location =
395 eval_storage.closure ? eval_storage.closure->source_location() : std::nullopt;
398 user_data.compute_context, bnode_.identifier, &btree_, closure_source_location};
402 closure_compute_context.
hash());
405 lf::Context eval_graph_context{
406 eval_storage.graph_executor_storage, &closure_user_data, &closure_local_user_data};
407 eval_storage.graph_executor->execute(params, eval_graph_context);
413 context = context->parent())
418 if (closure_context->node() == &bnode_) {
428 for (
const bNodeSocket *bsocket : bnode_.output_sockets().drop_back(1)) {
429 const int index = bsocket->index();
432 for (
const bNodeSocket *bsocket : bnode_.input_sockets().drop_back(1)) {
433 params.set_output(indices_.outputs.input_usages[bsocket->index()],
false);
438 const lf::Context &context)
const
441 const auto &user_data = *
static_cast<GeoNodesUserData *
>(context.user_data);
444 if (tree_logger ==
nullptr) {
449 Span{node_storage.input_items.items, node_storage.input_items.items_num})
454 if (!btree_.typeinfo->validate_link(item.socket_type, closure_item.
type->
type)) {
458 {NodeWarningType::Error,
459 fmt::format(
"{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
461 TIP_(
"Conversion not supported when evaluating closure"),
464 TIP_(item_type->label),
465 TIP_(closure_item.type->label))}});
467 else if (item.socket_type != closure_item.type->type) {
471 {NodeWarningType::Info,
472 fmt::format(
"{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
474 TIP_(
"Implicit type conversion when evaluating closure"),
477 TIP_(item_type->label),
478 TIP_(closure_item.type->label))}});
482 tree_logger->node_warnings.append(
483 *tree_logger->allocator,
486 NodeWarningType::Error,
487 fmt::format(fmt::runtime(TIP_(
"Closure does not have input: \"{}\"")), item.name),
491 for (
const NodeEvaluateClosureOutputItem &item :
492 Span{node_storage.output_items.items, node_storage.output_items.items_num})
494 const bke::bNodeSocketType *item_type = bke::node_socket_type_find_static(item.socket_type);
495 if (
const std::optional<int> i = signature.find_output_index(item.name)) {
496 const ClosureSignature::Item &closure_item = signature.outputs[*i];
497 if (!btree_.typeinfo->validate_link(closure_item.type->type, item.socket_type)) {
498 tree_logger->node_warnings.append(
499 *tree_logger->allocator,
501 {NodeWarningType::Error,
502 fmt::format(
"{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
504 TIP_(
"Conversion not supported when evaluating closure"),
507 TIP_(closure_item.type->label),
508 TIP_(item_type->label))}});
510 else if (item.socket_type != closure_item.type->type) {
511 tree_logger->node_warnings.append(
512 *tree_logger->allocator,
514 {NodeWarningType::Info,
515 fmt::format(
"{}: {} \"{}\" ({} " BLI_STR_UTF8_BLACK_RIGHT_POINTING_SMALL_TRIANGLE
517 TIP_(
"Implicit type conversion when evaluating closure"),
520 TIP_(closure_item.type->label),
521 TIP_(item_type->label))}});
525 tree_logger->node_warnings.append(
526 *tree_logger->allocator,
528 {NodeWarningType::Error,
529 fmt::format(fmt::runtime(TIP_(
"Closure does not have output: \"{}\"")),
539 lf::Graph &lf_graph = eval_storage.
graph;
541 for (
const lf::Input &input : inputs_) {
542 lf_graph.add_input(*input.type, input.debug_name);
544 for (
const lf::Output &
output : outputs_) {
556 inputs_map[i] = closure_signature.
find_input_index(node_storage.input_items.items[i].name);
561 node_storage.output_items.items[i].name);
564 lf::FunctionNode &lf_closure_node = lf_graph.add_function(closure.
function());
566 static constexpr bool static_true =
true;
567 static constexpr bool static_false =
false;
569 lf_graph_outputs[indices_.outputs.input_usages[0]]->set_default_value(&static_true);
571 for (
const int input_item_i :
IndexRange(node_storage.input_items.items_num)) {
572 lf::GraphOutputSocket &lf_usage_output =
573 *lf_graph_outputs[indices_.outputs.input_usages[input_item_i + 1]];
574 if (
const std::optional<int> mapped_i = inputs_map[input_item_i]) {
577 lf::OutputSocket *lf_from = lf_graph_inputs[indices_.inputs.main[input_item_i + 1]];
578 lf::InputSocket &lf_to = lf_closure_node.input(closure_indices.
inputs.main[*mapped_i]);
585 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
586 lf_graph.add_link(*lf_from, conversion_node.input(0));
587 lf_from = &conversion_node.output(0);
593 lf_usage_output.set_default_value(&static_false);
597 lf_graph.add_link(*lf_from, lf_to);
598 lf_graph.add_link(lf_closure_node.output(closure_indices.
outputs.input_usages[*mapped_i]),
602 lf_usage_output.set_default_value(&static_false);
606 for (
const int output_item_i :
IndexRange(node_storage.output_items.items_num)) {
607 lf::GraphOutputSocket &lf_main_output =
608 *lf_graph_outputs[indices_.outputs.main[output_item_i]];
610 if (
const std::optional<int> mapped_i = outputs_map[output_item_i]) {
612 *closure_signature.
outputs[*mapped_i].type;
613 lf::OutputSocket *lf_from = &lf_closure_node.output(
614 closure_indices.
outputs.main[*mapped_i]);
615 if (&closure_output_type != &main_output_type) {
617 closure_output_type, main_output_type, eval_storage.
scope))
621 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
622 lf_graph.add_link(*lf_from, conversion_node.input(0));
623 lf_from = &conversion_node.output(0);
632 lf_graph.add_link(*lf_from, lf_main_output);
633 lf_graph.add_link(*lf_graph_inputs[indices_.inputs.output_usages[output_item_i]],
634 lf_closure_node.input(closure_indices.
inputs.output_usages[*mapped_i]));
641 for (
const int i : closure_indices.
inputs.main.index_range()) {
642 lf::InputSocket &lf_closure_input = lf_closure_node.input(closure_indices.
inputs.main[i]);
643 if (lf_closure_input.origin()) {
651 for (
const int i : closure_indices.
outputs.main.index_range()) {
652 lf::OutputSocket &lf_closure_output = lf_closure_node.output(
653 closure_indices.
outputs.main[i]);
654 if (
const std::optional<int> lf_reference_set_input_i =
655 closure_indices.
inputs.output_data_reference_sets.lookup_try(i))
657 lf::InputSocket &lf_reference_set_input = lf_closure_node.input(*lf_reference_set_input_i);
658 const int node_output_i = outputs_map.
as_span().first_index_try(i);
659 if (node_output_i == -1) {
660 lf_reference_set_input.set_default_value(&static_empty_reference_set);
663 if (
const std::optional<int> lf_evaluate_node_reference_set_input_i =
664 indices_.inputs.reference_set_by_output.lookup_try(node_output_i))
666 lf_graph.add_link(*lf_graph_inputs[*lf_evaluate_node_reference_set_input_i],
667 lf_reference_set_input);
670 lf_reference_set_input.set_default_value(&static_empty_reference_set);
674 if (!lf_closure_output.targets().is_empty()) {
678 lf_closure_node.input(closure_indices.
inputs.output_usages[i])
679 .set_default_value(&static_false);
682 lf_graph.update_node_indices();
694 bnode_.identifier, [&]() { return lf_graph.to_dot(); });
701 lf::Graph &lf_graph = eval_storage.
graph;
702 for (
const lf::Input &input : inputs_) {
703 lf_graph.add_input(*input.type, input.debug_name);
705 for (
const lf::Output &
output : outputs_) {
711 for (
const int output_item_i :
IndexRange(node_storage.output_items.items_num)) {
712 const bNodeSocket &output_bsocket = bnode_.output_socket(output_item_i);
715 lf::GraphOutputSocket &lf_main_output =
716 *lf_graph_outputs[indices_.outputs.main[output_item_i]];
717 lf::GraphInputSocket &lf_usage_input =
718 *lf_graph_inputs[indices_.inputs.output_usages[output_item_i]];
721 lf::OutputSocket &lf_main_input =
722 *lf_graph_inputs[indices_.inputs.main[input_bsocket->index()]];
723 lf::GraphOutputSocket &lf_usage_output =
724 *lf_graph_outputs[indices_.outputs.input_usages[input_bsocket->index()]];
726 if (&input_type == &output_type) {
727 lf_graph.add_link(lf_main_input, lf_main_output);
728 lf_graph.add_link(lf_usage_input, lf_usage_output);
732 input_type, output_type, eval_storage.
scope))
734 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
735 lf_graph.add_link(lf_main_input, conversion_node.input(0));
736 lf_graph.add_link(conversion_node.output(0), lf_main_output);
737 lf_graph.add_link(lf_usage_input, lf_usage_output);
744 static constexpr bool static_false =
false;
745 for (
const int usage_i : indices_.outputs.input_usages) {
746 lf::GraphOutputSocket &lf_usage_output = *lf_graph_outputs[usage_i];
747 if (!lf_usage_output.origin()) {
748 lf_usage_output.set_default_value(&static_false);
752 lf_graph.update_node_indices();
753 eval_storage.
graph_executor.emplace(lf_graph,
nullptr,
nullptr,
nullptr);
764 const int fn_inputs_num =
fn.inputs().size();
765 const int fn_outputs_num =
fn.outputs().size();
771 void *
storage =
fn.init_storage(allocator);
789 for (
const int input_item_i : params.
inputs.index_range()) {
791 if (
const std::optional<int> mapped_i = inputs_map[input_item_i]) {
798 input_value = *value;
801 input_value = *
to_type.geometry_nodes_default_value;
803 lf_input_values[indices.
inputs.main[*mapped_i]] = {
811 for (
const int output_item_i : params.
outputs.index_range()) {
812 if (
const std::optional<int> mapped_i = outputs_map[output_item_i]) {
814 lf_input_values[indices.
inputs.output_usages[*mapped_i]] = {
816 lf_output_usages[indices.
outputs.main[*mapped_i]] = lf::ValueUsage::Used;
821 for (
const int main_input_i : indices.
inputs.main.index_range()) {
822 const int lf_input_i = indices.
inputs.main[main_input_i];
823 if (!lf_input_values[lf_input_i]) {
826 lf_input_values[lf_input_i] = value.release();
828 lf_output_values[indices.
outputs.input_usages[main_input_i]] = allocator.
allocate<
bool>();
831 for (
const int output_usage_i : indices.
inputs.output_usages.index_range()) {
832 const int lf_input_i = indices.
inputs.output_usages[output_usage_i];
833 if (!lf_input_values[lf_input_i]) {
835 allocator.
construct<
bool>(
false).release()};
839 for (
auto &&[main_output_i, lf_input_i] : indices.
inputs.output_data_reference_sets.items()) {
842 lf_input_values[lf_input_i] = {value.release()};
845 for (
const int main_output_i : indices.
outputs.main.index_range()) {
846 lf_output_values[indices.
outputs.main[main_output_i]] =
850 lf::BasicParams lf_params{
851 fn, lf_input_values, lf_output_values, lf_input_usages, lf_output_usages, lf_set_outputs};
852 fn.execute(lf_params, lf_context);
855 for (
const int output_item_i : params.
outputs.index_range()) {
857 if (
const std::optional<int> mapped_i = outputs_map[output_item_i]) {
882 for (
const int i : lf_output_values.
index_range()) {
883 if (lf_set_outputs[i]) {
884 lf_output_values[i].destruct();
895 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> &lf_graph_info)
898 btree, zone, zone_info, body_fn, lf_graph_info);
__forceinline float extract(const int4 &b)
Span< T > as_span() const
IndexRange index_range() const
static const CPPType & get()
const ComputeContextHash & hash() const
constexpr IndexRange()=default
destruct_ptr< T > construct(Args &&...args)
void * allocate(const int64_t size, const int64_t alignment)
T & construct(Args &&...args)
LinearAllocator & allocator()
constexpr bool is_empty() const
void append(const T &value)
void ensure_owns_direct_data()
static SocketValueVariant from(T &&value)
std::unique_ptr< LoggedZoneGraphs > logged_zone_graphs
std::unique_ptr< node_tree_reference_lifetimes::ReferenceLifetimesInfo > reference_lifetimes_info
std::optional< int > find_output_index(StringRef key) const
CustomIDVectorSet< Item, ItemKeyGetter > inputs
std::optional< int > find_input_index(StringRef key) const
CustomIDVectorSet< Item, ItemKeyGetter > outputs
const ClosureSignature & signature() const
const fn::lazy_function::LazyFunction & function() const
const bke::SocketValueVariant & default_input_value(const int index) const
const ClosureFunctionIndices & indices() const
void execute_impl(lf::Params ¶ms, const lf::Context &context) const override
LazyFunctionForClosureZone(const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, std::shared_ptr< GeometryNodesLazyFunctionGraphInfo > &lf_graph_info)
LazyFunctionForEvaluateClosureNode(const bNode &bnode)
EvaluateClosureFunctionIndices indices() const
bool is_recursive_call(const GeoNodesUserData &user_data) const
void destruct_storage(void *storage) const override
void initialize_execution_graph(EvaluateClosureEvalStorage &eval_storage) const
void initialize_pass_through_graph(EvaluateClosureEvalStorage &eval_storage) const
void generate_closure_compatibility_warnings(const Closure &closure, const lf::Context &context) const
void * init_storage(LinearAllocator<> &allocator) const override
void execute_impl(lf::Params ¶ms, const lf::Context &context) const override
void set_default_outputs(lf::Params ¶ms) const
LinearAllocator * allocator
linear_allocator::ChunkedList< WarningWithNode > node_warnings
#define storage(slot, qualifiers)
@ ClosureInputReferenceSet
bNodeSocketType * node_socket_type_find_static(int type, int subtype=0)
void evaluate_closure_eagerly(const Closure &closure, ClosureEagerEvalParams ¶ms)
void initialize_zone_wrapper(const bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, const bool expose_all_reference_sets, Vector< lf::Input > &r_inputs, Vector< lf::Output > &r_outputs)
LazyFunction & build_closure_zone_lazy_function(ResourceScope &scope, const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, std::shared_ptr< GeometryNodesLazyFunctionGraphInfo > &lf_graph_info)
void construct_socket_default_value(const bke::bNodeSocketType &stype, void *r_value)
const LazyFunction * build_implicit_conversion_lazy_function(const bke::bNodeSocketType &from_type, const bke::bNodeSocketType &to_type, ResourceScope &scope)
bool should_log_verbose_in_context(const GeoNodesUserData &user_data, const ComputeContextHash hash)
std::optional< SocketValueVariant > implicitly_convert_socket_value(const bke::bNodeSocketType &from_type, const SocketValueVariant &from_value, const bke::bNodeSocketType &to_type)
const bNodeSocket * evaluate_closure_node_internally_linked_input(const bNodeSocket &output_socket)
ImplicitSharingPtr< Closure > ClosurePtr
void set_default_value_for_output_socket(lf::Params ¶ms, const int lf_index, const bNodeSocket &bsocket)
EvaluateClosureFunction build_evaluate_closure_node_lazy_function(ResourceScope &scope, const bNode &bnode)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
T * DEG_get_original(T *id)
bke::bNodeSocketType * typeinfo
bke::bNodeTreeRuntime * runtime
const SocketValueVariant * geometry_nodes_default_value
const bke::bNodeSocketType * type
bke::SocketValueVariant * value
Vector< InputItem > inputs
GeoNodesUserData * user_data
Vector< OutputItem > outputs
struct blender::nodes::ClosureFunctionIndices::@160307352137314066326363125174013160024306142302 outputs
struct blender::nodes::ClosureFunctionIndices::@322073305126251315255160374026131265320171306337 inputs
const bke::bNodeSocketType * type
std::optional< lf::GraphExecutor > graph_executor
void * graph_executor_storage
std::optional< ClosureIntermediateGraphSideEffectProvider > side_effect_provider
const LazyFunction * lazy_function
EvaluateClosureFunctionIndices indices
const GeoNodesSideEffectNodes * side_effect_nodes
MultiValueMap< ComputeContextHash, const lf::FunctionNode * > nodes_by_context
const ComputeContext * compute_context
const GeoNodesCallData * call_data
ZoneFunctionIndices indices
ZoneFunctionIndices indices
struct blender::nodes::ZoneFunctionIndices::@342054057300321050315260123310012173322070035365 inputs