1980 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> lf_graph_info_;
1992 std::optional<BuildGraphParams> root_graph_build_params_;
2024 std::shared_ptr<GeometryNodesLazyFunctionGraphInfo> &lf_graph_info)
2025 : btree_(*lf_graph_info->tree),
2026 reference_lifetimes_(*lf_graph_info->tree->runtime->reference_lifetimes_info),
2027 scope_(lf_graph_info->scope),
2028 node_multi_functions_(
2030 lf_graph_info_(lf_graph_info)
2036 btree_.ensure_topology_cache();
2037 btree_.ensure_interface_cache();
2039 mapping_ = &lf_graph_info_->mapping;
2041 tree_zones_ = btree_.zones();
2043 this->initialize_mapping_arrays();
2044 this->build_zone_functions();
2045 this->build_root_graph();
2046 this->build_geometry_nodes_group_function();
2050 void initialize_mapping_arrays()
2053 btree_.all_output_sockets().size());
2056 btree_.all_output_sockets().size());
2065 void build_zone_functions()
2069 const Array<int> zone_build_order = this->compute_zone_build_order();
2071 for (
const int zone_i : zone_build_order) {
2075 this->build_simulation_zone_function(zone);
2079 this->build_repeat_zone_function(zone);
2083 this->build_foreach_geometry_element_zone_function(zone);
2086 this->build_closure_zone_function(zone);
2096 Array<int> compute_zone_build_order()
2099 Array<int> zone_build_order(tree_zones_->
zones.size());
2100 array_utils::fill_index_range<int>(zone_build_order);
2101 std::ranges::sort(zone_build_order, [&](
const int zone_a,
const int zone_b) {
2102 return tree_zones_->
zones[zone_a]->depth > tree_zones_->
zones[zone_b]->depth;
2104 return zone_build_order;
2111 void build_simulation_zone_function(
const bNodeTreeZone &zone)
2113 const int zone_i = zone.
index;
2114 ZoneBuildInfo &zone_info = zone_build_infos_[zone_i];
2115 lf::Graph &lf_graph = scope_.
construct<lf::Graph>(
"Simulation Zone");
2116 const auto &sim_output_storage = *
static_cast<const NodeGeometrySimulationOutput *
>(
2119 Vector<lf::GraphInputSocket *> lf_zone_inputs;
2120 Vector<lf::GraphOutputSocket *> lf_zone_outputs;
2123 for (
const bNodeSocket *bsocket : zone.
input_node()->input_sockets().drop_back(1)) {
2124 zone_info.indices.inputs.main.append(lf_zone_inputs.append_and_get_index(
2125 &lf_graph.add_input(CPPType::get<SocketValueVariant>(), bsocket->name)));
2126 zone_info.indices.outputs.input_usages.append(lf_zone_outputs.append_and_get_index(
2127 &lf_graph.add_output(CPPType::get<bool>(),
"Usage: " + StringRef(bsocket->name))));
2131 this->build_zone_border_links_inputs(
2132 zone, lf_graph, lf_zone_inputs, zone_info.indices.inputs.border_links);
2133 this->build_zone_border_link_input_usages(
2134 zone, lf_graph, lf_zone_outputs, zone_info.indices.outputs.border_link_usages);
2136 for (
const bNodeSocket *bsocket : zone.
output_node()->output_sockets().drop_back(1)) {
2137 zone_info.indices.outputs.main.append(lf_zone_outputs.append_and_get_index(
2138 &lf_graph.add_output(CPPType::get<SocketValueVariant>(), bsocket->name)));
2139 zone_info.indices.inputs.output_usages.append(lf_zone_inputs.append_and_get_index(
2140 &lf_graph.add_input(CPPType::get<bool>(),
"Usage: " + StringRef(bsocket->name))));
2143 lf::Node &lf_simulation_usage_node = [&]() -> lf::Node & {
2144 auto &lazy_function = scope_.
construct<LazyFunctionForSimulationInputsUsage>(
2146 lf::Node &lf_node = lf_graph.add_function(lazy_function);
2148 for (
const int i : zone_info.indices.outputs.input_usages) {
2149 lf_graph.add_link(lf_node.output(0), *lf_zone_outputs[i]);
2155 BuildGraphParams graph_params{lf_graph};
2157 lf::FunctionNode *lf_simulation_input =
nullptr;
2159 lf_simulation_input = this->insert_simulation_input_node(
2162 lf::FunctionNode &lf_simulation_output = this->insert_simulation_output_node(
2165 for (
const bNodeSocket *bsocket : zone.
output_node()->input_sockets().drop_back(1)) {
2166 graph_params.usage_by_bsocket.add(bsocket, &lf_simulation_usage_node.output(1));
2170 for (
const int i : IndexRange(sim_output_storage.items_num)) {
2171 lf::InputSocket &lf_to = lf_simulation_output.input(i + 1);
2172 if (lf_simulation_input) {
2173 lf::OutputSocket &lf_from = lf_simulation_input->output(i + 1);
2174 lf_graph.add_link(lf_from, lf_to);
2177 const bNodeSocket &bsocket = zone.
output_node()->input_socket(i + 1);
2178 lf_to.set_default_value(bsocket.typeinfo->geometry_nodes_default_value);
2185 this->build_output_socket_usages(*zone.
input_node(), graph_params);
2187 for (
const auto item : graph_params.lf_output_by_bsocket.items()) {
2188 this->insert_links_from_socket(*item.key, *item.value, graph_params);
2191 this->link_border_link_inputs_and_usages(zone,
2193 zone_info.indices.inputs.border_links,
2195 zone_info.indices.outputs.border_link_usages,
2198 for (
const int i : zone_info.indices.inputs.main) {
2199 lf_graph.add_link(*lf_zone_inputs[i], lf_simulation_input->input(i));
2202 for (
const int i : zone_info.indices.outputs.main.index_range()) {
2203 lf_graph.add_link(lf_simulation_output.output(i),
2204 *lf_zone_outputs[zone_info.indices.outputs.main[i]]);
2207 this->add_default_inputs(graph_params);
2209 Map<ReferenceSetIndex, lf::OutputSocket *> lf_reference_sets;
2210 this->build_reference_set_for_zone(graph_params, lf_reference_sets);
2211 for (
const auto item : lf_reference_sets.items()) {
2212 lf::OutputSocket &lf_attribute_set_socket = *item.value;
2213 if (lf_attribute_set_socket.node().is_interface()) {
2214 zone_info.indices.inputs.reference_sets.add_new(
2215 item.key, lf_zone_inputs.append_and_get_index(&lf_attribute_set_socket));
2218 this->link_reference_sets(graph_params, lf_reference_sets);
2219 this->fix_link_cycles(lf_graph, graph_params.socket_usage_inputs);
2221 lf_graph.update_node_indices();
2223 auto &logger = scope_.
construct<GeometryNodesLazyFunctionLogger>(*lf_graph_info_);
2224 auto &side_effect_provider = scope_.
construct<GeometryNodesLazyFunctionSideEffectProvider>();
2226 const auto &lf_graph_fn = scope_.
construct<lf::GraphExecutor>(lf_graph,
2227 lf_zone_inputs.as_span(),
2228 lf_zone_outputs.as_span(),
2230 &side_effect_provider,
2232 const auto &zone_function = scope_.
construct<LazyFunctionForSimulationZone>(
2234 zone_info.lazy_function = &zone_function;
2243 void build_repeat_zone_function(
const bNodeTreeZone &zone)
2245 ZoneBuildInfo &zone_info = zone_build_infos_[zone.
index];
2247 ZoneBodyFunction &body_fn = this->build_zone_body_function(
2248 zone,
"Repeat Body", &scope_.
construct<GeometryNodesLazyFunctionSideEffectProvider>());
2251 zone_info.lazy_function = &zone_fn;
2254 void build_foreach_geometry_element_zone_function(
const bNodeTreeZone &zone)
2256 ZoneBuildInfo &zone_info = zone_build_infos_[zone.
index];
2258 ZoneBodyFunction &body_fn = this->build_zone_body_function(
2259 zone,
"Foreach Body", &scope_.
construct<GeometryNodesLazyFunctionSideEffectProvider>());
2262 scope_, btree_, zone, zone_info, body_fn);
2263 zone_info.lazy_function = &zone_fn;
2266 void build_closure_zone_function(
const bNodeTreeZone &zone)
2268 ZoneBuildInfo &zone_info = zone_build_infos_[zone.
index];
2270 ZoneBodyFunction &body_fn = this->build_zone_body_function(
2271 zone,
"Closure Body", &scope_.
construct<GeometryNodesLazyFunctionSideEffectProvider>());
2273 scope_, btree_, zone, zone_info, body_fn, lf_graph_info_);
2274 zone_info.lazy_function = &zone_fn;
2280 ZoneBodyFunction &build_zone_body_function(
2281 const bNodeTreeZone &zone,
2282 const StringRef name,
2283 const lf::GraphExecutorSideEffectProvider *side_effect_provider)
2285 lf::Graph &lf_body_graph = scope_.
construct<lf::Graph>(name);
2287 BuildGraphParams graph_params{lf_body_graph};
2289 Vector<lf::GraphInputSocket *> lf_body_inputs;
2290 Vector<lf::GraphOutputSocket *> lf_body_outputs;
2291 ZoneBodyFunction &body_fn = scope_.
construct<ZoneBodyFunction>();
2293 for (
const bNodeSocket *bsocket : zone.
input_node()->output_sockets()) {
2297 lf::GraphInputSocket &lf_input = lf_body_graph.add_input(CPPType::get<SocketValueVariant>(),
2299 lf::GraphOutputSocket &lf_input_usage = lf_body_graph.add_output(
2300 CPPType::get<bool>(),
"Usage: " + StringRef(bsocket->name));
2301 body_fn.indices.inputs.main.append(lf_body_inputs.append_and_get_index(&lf_input));
2302 body_fn.indices.outputs.input_usages.append(
2303 lf_body_outputs.append_and_get_index(&lf_input_usage));
2304 graph_params.lf_output_by_bsocket.add_new(bsocket, &lf_input);
2307 this->build_zone_border_links_inputs(
2308 zone, lf_body_graph, lf_body_inputs, body_fn.indices.inputs.border_links);
2309 this->build_zone_border_link_input_usages(
2310 zone, lf_body_graph, lf_body_outputs, body_fn.indices.outputs.border_link_usages);
2312 for (
const bNodeSocket *bsocket : zone.
output_node()->input_sockets()) {
2316 lf::GraphOutputSocket &lf_output = lf_body_graph.add_output(
2317 CPPType::get<SocketValueVariant>(), bsocket->name);
2318 lf::GraphInputSocket &lf_output_usage = lf_body_graph.add_input(
2319 CPPType::get<bool>(),
"Usage: " + StringRef(bsocket->name));
2320 graph_params.lf_inputs_by_bsocket.add(bsocket, &lf_output);
2321 graph_params.usage_by_bsocket.add(bsocket, &lf_output_usage);
2322 body_fn.indices.outputs.main.append(lf_body_outputs.append_and_get_index(&lf_output));
2323 body_fn.indices.inputs.output_usages.append(
2324 lf_body_inputs.append_and_get_index(&lf_output_usage));
2329 this->build_output_socket_usages(*zone.
input_node(), graph_params);
2332 int valid_socket_i = 0;
2333 for (
const bNodeSocket *bsocket : zone.
input_node()->output_sockets()) {
2337 lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.
lookup_default(bsocket,
2339 lf::GraphOutputSocket &lf_usage_output =
2340 *lf_body_outputs[body_fn.indices.outputs.input_usages[valid_socket_i]];
2342 lf_body_graph.add_link(*lf_usage, lf_usage_output);
2345 static const bool static_false =
false;
2346 lf_usage_output.set_default_value(&static_false);
2352 for (
const auto item : graph_params.lf_output_by_bsocket.items()) {
2353 this->insert_links_from_socket(*item.key, *item.value, graph_params);
2356 this->link_border_link_inputs_and_usages(zone,
2358 body_fn.indices.inputs.border_links,
2360 body_fn.indices.outputs.border_link_usages,
2363 this->add_default_inputs(graph_params);
2365 Map<int, lf::OutputSocket *> lf_reference_sets;
2366 this->build_reference_set_for_zone(graph_params, lf_reference_sets);
2367 for (
const auto item : lf_reference_sets.items()) {
2368 lf::OutputSocket &lf_attribute_set_socket = *item.value;
2369 if (lf_attribute_set_socket.node().is_interface()) {
2370 body_fn.indices.inputs.reference_sets.add_new(
2371 item.key, lf_body_inputs.append_and_get_index(&lf_attribute_set_socket));
2374 this->link_reference_sets(graph_params, lf_reference_sets);
2375 this->fix_link_cycles(lf_body_graph, graph_params.socket_usage_inputs);
2377 lf_body_graph.update_node_indices();
2379 auto &logger = scope_.
construct<GeometryNodesLazyFunctionLogger>(*lf_graph_info_);
2381 body_fn.function = &scope_.
construct<lf::GraphExecutor>(lf_body_graph,
2382 lf_body_inputs.as_span(),
2383 lf_body_outputs.as_span(),
2385 side_effect_provider,
2395 void build_zone_border_links_inputs(
const bNodeTreeZone &zone,
2396 lf::Graph &lf_graph,
2397 Vector<lf::GraphInputSocket *> &r_lf_graph_inputs,
2398 Vector<int> &r_indices)
2400 for (
const bNodeLink *border_link : zone.
border_links) {
2401 r_indices.append(r_lf_graph_inputs.append_and_get_index(
2402 &lf_graph.add_input(CPPType::get<SocketValueVariant>(),
2403 StringRef(
"Link from ") + border_link->fromsock->name)));
2407 void build_zone_border_link_input_usages(
const bNodeTreeZone &zone,
2408 lf::Graph &lf_graph,
2409 Vector<lf::GraphOutputSocket *> &r_lf_graph_outputs,
2410 Vector<int> &r_indices)
2412 for (
const bNodeLink *border_link : zone.
border_links) {
2413 r_indices.append(r_lf_graph_outputs.append_and_get_index(&lf_graph.add_output(
2414 CPPType::get<bool>(), StringRef(
"Usage: Link from ") + border_link->fromsock->name)));
2418 void build_reference_set_for_zone(BuildGraphParams &graph_params,
2419 Map<ReferenceSetIndex, lf::OutputSocket *> &lf_reference_sets)
2421 const Vector<ReferenceSetIndex> all_required_reference_sets =
2422 this->find_all_required_reference_sets(graph_params.lf_reference_set_input_by_output,
2423 graph_params.lf_reference_set_inputs);
2425 auto add_reference_set_zone_input = [&](
const ReferenceSetIndex reference_set_i) {
2426 lf::GraphInputSocket &lf_graph_input = graph_params.lf_graph.add_input(
2427 CPPType::get<GeometryNodesReferenceSet>(),
"Reference Set");
2428 lf_reference_sets.add(reference_set_i, &lf_graph_input);
2431 VectorSet<ReferenceSetIndex> input_reference_sets;
2432 for (
const ReferenceSetIndex reference_set_i : all_required_reference_sets) {
2433 const ReferenceSetInfo &reference_set = reference_lifetimes_.
reference_sets[reference_set_i];
2434 switch (reference_set.type) {
2435 case ReferenceSetType::GroupOutputData:
2436 case ReferenceSetType::GroupInputReferenceSet: {
2437 add_reference_set_zone_input(reference_set_i);
2440 case ReferenceSetType::LocalReferenceSet:
2441 case ReferenceSetType::ClosureOutputData:
2442 case ReferenceSetType::ClosureInputReferenceSet: {
2443 const bNodeSocket &bsocket = *reference_set.socket;
2444 if (lf::OutputSocket *lf_socket = graph_params.lf_output_by_bsocket.lookup_default(
2447 lf::OutputSocket *lf_usage_socket = graph_params.usage_by_bsocket.
lookup_default(
2449 lf::OutputSocket &lf_reference_set_socket = this->get_extracted_reference_set(
2450 *lf_socket, lf_usage_socket, graph_params);
2451 lf_reference_sets.add(reference_set_i, &lf_reference_set_socket);
2455 add_reference_set_zone_input(reference_set_i);
2467 void build_root_graph()
2469 lf::Graph &lf_graph = lf_graph_info_->graph;
2471 this->build_main_group_inputs(lf_graph);
2472 if (btree_.group_output_node() ==
nullptr) {
2473 this->build_fallback_group_outputs(lf_graph);
2476 for (
const bNodeTreeInterfaceSocket *interface_input : btree_.interface_inputs()) {
2477 lf::GraphOutputSocket &lf_socket = lf_graph.add_output(
2478 CPPType::get<bool>(), StringRef(
"Usage: ") + interface_input->name());
2479 group_input_usage_sockets_.
append(&lf_socket);
2482 Vector<lf::GraphInputSocket *> lf_output_usages;
2483 for (
const bNodeTreeInterfaceSocket *interface_output : btree_.interface_outputs()) {
2484 lf::GraphInputSocket &lf_socket = lf_graph.add_input(
2485 CPPType::get<bool>(), StringRef(
"Usage: ") + interface_output->name());
2486 group_output_used_sockets_.
append(&lf_socket);
2487 lf_output_usages.append(&lf_socket);
2490 BuildGraphParams &graph_params = root_graph_build_params_.emplace(lf_graph);
2491 if (
const bNode *group_output_bnode = btree_.group_output_node()) {
2492 for (
const bNodeSocket *bsocket : group_output_bnode->input_sockets().drop_back(1)) {
2493 graph_params.usage_by_bsocket.add(bsocket, lf_output_usages[bsocket->index()]);
2497 this->insert_nodes_and_zones(
2500 for (
const auto item : graph_params.lf_output_by_bsocket.items()) {
2501 this->insert_links_from_socket(*item.key, *item.value, graph_params);
2503 this->build_group_input_usages(graph_params);
2504 this->add_default_inputs(graph_params);
2506 this->build_root_reference_set_inputs(lf_graph);
2508 Map<ReferenceSetIndex, lf::OutputSocket *> lf_reference_sets;
2509 this->build_reference_sets_outside_of_zones(graph_params, lf_reference_sets);
2510 this->link_reference_sets(graph_params, lf_reference_sets);
2512 this->fix_link_cycles(lf_graph, graph_params.socket_usage_inputs);
2516 lf_graph.update_node_indices();
2517 lf_graph_info_->num_inline_nodes_approximate += lf_graph.nodes().size();
2524 void build_geometry_nodes_group_function()
2526 GeometryNodesGroupFunction &function = lf_graph_info_->function;
2528 Vector<const lf::GraphInputSocket *> lf_graph_inputs;
2529 Vector<const lf::GraphOutputSocket *> lf_graph_outputs;
2531 lf_graph_inputs.extend(group_input_sockets_);
2532 function.inputs.main = lf_graph_inputs.index_range().take_back(group_input_sockets_.
size());
2534 lf_graph_inputs.extend(group_output_used_sockets_);
2535 function.inputs.output_usages = lf_graph_inputs.index_range().take_back(
2536 group_output_used_sockets_.
size());
2538 for (
auto [output_index, lf_socket] : reference_set_by_output_.
items()) {
2539 lf_graph_inputs.append(lf_socket);
2540 function.inputs.references_to_propagate.geometry_outputs.append(output_index);
2542 function.inputs.references_to_propagate.range = lf_graph_inputs.index_range().take_back(
2543 reference_set_by_output_.
size());
2545 lf_graph_outputs.extend(standard_group_output_sockets_);
2546 function.outputs.main = lf_graph_outputs.index_range().take_back(
2547 standard_group_output_sockets_.
size());
2549 lf_graph_outputs.extend(group_input_usage_sockets_);
2550 function.outputs.input_usages = lf_graph_outputs.index_range().take_back(
2551 group_input_usage_sockets_.
size());
2553 Vector<const lf::FunctionNode *> &local_side_effect_nodes =
2554 scope_.
construct<Vector<const lf::FunctionNode *>>();
2555 for (
const bNode *bnode : btree_.nodes_by_type(
"GeometryNodeWarning"_ustr)) {
2556 if (bnode->output_socket(0).is_directly_linked()) {
2568 const lf::Socket *lf_socket = root_graph_build_params_->lf_inputs_by_bsocket.lookup(
2569 &bnode->input_socket(0))[0];
2570 const lf::FunctionNode &lf_node =
static_cast<const lf::FunctionNode &
>(lf_socket->node());
2571 local_side_effect_nodes.append(&lf_node);
2574 function.function = &scope_.
construct<lf::GraphExecutor>(
2575 lf_graph_info_->graph,
2576 std::move(lf_graph_inputs),
2577 std::move(lf_graph_outputs),
2578 &scope_.
construct<GeometryNodesLazyFunctionLogger>(*lf_graph_info_),
2579 &scope_.
construct<GeometryNodesLazyFunctionSideEffectProvider>(local_side_effect_nodes),
2583 void build_reference_sets_outside_of_zones(
2584 BuildGraphParams &graph_params,
2585 Map<ReferenceSetIndex, lf::OutputSocket *> &lf_reference_sets)
2587 const Vector<ReferenceSetIndex> all_required_reference_sets =
2588 this->find_all_required_reference_sets(graph_params.lf_reference_set_input_by_output,
2589 graph_params.lf_reference_set_inputs);
2590 for (
const ReferenceSetIndex reference_set_i : all_required_reference_sets) {
2591 const ReferenceSetInfo &reference_set = reference_lifetimes_.
reference_sets[reference_set_i];
2592 switch (reference_set.type) {
2593 case ReferenceSetType::LocalReferenceSet: {
2594 const bNodeSocket &bsocket = *reference_set.socket;
2595 lf::OutputSocket &lf_socket = *graph_params.lf_output_by_bsocket.
lookup(&bsocket);
2596 lf::OutputSocket *lf_usage_socket = graph_params.usage_by_bsocket.
lookup_default(
2598 lf::OutputSocket &lf_reference_set_socket = this->get_extracted_reference_set(
2599 lf_socket, lf_usage_socket, graph_params);
2600 lf_reference_sets.add_new(reference_set_i, &lf_reference_set_socket);
2603 case ReferenceSetType::GroupInputReferenceSet: {
2604 const int group_input_i = reference_set.index;
2605 lf::GraphInputSocket &lf_socket = *group_input_sockets_[group_input_i];
2606 lf::OutputSocket *lf_usage_socket = group_input_usage_sockets_[group_input_i]->origin();
2607 lf::OutputSocket &lf_reference_set_socket = this->get_extracted_reference_set(
2608 lf_socket, lf_usage_socket, graph_params);
2609 lf_reference_sets.add_new(reference_set_i, &lf_reference_set_socket);
2612 case ReferenceSetType::GroupOutputData: {
2613 const int group_output_i = reference_set.index;
2614 lf::GraphInputSocket *lf_reference_set_socket = reference_set_by_output_.
lookup(
2616 lf_reference_sets.add_new(reference_set_i, lf_reference_set_socket);
2619 case ReferenceSetType::ClosureOutputData:
2620 case ReferenceSetType::ClosureInputReferenceSet: {
2629 Vector<ReferenceSetIndex> find_all_required_reference_sets(
2630 const Map<const bNodeSocket *, lf::InputSocket *> &lf_reference_set_input_by_output,
2631 const MultiValueMap<ReferenceSetIndex, lf::InputSocket *> &lf_reference_set_inputs)
2633 BitVector<> all_required_reference_sets(reference_lifetimes_.
reference_sets.size(),
false);
2634 for (
const bNodeSocket *bsocket : lf_reference_set_input_by_output.keys()) {
2635 all_required_reference_sets |=
2638 for (
const ReferenceSetIndex reference_set_i : lf_reference_set_inputs.keys()) {
2639 all_required_reference_sets[reference_set_i].set();
2641 Vector<ReferenceSetIndex> indices;
2642 bits::foreach_1_index(all_required_reference_sets,
2643 [&](
const int index) { indices.append(
index); });
2647 void link_reference_sets(BuildGraphParams &graph_params,
2648 const Map<ReferenceSetIndex, lf::OutputSocket *> &lf_reference_sets)
2652 for (
const auto &item : graph_params.lf_reference_set_input_by_output.items()) {
2653 const bNodeSocket &output_bsocket = *item.key;
2654 lf::InputSocket &lf_reference_set_input = *item.value;
2656 Vector<lf::OutputSocket *> lf_reference_sets_to_join;
2657 const BoundedBitSpan required_reference_sets =
2659 bits::foreach_1_index(required_reference_sets, [&](
const ReferenceSetIndex reference_set_i) {
2660 const ReferenceSetInfo &reference_set =
2662 if (reference_set.type == ReferenceSetType::LocalReferenceSet) {
2663 if (&reference_set.socket->owner_node() == &output_bsocket.owner_node()) {
2668 lf_reference_sets_to_join.append(lf_reference_sets.lookup(reference_set_i));
2671 if (lf::OutputSocket *lf_joined_reference_set = this->join_reference_sets(
2672 lf_reference_sets_to_join,
2673 join_reference_sets_cache,
2674 graph_params.lf_graph,
2675 graph_params.socket_usage_inputs))
2677 graph_params.lf_graph.add_link(*lf_joined_reference_set, lf_reference_set_input);
2680 static const GeometryNodesReferenceSet empty_reference_set;
2681 lf_reference_set_input.set_default_value(&empty_reference_set);
2686 for (
const auto &item : graph_params.lf_reference_set_inputs.items()) {
2688 lf::OutputSocket &lf_reference_set = *lf_reference_sets.
lookup(reference_set_i);
2689 for (lf::InputSocket *lf_reference_set_input : item.value) {
2690 graph_params.lf_graph.add_link(lf_reference_set, *lf_reference_set_input);
2695 void insert_nodes_and_zones(
const Span<const bNode *> bnodes,
2696 const Span<const bNodeTreeZone *> zones,
2697 BuildGraphParams &graph_params)
2699 Vector<const bNode *> nodes_to_insert = bnodes;
2700 Map<const bNode *, const bNodeTreeZone *> zone_by_output;
2701 for (
const bNodeTreeZone *zone : zones) {
2706 std::ranges::sort(nodes_to_insert, [](
const bNode *a,
const bNode *
b) {
2707 return a->runtime->toposort_right_to_left_index <
b->runtime->toposort_right_to_left_index;
2710 for (
const bNode *bnode : nodes_to_insert) {
2711 this->build_output_socket_usages(*bnode, graph_params);
2712 if (
const bNodeTreeZone *zone = zone_by_output.lookup_default(bnode,
nullptr)) {
2713 this->insert_child_zone_node(*zone, graph_params);
2716 this->insert_node_in_graph(*bnode, graph_params);
2721 void link_border_link_inputs_and_usages(
const bNodeTreeZone &zone,
2722 const Span<lf::GraphInputSocket *> lf_inputs,
2723 const Span<int> lf_border_link_input_indices,
2724 const Span<lf::GraphOutputSocket *> lf_usages,
2725 const Span<int> lf_border_link_usage_indices,
2726 BuildGraphParams &graph_params)
2728 lf::Graph &lf_graph = graph_params.lf_graph;
2729 for (
const int border_link_i : zone.
border_links.index_range()) {
2730 const bNodeLink &border_link = *zone.
border_links[border_link_i];
2731 lf::GraphInputSocket &lf_from = *lf_inputs[lf_border_link_input_indices[border_link_i]];
2732 const Vector<lf::InputSocket *> lf_link_targets = this->find_link_targets(border_link,
2734 for (lf::InputSocket *lf_to : lf_link_targets) {
2735 lf_graph.add_link(lf_from, *lf_to);
2737 lf::GraphOutputSocket &lf_usage_output =
2738 *lf_usages[lf_border_link_usage_indices[border_link_i]];
2739 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(
2740 border_link.tosock,
nullptr))
2742 lf_graph.add_link(*lf_usage, lf_usage_output);
2745 static const bool static_false =
false;
2746 lf_usage_output.set_default_value(&static_false);
2751 lf::OutputSocket &get_extracted_reference_set(lf::OutputSocket &lf_field_socket,
2752 lf::OutputSocket *lf_usage_socket,
2753 BuildGraphParams &graph_params)
2755 auto &lazy_function = scope_.
construct<LazyFunctionForExtractingReferenceSet>();
2756 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
2757 lf::InputSocket &lf_use_input = lf_node.input(0);
2758 lf::InputSocket &lf_field_input = lf_node.input(1);
2759 graph_params.socket_usage_inputs.add_new(&lf_use_input);
2760 if (lf_usage_socket) {
2761 graph_params.lf_graph.add_link(*lf_usage_socket, lf_use_input);
2764 static const bool static_false =
false;
2765 lf_use_input.set_default_value(&static_false);
2767 graph_params.lf_graph.add_link(lf_field_socket, lf_field_input);
2768 return lf_node.output(0);
2774 lf::OutputSocket *join_reference_sets(
const Span<lf::OutputSocket *> lf_reference_set_sockets,
2775 JoinReferenceSetsCache &cache,
2776 lf::Graph &lf_graph,
2777 Set<lf::InputSocket *> &socket_usage_inputs)
2779 if (lf_reference_set_sockets.
is_empty()) {
2782 if (lf_reference_set_sockets.
size() == 1) {
2783 return lf_reference_set_sockets[0];
2786 Vector<lf::OutputSocket *, 16> key = lf_reference_set_sockets;
2787 std::ranges::sort(key);
2788 return cache.lookup_or_add_cb(key, [&]() {
2789 const auto &lazy_function = LazyFunctionForJoinReferenceSets::get_cached(
2790 lf_reference_set_sockets.
size(), scope_);
2791 lf::Node &lf_node = lf_graph.add_function(lazy_function);
2792 for (
const int i : lf_reference_set_sockets.
index_range()) {
2793 lf::OutputSocket &lf_reference_set_socket = *lf_reference_set_sockets[i];
2794 lf::InputSocket &lf_use_input = lf_node.input(lazy_function.get_use_input(i));
2798 static const bool static_true =
true;
2799 lf_use_input.set_default_value(&static_true);
2801 socket_usage_inputs.add(&lf_use_input);
2802 lf::InputSocket &lf_reference_set_input = lf_node.input(
2803 lazy_function.get_reference_set_input(i));
2804 lf_graph.add_link(lf_reference_set_socket, lf_reference_set_input);
2806 return &lf_node.output(0);
2810 void insert_child_zone_node(
const bNodeTreeZone &child_zone, BuildGraphParams &graph_params)
2812 const int child_zone_i = child_zone.
index;
2813 ZoneBuildInfo &child_zone_info = zone_build_infos_[child_zone_i];
2814 lf::FunctionNode &child_zone_node = graph_params.lf_graph.add_function(
2815 *child_zone_info.lazy_function);
2819 int valid_socket_i = 0;
2820 for (
const bNodeSocket *bsocket : child_zone.
input_node()->input_sockets()) {
2824 lf::InputSocket &lf_input_socket = child_zone_node.input(
2825 child_zone_info.indices.inputs.main[valid_socket_i]);
2826 lf::OutputSocket &lf_usage_socket = child_zone_node.output(
2827 child_zone_info.indices.outputs.input_usages[valid_socket_i]);
2828 this->add_to_socket_map(graph_params, *bsocket, lf_input_socket);
2829 graph_params.usage_by_bsocket.add(bsocket, &lf_usage_socket);
2834 int valid_socket_i = 0;
2835 for (
const bNodeSocket *bsocket : child_zone.
output_node()->output_sockets()) {
2839 lf::OutputSocket &lf_output_socket = child_zone_node.output(
2840 child_zone_info.indices.outputs.main[valid_socket_i]);
2841 lf::InputSocket &lf_usage_input = child_zone_node.input(
2842 child_zone_info.indices.inputs.output_usages[valid_socket_i]);
2843 this->add_to_socket_map(graph_params, *bsocket, lf_output_socket);
2844 graph_params.socket_usage_inputs.add(&lf_usage_input);
2845 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(bsocket,
2848 graph_params.lf_graph.add_link(*lf_usage, lf_usage_input);
2851 static const bool static_false =
false;
2852 lf_usage_input.set_default_value(&static_false);
2858 const Span<const bNodeLink *> child_border_links = child_zone.
border_links;
2859 for (
const int child_border_link_i : child_border_links.
index_range()) {
2860 lf::InputSocket &child_border_link_input = child_zone_node.input(
2861 child_zone_info.indices.inputs.border_links[child_border_link_i]);
2862 const bNodeLink &link = *child_border_links[child_border_link_i];
2863 graph_params.lf_input_by_border_link.add(&link, &child_border_link_input);
2864 lf::OutputSocket &lf_usage = child_zone_node.output(
2865 child_zone_info.indices.outputs.border_link_usages[child_border_link_i]);
2866 graph_params.lf_inputs_by_bsocket.
add(link.tosock, &child_border_link_input);
2867 graph_params.usage_by_bsocket.add(link.tosock, &lf_usage);
2870 for (
const auto &item : child_zone_info.indices.inputs.reference_sets.items()) {
2872 const int child_zone_input_i = item.value;
2873 lf::InputSocket &lf_reference_set_input = child_zone_node.input(child_zone_input_i);
2874 BLI_assert(lf_reference_set_input.type().is<GeometryNodesReferenceSet>());
2875 graph_params.lf_reference_set_inputs.add(reference_set_i, &lf_reference_set_input);
2879 void build_main_group_inputs(lf::Graph &lf_graph)
2881 const Span<const bNodeTreeInterfaceSocket *> interface_inputs = btree_.interface_inputs();
2882 for (
const bNodeTreeInterfaceSocket *interface_input : interface_inputs) {
2883 lf::GraphInputSocket &lf_socket = lf_graph.add_input(CPPType::get<SocketValueVariant>(),
2884 interface_input->name());
2885 group_input_sockets_.
append(&lf_socket);
2893 void build_fallback_group_outputs(lf::Graph &lf_graph)
2895 for (
const bNodeTreeInterfaceSocket *interface_output : btree_.interface_outputs()) {
2896 const bke::bNodeSocketType *typeinfo = interface_output->socket_typeinfo();
2897 lf::GraphOutputSocket &lf_socket = lf_graph.add_output(CPPType::get<SocketValueVariant>(),
2898 interface_output->name());
2899 lf_socket.set_default_value(typeinfo->geometry_nodes_default_value);
2900 standard_group_output_sockets_.
append(&lf_socket);
2904 void insert_node_in_graph(
const bNode &bnode, BuildGraphParams &graph_params)
2906 const bke::bNodeType *node_type = bnode.
typeinfo;
2907 if (node_type ==
nullptr) {
2910 if (bnode.is_muted()) {
2911 this->build_muted_node(bnode, graph_params);
2914 if (bnode.is_group()) {
2917 this->build_group_node(bnode, graph_params);
2920 switch (node_type->type_legacy) {
2926 this->build_reroute_node(bnode, graph_params);
2930 this->handle_group_input_node(bnode, graph_params);
2934 this->build_group_output_node(bnode, graph_params);
2938 this->build_viewer_node(bnode, graph_params);
2942 this->build_switch_node(bnode, graph_params);
2946 this->build_index_switch_node(bnode, graph_params);
2950 this->build_warning_node(bnode, graph_params);
2956 this->build_gizmo_node(bnode, graph_params);
2960 this->build_bake_node(bnode, graph_params);
2964 this->build_menu_switch_node(bnode, graph_params);
2968 this->build_evaluate_closure_node(bnode, graph_params);
2972 if (node_type->geometry_node_execute) {
2973 this->build_geometry_node(bnode, graph_params);
2976 const NodeMultiFunctions::Item &fn_item = node_multi_functions_.
try_get(bnode);
2977 if (fn_item.fn !=
nullptr) {
2978 this->build_multi_function_node(bnode, fn_item, graph_params);
2981 if (bnode.is_type(
"NodeEnableOutput"_ustr)) {
2982 this->build_enable_output_node(bnode, graph_params);
2985 if (bnode.is_undefined()) {
2986 this->build_undefined_node(bnode, graph_params);
2995 void build_muted_node(
const bNode &bnode, BuildGraphParams &graph_params)
2997 auto &lazy_function = scope_.
construct<LazyFunctionForMutedNode>(
2999 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3000 for (
const bNodeSocket *bsocket : bnode.input_sockets()) {
3002 if (lf_index == -1) {
3005 this->add_to_socket_map(graph_params, *bsocket, lf_node.input(lf_index));
3007 for (
const bNodeSocket *bsocket : bnode.output_sockets()) {
3009 if (lf_index == -1) {
3012 this->add_to_socket_map(graph_params, *bsocket, lf_node.output(lf_index));
3015 this->build_muted_node_usages(bnode, graph_params);
3021 void build_muted_node_usages(
const bNode &bnode, BuildGraphParams &graph_params)
3024 MultiValueMap<const bNodeSocket *, const bNodeSocket *> outputs_by_input;
3025 for (
const bNodeInternalLink &blink : bnode.internal_links()) {
3026 outputs_by_input.add(blink.in, blink.out);
3028 for (
const auto item : outputs_by_input.items()) {
3029 const bNodeSocket &input_bsocket = *item.key;
3030 const Span<const bNodeSocket *> output_bsockets = item.value;
3033 Vector<lf::OutputSocket *> lf_socket_usages;
3034 for (
const bNodeSocket *output_bsocket : output_bsockets) {
3035 if (lf::OutputSocket *lf_socket = graph_params.usage_by_bsocket.lookup_default(
3036 output_bsocket,
nullptr))
3038 lf_socket_usages.append(lf_socket);
3041 graph_params.usage_by_bsocket.add(&input_bsocket,
3042 this->or_socket_usages(lf_socket_usages, graph_params));
3046 void build_reroute_node(
const bNode &bnode, BuildGraphParams &graph_params)
3048 const bNodeSocket &input_bsocket = bnode.input_socket(0);
3049 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3050 if (!input_bsocket.typeinfo->geometry_nodes_default_value) {
3054 auto &lazy_function = scope_.
construct<LazyFunctionForRerouteNode>();
3055 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3057 this->add_to_socket_map(graph_params, input_bsocket, lf_node.input(0));
3058 this->add_to_socket_map(graph_params, output_bsocket, lf_node.output(0));
3060 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(
3061 &bnode.output_socket(0),
nullptr))
3063 graph_params.usage_by_bsocket.add(&bnode.input_socket(0), lf_usage);
3067 void handle_group_input_node(
const bNode &bnode, BuildGraphParams &graph_params)
3069 for (
const int i : btree_.interface_inputs().index_range()) {
3070 const bNodeSocket &bsocket = bnode.output_socket(i);
3071 lf::GraphInputSocket &lf_socket = *
const_cast<lf::GraphInputSocket *
>(
3072 group_input_sockets_[i]);
3073 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3077 void build_group_output_node(
const bNode &bnode, BuildGraphParams &graph_params)
3079 Vector<lf::GraphOutputSocket *> lf_graph_outputs;
3081 for (
const int i : btree_.interface_outputs().index_range()) {
3082 const bNodeTreeInterfaceSocket &interface_output = *btree_.interface_outputs()[i];
3083 const bNodeSocket &bsocket = bnode.input_socket(i);
3084 lf::GraphOutputSocket &lf_socket = graph_params.lf_graph.add_output(
3085 CPPType::get<SocketValueVariant>(), interface_output.name());
3086 lf_graph_outputs.append(&lf_socket);
3087 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3090 if (&bnode == btree_.group_output_node()) {
3091 standard_group_output_sockets_ = lf_graph_outputs.
as_span();
3095 void build_group_node(
const bNode &bnode, BuildGraphParams &graph_params)
3097 const bNodeTree *group_btree =
reinterpret_cast<bNodeTree *
>(bnode.id);
3098 if (group_btree ==
nullptr) {
3101 const std::shared_ptr<const GeometryNodesLazyFunctionGraphInfo> &group_lf_graph_info =
3103 if (!group_lf_graph_info) {
3107 scope_.
add(group_lf_graph_info);
3109 auto &lazy_function = scope_.
construct<LazyFunctionForGroupNode>(
3110 bnode, *group_lf_graph_info, *lf_graph_info_);
3111 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(lazy_function);
3113 for (
const int i : bnode.input_sockets().index_range()) {
3114 const bNodeSocket &bsocket = bnode.input_socket(i);
3116 lf::InputSocket &lf_socket = lf_node.input(group_lf_graph_info->function.inputs.main[i]);
3117 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3119 for (
const int i : bnode.output_sockets().index_range()) {
3120 const bNodeSocket &bsocket = bnode.output_socket(i);
3121 lf::OutputSocket &lf_socket = lf_node.output(group_lf_graph_info->function.outputs.main[i]);
3122 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3125 lf_graph_info_->num_inline_nodes_approximate +=
3126 group_lf_graph_info->num_inline_nodes_approximate;
3127 static const bool static_false =
false;
3128 for (
const bNodeSocket *bsocket : bnode.output_sockets()) {
3130 const int lf_input_index =
3132 if (lf_input_index != -1) {
3133 lf::InputSocket &lf_input = lf_node.input(lf_input_index);
3134 lf_input.set_default_value(&static_false);
3135 graph_params.socket_usage_inputs.add(&lf_input);
3140 const int lf_input_index =
3142 if (lf_input_index != -1) {
3143 lf::InputSocket &lf_input = lf_node.input(lf_input_index);
3144 graph_params.lf_reference_set_input_by_output.add(bsocket, &lf_input);
3149 this->build_group_node_socket_usage(bnode, lf_node, graph_params, *group_lf_graph_info);
3152 void build_group_node_socket_usage(
const bNode &bnode,
3153 lf::FunctionNode &lf_group_node,
3154 BuildGraphParams &graph_params,
3155 const GeometryNodesLazyFunctionGraphInfo &group_lf_graph_info)
3157 for (
const bNodeSocket *input_bsocket : bnode.input_sockets()) {
3158 const int input_index = input_bsocket->index();
3159 const InputUsageHint &input_usage_hint =
3160 group_lf_graph_info.mapping.group_input_usage_hints[input_index];
3161 switch (input_usage_hint.type) {
3162 case InputUsageHintType::Never: {
3166 case InputUsageHintType::DependsOnOutput: {
3167 Vector<lf::OutputSocket *> output_usages;
3168 for (
const int i : input_usage_hint.output_dependencies) {
3169 if (lf::OutputSocket *lf_socket = graph_params.usage_by_bsocket.lookup_default(
3170 &bnode.output_socket(i),
nullptr))
3172 output_usages.append(lf_socket);
3175 graph_params.usage_by_bsocket.add(input_bsocket,
3176 this->or_socket_usages(output_usages, graph_params));
3179 case InputUsageHintType::DynamicSocket: {
3180 graph_params.usage_by_bsocket.add(
3182 &lf_group_node.output(
3183 group_lf_graph_info.function.outputs.input_usages[input_index]));
3189 for (
const bNodeSocket *output_bsocket : bnode.output_sockets()) {
3190 const int lf_input_index =
3194 lf::InputSocket &lf_socket = lf_group_node.input(lf_input_index);
3195 if (lf::OutputSocket *lf_output_is_used = graph_params.usage_by_bsocket.lookup_default(
3196 output_bsocket,
nullptr))
3198 graph_params.lf_graph.add_link(*lf_output_is_used, lf_socket);
3201 static const bool static_false =
false;
3202 lf_socket.set_default_value(&static_false);
3207 void build_geometry_node(
const bNode &bnode, BuildGraphParams &graph_params)
3209 auto &lazy_function = scope_.
construct<LazyFunctionForGeometryNode>(bnode, *lf_graph_info_);
3210 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3212 for (
const bNodeSocket *bsocket : bnode.input_sockets()) {
3214 if (lf_index == -1) {
3217 lf::InputSocket &lf_socket = lf_node.input(lf_index);
3219 if (bsocket->is_multi_input()) {
3220 auto &multi_input_lazy_function = scope_.
construct<LazyFunctionForMultiInput>(*bsocket);
3221 lf::Node &lf_multi_input_node = graph_params.lf_graph.add_function(
3222 multi_input_lazy_function);
3223 graph_params.lf_graph.add_link(lf_multi_input_node.output(0), lf_socket);
3224 for (
const int i : multi_input_lazy_function.links.index_range()) {
3225 lf::InputSocket &lf_multi_input_socket = lf_multi_input_node.input(i);
3226 const bNodeLink *link = multi_input_lazy_function.links[i];
3227 graph_params.lf_input_by_multi_input_link.add(link, &lf_multi_input_socket);
3229 lf_multi_input_socket.set_default_value(bsocket->typeinfo->geometry_nodes_default_value);
3233 this->add_to_socket_map(graph_params, *bsocket, lf_socket);
3236 for (
const bNodeSocket *bsocket : bnode.output_sockets()) {
3238 if (lf_index == -1) {
3241 lf::OutputSocket &lf_socket = lf_node.output(lf_index);
3242 this->add_to_socket_map(graph_params, *bsocket, lf_socket);
3245 for (
const bNodeSocket *bsocket : bnode.output_sockets()) {
3247 const int lf_input_index =
3249 if (lf_input_index != -1) {
3250 lf::InputSocket &lf_input_socket = lf_node.input(lf_input_index);
3251 if (lf::OutputSocket *lf_usage = graph_params.usage_by_bsocket.lookup_default(bsocket,
3254 graph_params.lf_graph.add_link(*lf_usage, lf_input_socket);
3257 static const bool static_false =
false;
3258 lf_input_socket.set_default_value(&static_false);
3260 graph_params.socket_usage_inputs.add_new(&lf_node.input(lf_input_index));
3265 const int lf_input_index =
3267 if (lf_input_index != -1) {
3268 graph_params.lf_reference_set_input_by_output.add(bsocket,
3269 &lf_node.input(lf_input_index));
3274 this->build_standard_node_input_socket_usage(bnode, graph_params);
3277 void build_standard_node_input_socket_usage(
const bNode &bnode, BuildGraphParams &graph_params)
3279 if (bnode.input_sockets().is_empty()) {
3283 Vector<lf::OutputSocket *> output_usages;
3284 for (
const bNodeSocket *output_socket : bnode.output_sockets()) {
3285 if (!output_socket->is_available()) {
3288 if (lf::OutputSocket *is_used_socket = graph_params.usage_by_bsocket.lookup_default(
3289 output_socket,
nullptr))
3291 output_usages.append_non_duplicates(is_used_socket);
3296 lf::OutputSocket *lf_usage = this->or_socket_usages(output_usages, graph_params);
3297 if (lf_usage ==
nullptr) {
3301 for (
const bNodeSocket *input_socket : bnode.input_sockets()) {
3302 if (input_socket->is_available()) {
3303 graph_params.usage_by_bsocket.add(input_socket, lf_usage);
3308 void build_multi_function_node(
const bNode &bnode,
3309 const NodeMultiFunctions::Item &fn_item,
3310 BuildGraphParams &graph_params)
3312 auto &lazy_function = scope_.
construct<LazyFunctionForMultiFunctionNode>(
3314 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(lazy_function);
3316 for (
const bNodeSocket *bsocket : bnode.input_sockets()) {
3318 if (lf_index == -1) {
3322 this->add_to_socket_map(graph_params, *bsocket, lf_node.input(lf_index));
3324 for (
const bNodeSocket *bsocket : bnode.output_sockets()) {
3326 if (lf_index == -1) {
3329 this->add_to_socket_map(graph_params, *bsocket, lf_node.output(lf_index));
3332 this->build_standard_node_input_socket_usage(bnode, graph_params);
3335 void build_viewer_node(
const bNode &bnode, BuildGraphParams &graph_params)
3337 auto &lazy_function = scope_.
construct<LazyFunctionForViewerNode>(
3339 lf::FunctionNode &lf_viewer_node = graph_params.lf_graph.add_function(lazy_function);
3341 for (
const bNodeSocket *bsocket : bnode.input_sockets().drop_back(1)) {
3343 this->add_to_socket_map(graph_params, *bsocket, lf_viewer_node.input(lf_index));
3349 auto &usage_lazy_function = scope_.
construct<LazyFunctionForViewerInputUsage>(
3351 lf::FunctionNode &lf_usage_node = graph_params.lf_graph.add_function(usage_lazy_function);
3353 for (
const bNodeSocket *bsocket : bnode.input_sockets().drop_back(1)) {
3354 graph_params.usage_by_bsocket.add(bsocket, &lf_usage_node.output(0));
3359 void build_gizmo_node(
const bNode &bnode, BuildGraphParams &graph_params)
3361 auto &lazy_function = scope_.
construct<LazyFunctionForGizmoNode>(
3363 lf::FunctionNode &lf_gizmo_node = graph_params.lf_graph.add_function(lazy_function);
3364 lazy_function.self_node = &lf_gizmo_node;
3366 for (
const int i : lazy_function.gizmo_links.index_range()) {
3367 const bNodeLink &link = *lazy_function.gizmo_links[i];
3368 lf::InputSocket &lf_socket = lf_gizmo_node.input(i);
3369 graph_params.lf_input_by_multi_input_link.add(&link, &lf_socket);
3371 for (
const int i : bnode.input_sockets().drop_front(1).index_range()) {
3372 this->add_to_socket_map(graph_params,
3373 bnode.input_socket(i + 1),
3374 lf_gizmo_node.input(i + lazy_function.gizmo_links.size()));
3376 for (
const int i : bnode.output_sockets().index_range()) {
3377 this->add_to_socket_map(graph_params, bnode.output_socket(i), lf_gizmo_node.output(i));
3380 this->build_gizmo_node_socket_usage(bnode, graph_params, lf_gizmo_node);
3385 void build_gizmo_node_socket_usage(
const bNode &bnode,
3386 BuildGraphParams &graph_params,
3387 const lf::FunctionNode &lf_gizmo_node)
3389 const auto &usage_fn = scope_.
construct<LazyFunctionForGizmoInputsUsage>(bnode, lf_gizmo_node);
3390 lf::FunctionNode &lf_usage_node = graph_params.lf_graph.add_function(usage_fn);
3391 for (
const bNodeSocket *bsocket : bnode.input_sockets()) {
3392 graph_params.usage_by_bsocket.add(bsocket, &lf_usage_node.output(0));
3396 lf::FunctionNode *insert_simulation_input_node(
const bNodeTree &node_tree,
3398 BuildGraphParams &graph_params)
3400 const NodeGeometrySimulationInput *
storage =
static_cast<const NodeGeometrySimulationInput *
>(
3402 if (node_tree.node_by_id(
storage->output_node_id) ==
nullptr) {
3407 node_tree, bnode, *lf_graph_info_);
3408 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3409 scope_.
add(std::move(lazy_function));
3411 for (
const int i : bnode.input_sockets().index_range().drop_back(1)) {
3412 const bNodeSocket &bsocket = bnode.input_socket(i);
3413 this->add_to_socket_map(
3418 for (
const int i : bnode.output_sockets().index_range().drop_back(1)) {
3419 const bNodeSocket &bsocket = bnode.output_socket(i);
3420 this->add_to_socket_map(
3428 lf::FunctionNode &insert_simulation_output_node(
const bNode &bnode,
3429 BuildGraphParams &graph_params)
3432 bnode, *lf_graph_info_);
3433 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3434 scope_.
add(std::move(lazy_function));
3436 for (
const int i : bnode.input_sockets().index_range().drop_back(1)) {
3437 const bNodeSocket &bsocket = bnode.input_socket(i);
3438 this->add_to_socket_map(
3443 for (
const int i : bnode.output_sockets().index_range().drop_back(1)) {
3444 const bNodeSocket &bsocket = bnode.output_socket(i);
3445 this->add_to_socket_map(
3456 void build_bake_node(
const bNode &bnode, BuildGraphParams &graph_params)
3459 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3460 scope_.
add(std::move(lazy_function));
3462 for (
const int i : bnode.input_sockets().index_range().drop_back(1)) {
3463 const bNodeSocket &bsocket = bnode.input_socket(i);
3464 this->add_to_socket_map(
3469 for (
const int i : bnode.output_sockets().index_range().drop_back(1)) {
3470 const bNodeSocket &bsocket = bnode.output_socket(i);
3471 this->add_to_socket_map(
3479 this->build_bake_node_socket_usage(bnode, graph_params);
3482 void build_bake_node_socket_usage(
const bNode &bnode, BuildGraphParams &graph_params)
3484 const LazyFunction &usage_fn = scope_.
construct<LazyFunctionForBakeInputsUsage>(bnode);
3485 lf::FunctionNode &lf_usage_node = graph_params.lf_graph.add_function(usage_fn);
3486 const int items_num = bnode.input_sockets().size() - 1;
3487 for (
const int i : IndexRange(items_num)) {
3488 graph_params.usage_by_bsocket.add(&bnode.input_socket(i), &lf_usage_node.output(0));
3492 void build_switch_node(
const bNode &bnode, BuildGraphParams &graph_params)
3495 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3496 scope_.
add(std::move(lazy_function));
3498 for (
const int i : bnode.input_sockets().index_range()) {
3499 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3501 this->add_to_socket_map(graph_params, bnode.output_socket(0), lf_node.output(0));
3503 this->build_switch_node_socket_usage(bnode, graph_params);
3506 void build_switch_node_socket_usage(
const bNode &bnode, BuildGraphParams &graph_params)
3508 const bNodeSocket &switch_input_bsocket = bnode.input_socket(0);
3509 const bNodeSocket &false_input_bsocket = bnode.input_socket(1);
3510 const bNodeSocket &true_input_bsocket = bnode.input_socket(2);
3511 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3512 lf::OutputSocket *output_is_used_socket = graph_params.usage_by_bsocket.
lookup_default(
3513 &output_bsocket,
nullptr);
3514 if (output_is_used_socket ==
nullptr) {
3517 graph_params.usage_by_bsocket.add(&switch_input_bsocket, output_is_used_socket);
3518 if (switch_input_bsocket.is_directly_linked()) {
3520 static const LazyFunctionForSwitchSocketUsage switch_socket_usage_fn;
3521 lf::Node &lf_node = graph_params.lf_graph.add_function(switch_socket_usage_fn);
3522 graph_params.lf_inputs_by_bsocket.add(&switch_input_bsocket, &lf_node.input(0));
3523 graph_params.usage_by_bsocket.add(&false_input_bsocket, &lf_node.output(0));
3524 graph_params.usage_by_bsocket.add(&true_input_bsocket, &lf_node.output(1));
3527 if (switch_input_bsocket.default_value_typed<bNodeSocketValueBoolean>()->value) {
3528 graph_params.usage_by_bsocket.add(&true_input_bsocket, output_is_used_socket);
3531 graph_params.usage_by_bsocket.add(&false_input_bsocket, output_is_used_socket);
3536 void build_enable_output_node(
const bNode &bnode, BuildGraphParams &graph_params)
3539 bnode, *lf_graph_info_);
3540 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3541 scope_.
add(std::move(lazy_function));
3543 for (
const int i : bnode.input_sockets().index_range()) {
3544 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3546 for (
const int i : bnode.output_sockets().index_range()) {
3547 this->add_to_socket_map(graph_params, bnode.output_socket(i), lf_node.output(i));
3550 this->build_enable_output_node_socket_usage(bnode, graph_params);
3553 void build_enable_output_node_socket_usage(
const bNode &bnode, BuildGraphParams &graph_params)
3555 const bNodeSocket &enable_bsocket = *bnode.input_by_identifier(
"Enable"_ustr);
3556 const bNodeSocket &value_input_bsocket = *bnode.input_by_identifier(
"Value"_ustr);
3557 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3558 lf::OutputSocket *output_is_used_socket = graph_params.usage_by_bsocket.
lookup_default(
3559 &output_bsocket,
nullptr);
3560 if (!output_is_used_socket) {
3563 static LazyFunctionForEnableOutputSocketUsage socket_usage_fn;
3564 lf::Node &lf_node = graph_params.lf_graph.add_function(socket_usage_fn);
3565 graph_params.lf_inputs_by_bsocket.add(&enable_bsocket, &lf_node.input(0));
3566 graph_params.usage_by_bsocket.add(&enable_bsocket, output_is_used_socket);
3567 graph_params.usage_by_bsocket.add(&value_input_bsocket, &lf_node.output(0));
3570 void build_index_switch_node(
const bNode &bnode, BuildGraphParams &graph_params)
3573 bnode, *lf_graph_info_);
3574 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3575 scope_.
add(std::move(lazy_function));
3577 for (
const int i : bnode.input_sockets().drop_back(1).index_range()) {
3578 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3580 this->add_to_socket_map(graph_params, bnode.output_socket(0), lf_node.output(0));
3582 this->build_index_switch_node_socket_usage(bnode, graph_params);
3585 void build_index_switch_node_socket_usage(
const bNode &bnode, BuildGraphParams &graph_params)
3587 const bNodeSocket &index_socket = bnode.input_socket(0);
3588 const int items_num = bnode.input_sockets().size() - 1;
3590 lf::OutputSocket *output_is_used = graph_params.usage_by_bsocket.
lookup_default(
3591 &bnode.output_socket(0),
nullptr);
3592 if (output_is_used ==
nullptr) {
3595 graph_params.usage_by_bsocket.add(&index_socket, output_is_used);
3596 if (index_socket.is_directly_linked()) {
3598 auto usage_fn = std::make_unique<LazyFunctionForIndexSwitchSocketUsage>(bnode);
3599 lf::Node &lf_node = graph_params.lf_graph.add_function(*usage_fn);
3600 scope_.
add(std::move(usage_fn));
3602 graph_params.lf_inputs_by_bsocket.add(&index_socket, &lf_node.input(0));
3603 for (
const int i : IndexRange(items_num)) {
3604 graph_params.usage_by_bsocket.add(&bnode.input_socket(i + 1), &lf_node.output(i));
3608 const int index = index_socket.default_value_typed<bNodeSocketValueInt>()->value;
3610 graph_params.usage_by_bsocket.add(&bnode.input_socket(
index + 1), output_is_used);
3615 void build_warning_node(
const bNode &bnode, BuildGraphParams &graph_params)
3618 LazyFunction &lazy_function = *lazy_function_ptr;
3619 scope_.
add(std::move(lazy_function_ptr));
3621 lf::Node &lf_node = graph_params.lf_graph.add_function(lazy_function);
3623 for (
const int i : bnode.input_sockets().index_range()) {
3624 this->add_to_socket_map(graph_params, bnode.input_socket(i), lf_node.input(i));
3626 for (
const int i : bnode.output_sockets().index_range()) {
3627 this->add_to_socket_map(graph_params, bnode.output_socket(i), lf_node.output(i));
3630 const bNodeSocket &output_bsocket = bnode.output_socket(0);
3632 lf::OutputSocket *lf_usage =
nullptr;
3633 if (output_bsocket.is_directly_linked()) {
3635 lf_usage = graph_params.usage_by_bsocket.lookup_default(&output_bsocket,
nullptr);
3639 lf_usage = this->or_socket_usages(group_output_used_sockets_, graph_params);
3642 for (
const bNodeSocket *socket : bnode.input_sockets()) {
3643 graph_params.usage_by_bsocket.add(socket, lf_usage);
3648 void build_menu_switch_node(
const bNode &bnode, BuildGraphParams &graph_params)
3650 const NodeMenuSwitch &
storage = *
static_cast<NodeMenuSwitch *
>(bnode.storage);
3658 bnode, *lf_graph_info_);
3660 lf::FunctionNode &lf_value_node = graph_params.lf_graph.add_function(*value_fn);
3661 lf::FunctionNode &lf_bools_node = graph_params.lf_graph.add_function(*bools_fn);
3662 scope_.
add(std::move(value_fn));
3663 scope_.
add(std::move(bools_fn));
3665 for (
const int i : bnode.input_sockets().index_range().drop_back(1)) {
3666 const bNodeSocket &bsocket = bnode.input_socket(i);
3667 this->add_to_socket_map(graph_params, bsocket, lf_value_node.input(i));
3669 this->add_to_socket_map(graph_params, bnode.input_socket(0), lf_bools_node.input(0));
3671 this->add_to_socket_map(graph_params, bnode.output_socket(0), lf_value_node.output(0));
3673 for (
const int i : IndexRange(
storage.enum_definition.items_num)) {
3674 const bNodeSocket &bsocket = bnode.output_socket(i + 1);
3675 this->add_to_socket_map(graph_params, bsocket, lf_bools_node.output(i));
3678 this->build_menu_switch_node_socket_usage(bnode, graph_params);
3681 void build_menu_switch_node_socket_usage(
const bNode &bnode, BuildGraphParams &graph_params)
3683 const NodeMenuSwitch &
storage = *
static_cast<NodeMenuSwitch *
>(bnode.storage);
3684 const NodeEnumDefinition &enum_def =
storage.enum_definition;
3686 const bNodeSocket *switch_input_bsocket = bnode.input_sockets()[0];
3687 Vector<const bNodeSocket *> input_bsockets(enum_def.items_num);
3688 for (
const int i : IndexRange(enum_def.items_num)) {
3689 input_bsockets[i] = bnode.input_sockets()[i + 1];
3691 const bNodeSocket *output_bsocket = bnode.output_sockets()[0];
3693 lf::OutputSocket *output_is_used_socket = graph_params.usage_by_bsocket.
lookup_default(
3694 output_bsocket,
nullptr);
3695 if (output_is_used_socket ==
nullptr) {
3698 graph_params.usage_by_bsocket.add(switch_input_bsocket, output_is_used_socket);
3699 if (switch_input_bsocket->is_directly_linked()) {
3701 std::unique_ptr<LazyFunction> lazy_function =
3703 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*lazy_function);
3704 scope_.
add(std::move(lazy_function));
3706 graph_params.lf_inputs_by_bsocket.add(switch_input_bsocket, &lf_node.input(0));
3707 for (
const int i : IndexRange(enum_def.items_num)) {
3708 graph_params.usage_by_bsocket.add(input_bsockets[i], &lf_node.output(i));
3713 switch_input_bsocket->default_value_typed<bNodeSocketValueMenu>()->value;
3714 for (
const int i : IndexRange(enum_def.items_num)) {
3715 const NodeEnumItem &enum_item = enum_def.items()[i];
3716 if (enum_item.identifier ==
condition) {
3717 graph_params.usage_by_bsocket.add(input_bsockets[i], output_is_used_socket);
3724 void build_evaluate_closure_node(
const bNode &bnode, BuildGraphParams &graph_params)
3728 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(*function.lazy_function);
3729 const int inputs_num = bnode.input_sockets().size() - 1;
3730 const int outputs_num = bnode.output_sockets().size() - 1;
3731 BLI_assert(inputs_num == function.indices.inputs.main.size());
3732 BLI_assert(inputs_num == function.indices.outputs.input_usages.size());
3733 BLI_assert(outputs_num == function.indices.outputs.main.size());
3734 BLI_assert(outputs_num == function.indices.inputs.output_usages.size());
3738 for (
const int i : IndexRange(inputs_num)) {
3739 const bNodeSocket &bsocket = bnode.input_socket(i);
3740 lf::InputSocket &lf_socket = lf_node.input(function.indices.inputs.main[i]);
3741 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3742 graph_params.usage_by_bsocket.add(&bsocket,
3743 &lf_node.output(function.indices.outputs.input_usages[i]));
3745 for (
const int i : IndexRange(outputs_num)) {
3746 const bNodeSocket &bsocket = bnode.output_socket(i);
3747 lf::OutputSocket &lf_socket = lf_node.output(function.indices.outputs.main[i]);
3748 this->add_to_socket_map(graph_params, bsocket, lf_socket);
3749 lf::InputSocket &lf_usage_socket = lf_node.input(function.indices.inputs.output_usages[i]);
3750 graph_params.socket_usage_inputs.add(&lf_usage_socket);
3751 if (lf::OutputSocket *output_is_used = graph_params.usage_by_bsocket.lookup(&bsocket)) {
3752 graph_params.lf_graph.add_link(*output_is_used, lf_usage_socket);
3755 static const bool static_false =
false;
3756 lf_usage_socket.set_default_value(&static_false);
3759 for (
const auto item : function.indices.inputs.reference_set_by_output.items()) {
3760 const bNodeSocket &bsocket = bnode.output_socket(item.key);
3761 lf_graph_info_->mapping
3762 .lf_input_index_for_reference_set_for_output[bsocket.index_in_all_outputs()] =
3764 graph_params.lf_reference_set_input_by_output.add(&bsocket, &lf_node.input(item.value));
3768 void build_undefined_node(
const bNode &bnode, BuildGraphParams &graph_params)
3770 auto &lazy_function = scope_.
construct<LazyFunctionForUndefinedNode>(
3772 lf::FunctionNode &lf_node = graph_params.lf_graph.add_function(lazy_function);
3774 for (
const bNodeSocket *bsocket : bnode.output_sockets()) {
3776 if (lf_index == -1) {
3779 this->add_to_socket_map(graph_params, *bsocket, lf_node.output(lf_index));
3783 void add_to_socket_map(BuildGraphParams &graph_params,
3784 const bNodeSocket &bsocket,
3785 lf::InputSocket &lf_socket)
3787 graph_params.lf_inputs_by_bsocket.add(&bsocket, &lf_socket);
3791 void add_to_socket_map(BuildGraphParams &graph_params,
3792 const bNodeSocket &bsocket,
3793 lf::OutputSocket &lf_socket)
3795 graph_params.lf_output_by_bsocket.add(&bsocket, &lf_socket);
3799 struct TypeWithLinks {
3800 const bke::bNodeSocketType *typeinfo;
3801 Vector<const bNodeLink *> links;
3804 void insert_links_from_socket(
const bNodeSocket &from_bsocket,
3805 lf::OutputSocket &from_lf_socket,
3806 BuildGraphParams &graph_params)
3808 if (from_bsocket.owner_node().is_dangling_reroute()) {
3812 const bke::bNodeSocketType &from_typeinfo = *from_bsocket.typeinfo;
3815 const Vector<TypeWithLinks> types_with_links = this->group_link_targets_by_type(from_bsocket);
3817 for (
const TypeWithLinks &type_with_links : types_with_links) {
3818 if (!type_with_links.typeinfo) {
3821 if (!type_with_links.typeinfo->geometry_nodes_default_value) {
3824 const bke::bNodeSocketType &to_typeinfo = *type_with_links.typeinfo;
3825 const Span<const bNodeLink *> links = type_with_links.links;
3827 lf::OutputSocket *converted_from_lf_socket = this->insert_type_conversion_if_necessary(
3828 from_lf_socket, from_typeinfo, to_typeinfo, graph_params.lf_graph);
3830 for (
const bNodeLink *link : links) {
3831 const Vector<lf::InputSocket *> lf_link_targets = this->find_link_targets(*link,
3833 if (converted_from_lf_socket ==
nullptr) {
3834 for (lf::InputSocket *to_lf_socket : lf_link_targets) {
3835 to_lf_socket->set_default_value(to_typeinfo.geometry_nodes_default_value);
3839 for (lf::InputSocket *to_lf_socket : lf_link_targets) {
3840 graph_params.lf_graph.add_link(*converted_from_lf_socket, *to_lf_socket);
3847 Vector<TypeWithLinks> group_link_targets_by_type(
const bNodeSocket &from_bsocket)
3849 const Span<const bNodeLink *> links_from_bsocket = from_bsocket.directly_linked_links();
3850 Vector<TypeWithLinks> types_with_links;
3851 for (
const bNodeLink *link : links_from_bsocket) {
3852 if (link->is_muted()) {
3855 if (!link->is_available()) {
3858 const bNodeSocket &to_bsocket = *link->tosock;
3859 bool inserted =
false;
3860 for (TypeWithLinks &types_with_links : types_with_links) {
3861 if (types_with_links.typeinfo == to_bsocket.typeinfo) {
3862 types_with_links.links.append(link);
3870 types_with_links.append({to_bsocket.typeinfo, {link}});
3872 return types_with_links;
3875 Vector<lf::InputSocket *> find_link_targets(
const bNodeLink &link,
3876 const BuildGraphParams &graph_params)
3878 if (lf::InputSocket *lf_input_socket = graph_params.lf_input_by_border_link.lookup_default(
3881 return {lf_input_socket};
3884 const bNodeSocket &to_bsocket = *link.tosock;
3885 if (to_bsocket.is_multi_input()) {
3888 for (
const bNodeLink *multi_input_link : to_bsocket.directly_linked_links()) {
3889 if (multi_input_link == &link) {
3892 if (multi_input_link->is_muted() || !multi_input_link->fromsock->is_available() ||
3893 multi_input_link->fromnode->is_dangling_reroute())
3899 if (to_bsocket.owner_node().is_muted()) {
3900 if (link_index == 0) {
3901 return Vector<lf::InputSocket *>(graph_params.lf_inputs_by_bsocket.lookup(&to_bsocket));
3905 lf::InputSocket *lf_multi_input_socket =
3906 graph_params.lf_input_by_multi_input_link.lookup_default(&link,
nullptr);
3907 if (!lf_multi_input_socket) {
3910 return {lf_multi_input_socket};
3914 return Vector<lf::InputSocket *>(graph_params.lf_inputs_by_bsocket.lookup(&to_bsocket));
3919 lf::OutputSocket *insert_type_conversion_if_necessary(lf::OutputSocket &from_socket,
3920 const bke::bNodeSocketType &from_typeinfo,
3921 const bke::bNodeSocketType &to_typeinfo,
3922 lf::Graph &lf_graph)
3924 if (from_typeinfo.type == to_typeinfo.type) {
3925 return &from_socket;
3928 from_typeinfo, to_typeinfo, scope_))
3930 lf::Node &conversion_node = lf_graph.add_function(*conversion_fn);
3931 lf_graph.add_link(from_socket, conversion_node.input(0));
3932 return &conversion_node.output(0);
3937 void add_default_inputs(BuildGraphParams &graph_params)
3939 for (
auto item : graph_params.lf_inputs_by_bsocket.items()) {
3940 const bNodeSocket &bsocket = *item.key;
3941 const Span<lf::InputSocket *> lf_sockets = item.value;
3942 for (lf::InputSocket *lf_socket : lf_sockets) {
3943 if (lf_socket->origin() !=
nullptr) {
3947 this->add_default_input(bsocket, *lf_socket, graph_params);
3952 void add_default_input(
const bNodeSocket &input_bsocket,
3953 lf::InputSocket &input_lf_socket,
3954 BuildGraphParams &graph_params)
3956 if (this->try_add_implicit_input(input_bsocket, input_lf_socket, graph_params)) {
3959 input_lf_socket.set_default_value(&scope_.
add_value(
3960 input_bsocket.typeinfo->get_geometry_nodes_cpp_value(input_bsocket.default_value)));
3963 bool try_add_implicit_input(
const bNodeSocket &input_bsocket,
3964 lf::InputSocket &input_lf_socket,
3965 BuildGraphParams &graph_params)
3967 const bNode &bnode = input_bsocket.owner_node();
3968 const SocketDeclaration *socket_decl = input_bsocket.runtime->declaration;
3969 if (socket_decl ==
nullptr) {
3972 if (socket_decl->default_input_type == NODE_DEFAULT_INPUT_VALUE) {
3975 lf::LazyFunction *lazy_function =
nullptr;
3977 socket_decl->default_input_type))
3979 std::function<void(
void *)> init_fn = [&bnode, implicit_input_fn](
void *r_value) {
3980 (*implicit_input_fn)(bnode, r_value);
3982 const CPPType &type = input_lf_socket.type();
3983 lazy_function = &scope_.
construct<LazyFunctionForImplicitInput>(type, std::move(init_fn));
3985 else if (socket_decl->default_input_type == NODE_DEFAULT_INPUT_SCENE_FRAME) {
3986 if (input_bsocket.type == SOCK_INT) {
3987 static LazyFunctionForImplicitSceneFrame<int> scene_frame_int;
3988 lazy_function = &scene_frame_int;
3990 else if (input_bsocket.type == SOCK_FLOAT) {
3991 static LazyFunctionForImplicitSceneFrame<float> scene_frame_float;
3992 lazy_function = &scene_frame_float;
3995 else if (socket_decl->default_input_type == NODE_DEFAULT_INPUT_SELF_OBJECT) {
3996 if (input_bsocket.type == SOCK_OBJECT) {
3997 static LazyFunctionForImplicitSelfObject self_object;
3998 lazy_function = &self_object;
4001 if (!lazy_function) {
4004 lf::Node &lf_node = graph_params.lf_graph.add_function(*lazy_function);
4005 graph_params.lf_graph.add_link(lf_node.output(0), input_lf_socket);
4014 void build_root_reference_set_inputs(lf::Graph &lf_graph)
4016 const rl::RelationsInNode &tree_relations = reference_lifetimes_.
tree_relations;
4017 Vector<int> output_indices;
4018 for (
const rl::DataPropagation &relation : tree_relations.data_propagations) {
4019 output_indices.append_non_duplicates(relation.to_output);
4022 for (
const int i : output_indices.index_range()) {
4023 const int output_index = output_indices[i];
4024 const StringRef name = btree_.interface_outputs()[output_index]->name();
4025 lf::GraphInputSocket &lf_socket = lf_graph.add_input(
4026 CPPType::get<GeometryNodesReferenceSet>(),
"Propagate: " + name);
4027 reference_set_by_output_.
add(output_index, &lf_socket);
4035 lf::OutputSocket *or_socket_usages(
const Span<lf::OutputSocket *> usages,
4036 BuildGraphParams &graph_params)
4041 if (usages.
size() == 1) {
4046 Vector<lf::OutputSocket *> usages_sorted(usages);
4047 std::ranges::sort(usages_sorted);
4048 return graph_params.socket_usages_combination_cache.lookup_or_add_cb(
4049 std::move(usages_sorted), [&]() {
4050 auto &logical_or_fn = scope_.
construct<LazyFunctionForLogicalOr>(usages.
size());
4051 lf::Node &logical_or_node = graph_params.lf_graph.add_function(logical_or_fn);
4053 for (
const int i : usages_sorted.index_range()) {
4054 graph_params.lf_graph.add_link(*usages_sorted[i], logical_or_node.input(i));
4056 return &logical_or_node.output(0);
4060 void build_output_socket_usages(
const bNode &bnode, BuildGraphParams &graph_params)
4063 for (
const bNodeSocket *socket : bnode.output_sockets()) {
4064 if (!socket->is_available()) {
4068 Vector<lf::OutputSocket *> target_usages;
4069 for (
const bNodeLink *link : socket->directly_linked_links()) {
4070 if (!link->is_used()) {
4073 const bNodeSocket &target_socket = *link->tosock;
4074 if (lf::OutputSocket *is_used_socket = graph_params.usage_by_bsocket.lookup_default(
4075 &target_socket,
nullptr))
4077 target_usages.append_non_duplicates(is_used_socket);
4081 graph_params.usage_by_bsocket.add(socket,
4082 this->or_socket_usages(target_usages, graph_params));
4086 void build_group_input_usages(BuildGraphParams &graph_params)
4088 const Span<const bNode *> group_input_nodes = btree_.group_input_nodes();
4089 for (
const int i : btree_.interface_inputs().index_range()) {
4090 Vector<lf::OutputSocket *> target_usages;
4091 for (
const bNode *group_input_node : group_input_nodes) {
4092 if (lf::OutputSocket *lf_socket = graph_params.usage_by_bsocket.lookup_default(
4093 &group_input_node->output_socket(i),
nullptr))
4095 target_usages.append_non_duplicates(lf_socket);
4099 lf::OutputSocket *lf_socket = this->or_socket_usages(target_usages, graph_params);
4100 lf::InputSocket *lf_group_output =
const_cast<lf::InputSocket *
>(
4101 group_input_usage_sockets_[i]);
4102 InputUsageHint input_usage_hint;
4103 if (lf_socket ==
nullptr) {
4104 static const bool static_false =
false;
4105 lf_group_output->set_default_value(&static_false);
4106 input_usage_hint.type = InputUsageHintType::Never;
4109 graph_params.lf_graph.add_link(*lf_socket, *lf_group_output);
4110 if (lf_socket->node().is_interface()) {
4113 input_usage_hint.type = InputUsageHintType::DependsOnOutput;
4114 input_usage_hint.output_dependencies = {
4118 input_usage_hint.type = InputUsageHintType::DynamicSocket;
4121 lf_graph_info_->mapping.group_input_usage_hints.append(std::move(input_usage_hint));
4136 void fix_link_cycles(lf::Graph &lf_graph,
const Set<lf::InputSocket *> &socket_usage_inputs)
4138 lf_graph.update_socket_indices();
4139 const int sockets_num = lf_graph.socket_num();
4141 struct SocketState {
4143 bool in_stack =
false;
4146 Array<SocketState> socket_states(sockets_num);
4148 Vector<lf::Socket *> lf_sockets_to_check;
4149 for (lf::Node *lf_node : lf_graph.nodes()) {
4150 if (lf_node->is_function()) {
4151 for (lf::OutputSocket *lf_socket : lf_node->outputs()) {
4152 if (lf_socket->targets().is_empty()) {
4153 lf_sockets_to_check.append(lf_socket);
4157 if (lf_node->outputs().is_empty()) {
4158 for (lf::InputSocket *lf_socket : lf_node->inputs()) {
4159 lf_sockets_to_check.append(lf_socket);
4163 Vector<lf::Socket *> lf_socket_stack;
4164 while (!lf_sockets_to_check.is_empty()) {
4165 lf::Socket *lf_inout_socket = lf_sockets_to_check.last();
4166 lf::Node &lf_node = lf_inout_socket->node();
4167 SocketState &
state = socket_states[lf_inout_socket->index_in_graph()];
4169 if (!
state.in_stack) {
4170 lf_socket_stack.append(lf_inout_socket);
4171 state.in_stack =
true;
4174 Vector<lf::Socket *, 16> lf_origin_sockets;
4175 if (lf_inout_socket->is_input()) {
4176 lf::InputSocket &lf_input_socket = lf_inout_socket->as_input();
4177 if (lf::OutputSocket *lf_origin_socket = lf_input_socket.origin()) {
4178 lf_origin_sockets.append(lf_origin_socket);
4182 lf::OutputSocket &lf_output_socket = lf_inout_socket->as_output();
4183 if (lf_node.is_function()) {
4184 lf::FunctionNode &lf_function_node =
static_cast<lf::FunctionNode &
>(lf_node);
4185 const lf::LazyFunction &fn = lf_function_node.function();
4186 fn.possible_output_dependencies(
4187 lf_output_socket.index(), [&](
const Span<int> input_indices) {
4188 for (const int input_index : input_indices) {
4189 lf_origin_sockets.append(&lf_node.input(input_index));
4195 bool pushed_socket =
false;
4196 bool detected_cycle =
false;
4197 for (lf::Socket *lf_origin_socket : lf_origin_sockets) {
4198 if (socket_states[lf_origin_socket->index_in_graph()].in_stack) {
4208 detected_cycle =
true;
4209 const int index_in_socket_stack = lf_socket_stack.first_index_of(lf_origin_socket);
4210 const int index_in_sockets_to_check = lf_sockets_to_check.first_index_of(
4212 const Span<lf::Socket *> cycle = lf_socket_stack.as_span().drop_front(
4213 index_in_socket_stack);
4215 bool broke_cycle =
false;
4216 for (lf::Socket *lf_cycle_socket : cycle) {
4217 if (lf_cycle_socket->is_input() &&
4218 socket_usage_inputs.contains(&lf_cycle_socket->as_input()))
4220 lf::InputSocket &lf_cycle_input_socket = lf_cycle_socket->as_input();
4221 lf_graph.clear_origin(lf_cycle_input_socket);
4222 static const bool static_true =
true;
4223 lf_cycle_input_socket.set_default_value(&static_true);
4227 SocketState &lf_cycle_socket_state = socket_states[lf_cycle_socket->index_in_graph()];
4228 lf_cycle_socket_state.in_stack =
false;
4235 lf_socket_stack.resize(index_in_socket_stack);
4237 lf_sockets_to_check.resize(index_in_sockets_to_check + 1);
4240 if (!socket_states[lf_origin_socket->index_in_graph()].done) {
4241 lf_sockets_to_check.append(lf_origin_socket);
4242 pushed_socket =
true;
4245 if (detected_cycle) {
4248 if (pushed_socket) {
4253 state.in_stack =
false;
4254 lf_sockets_to_check.pop_last();
4255 lf_socket_stack.pop_last();