55 std::optional<Span<bool>> top_level_ignored_inputs_;
65 const std::optional<
Span<bool>> top_level_ignored_inputs)
67 compute_context_cache_(compute_context_cache),
68 group_input_value_fn_(group_input_value_fn),
69 top_level_ignored_inputs_(top_level_ignored_inputs),
72 root_tree_.ensure_topology_cache();
73 root_tree_.ensure_interface_cache();
74 this->ensure_animation_data_processed(root_tree_);
79 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(socket);
80 if (value.has_value()) {
83 if (socket->owner_tree().has_available_link_cycle()) {
88 value_tasks_.push(socket);
90 while (!value_tasks_.is_empty()) {
92 this->value_task(socket);
93 if (&socket == &value_tasks_.peek()) {
99 return all_socket_values_.lookup(socket);
105 if (all_socket_values_.
contains(socket)) {
109 const bNode &
node = socket->owner_node();
110 if (
node.is_undefined() && !
node.is_custom_group()) {
120 if (socket->is_input()) {
121 this->value_task__input(socket);
124 this->value_task__output(socket);
128 void value_task__output(
const SocketInContext &socket)
130 const NodeInContext
node = socket.owner_node();
131 if (
node->is_muted()) {
132 this->value_task__output__muted_node(socket);
135 switch (
node->type_legacy) {
138 this->value_task__output__group_node(socket);
142 this->value_task__output__group_input_node(socket);
146 this->value_task__output__reroute_node(socket);
150 this->value_task__output__generic_switch(
155 this->value_task__output__generic_switch(
160 if (socket->index() == 0) {
161 this->value_task__output__generic_switch(
165 this->value_task__output__menu_switch_selection(socket);
170 this->value_task__output__generic_switch(
175 this->value_task__output__generic_switch(
180 this->value_task__output__float_math(socket);
184 this->value_task__output__vector_math(socket);
188 this->value_task__output__integer_math(socket);
192 this->value_task__output__boolean_math(socket);
196 this->value_task__output__warning(socket);
200 if (
node->is_type(
"NodeEnableOutput"_ustr)) {
201 this->value_task__output__enable_output(socket);
204 if (
node->is_type(
"NodeImplicitConversion"_ustr)) {
205 this->value_task__output__implicit_conversion_node(socket);
208 if (
node->typeinfo->build_multi_function) {
209 this->value_task__output__multi_function_node(socket);
220 void value_task__output__group_node(
const SocketInContext &socket)
222 const NodeInContext
node = socket.owner_node();
223 const bNodeTree *group =
reinterpret_cast<const bNodeTree *
>(
node->id);
228 group->ensure_topology_cache();
229 if (group->has_available_link_cycle()) {
233 this->ensure_animation_data_processed(*group);
234 const bNode *group_output_node = group->group_output_node();
235 if (!group_output_node) {
240 const ComputeContext &group_context = compute_context_cache_.for_group_node(
241 socket.context,
node->identifier, &
node->owner_tree());
242 const SocketInContext socket_in_group{&group_context,
243 &group_output_node->input_socket(socket->index())};
244 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(socket_in_group);
245 if (!value.has_value()) {
246 this->push_value_task(socket_in_group);
249 all_socket_values_.add_new(socket, *value);
252 void value_task__output__group_input_node(
const SocketInContext &socket)
254 const bool is_root_context = socket.context ==
nullptr;
255 if (is_root_context) {
257 if (group_input_value_fn_) {
258 value = group_input_value_fn_(socket->index());
260 all_socket_values_.add_new(socket, value);
264 const bke::GroupNodeComputeContext &group_context =
265 *
static_cast<const bke::GroupNodeComputeContext *
>(socket.context);
266 const SocketInContext group_node_input{group_context.parent(),
267 &group_context.node()->input_socket(socket->index())};
268 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(group_node_input);
269 if (!value.has_value()) {
270 this->push_value_task(group_node_input);
273 all_socket_values_.add_new(socket, *value);
276 void value_task__output__reroute_node(
const SocketInContext &socket)
278 const SocketInContext input_socket = socket.owner_node().input_socket(0);
279 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(input_socket);
280 if (!value.has_value()) {
281 this->push_value_task(input_socket);
284 all_socket_values_.add_new(socket, *value);
287 void value_task__output__implicit_conversion_node(
const SocketInContext &socket)
289 const SocketInContext input_socket = socket.owner_node().input_socket(0);
290 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(input_socket);
291 if (!value.has_value()) {
292 this->push_value_task(input_socket);
295 all_socket_values_.add_new(socket, *value);
298 void value_task__output__menu_switch_selection(
const SocketInContext &socket)
300 const NodeInContext
node = socket.owner_node();
301 const SocketInContext input_socket =
node.input_socket(0);
302 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(input_socket);
303 if (!value.has_value()) {
304 this->push_value_task(input_socket);
307 const std::optional<MenuValue> menu_value = value->get_if_primitive<MenuValue>();
308 if (!menu_value.has_value()) {
312 const NodeMenuSwitch &
storage = *
static_cast<const NodeMenuSwitch *
>(
node->storage);
313 const NodeEnumItem &item =
storage.enum_definition.items_array[socket->index() - 1];
314 const bool is_selected = item.identifier == menu_value->value;
315 all_socket_values_.add_new(socket, this->make_primitive_inference_value(is_selected));
318 void value_task__output__float_math(
const SocketInContext &socket)
320 const NodeInContext
node = socket.owner_node();
324 this->value_task__output__generic_eval(
325 socket, [&](
const Span<InferenceValue> inputs) -> std::optional<InferenceValue> {
326 const std::optional<float> a = inputs[0].get_if_primitive<
float>();
327 const std::optional<float>
b = inputs[1].get_if_primitive<
float>();
328 if (a == 0.0f ||
b == 0.0f) {
329 return this->make_primitive_inference_value(0.0f);
331 if (a.has_value() &&
b.has_value()) {
332 return this->make_primitive_inference_value(*a * *
b);
339 this->value_task__output__multi_function_node(socket);
345 void value_task__output__vector_math(
const SocketInContext &socket)
347 const NodeInContext
node = socket.owner_node();
351 this->value_task__output__generic_eval(
352 socket, [&](
const Span<InferenceValue> inputs) -> std::optional<InferenceValue> {
353 const std::optional<float3> a = inputs[0].get_if_primitive<
float3>();
354 const std::optional<float3>
b = inputs[1].get_if_primitive<
float3>();
356 return this->make_primitive_inference_value(
float3(0.0f));
358 if (a.has_value() &&
b.has_value()) {
359 return this->make_primitive_inference_value(
float3(*a * *
b));
366 this->value_task__output__generic_eval(
367 socket, [&](
const Span<InferenceValue> inputs) -> std::optional<InferenceValue> {
368 const std::optional<float3> a = inputs[0].get_if_primitive<
float3>();
369 const std::optional<float>
scale = inputs[3].get_if_primitive<
float>();
371 return this->make_primitive_inference_value(
float3(0.0f));
373 if (a.has_value() &&
scale.has_value()) {
374 return this->make_primitive_inference_value(
float3(*a * *
scale));
381 this->value_task__output__multi_function_node(socket);
387 void value_task__output__integer_math(
const SocketInContext &socket)
389 const NodeInContext
node = socket.owner_node();
393 this->value_task__output__generic_eval(
394 socket, [&](
const Span<InferenceValue> inputs) -> std::optional<InferenceValue> {
395 const std::optional<int> a = inputs[0].get_if_primitive<
int>();
396 const std::optional<int>
b = inputs[1].get_if_primitive<
int>();
397 if (a == 0 ||
b == 0) {
398 return this->make_primitive_inference_value(0);
400 if (a.has_value() &&
b.has_value()) {
401 return this->make_primitive_inference_value(*a * *
b);
408 this->value_task__output__multi_function_node(socket);
414 void value_task__output__boolean_math(
const SocketInContext &socket)
416 const NodeInContext
node = socket.owner_node();
419 const auto handle_binary_op =
420 [&](FunctionRef<std::optional<bool>(std::optional<bool>, std::optional<bool>)> fn) {
421 this->value_task__output__generic_eval(
422 socket, [&](
const Span<InferenceValue> inputs) -> std::optional<InferenceValue> {
423 const std::optional<bool> a = inputs[0].get_if_primitive<
bool>();
424 const std::optional<bool>
b = inputs[1].get_if_primitive<
bool>();
425 const std::optional<bool>
result = fn(a,
b);
427 return this->make_primitive_inference_value(*
result);
435 [](
const std::optional<bool> &a,
const std::optional<bool> &
b) -> std::optional<bool> {
436 if (a ==
false ||
b ==
false) {
439 if (a.has_value() &&
b.has_value()) {
448 [](
const std::optional<bool> &a,
const std::optional<bool> &
b) -> std::optional<bool> {
449 if (a ==
true ||
b ==
true) {
452 if (a.has_value() &&
b.has_value()) {
461 [](
const std::optional<bool> &a,
const std::optional<bool> &
b) -> std::optional<bool> {
462 if (a ==
false ||
b ==
false) {
465 if (a.has_value() &&
b.has_value()) {
474 [](
const std::optional<bool> &a,
const std::optional<bool> &
b) -> std::optional<bool> {
475 if (a ==
true ||
b ==
true) {
478 if (a.has_value() &&
b.has_value()) {
487 [](
const std::optional<bool> &a,
const std::optional<bool> &
b) -> std::optional<bool> {
488 if (a ==
false ||
b ==
true) {
491 if (a.has_value() &&
b.has_value()) {
500 [](
const std::optional<bool> &a,
const std::optional<bool> &
b) -> std::optional<bool> {
501 if (a ==
false ||
b ==
true) {
504 if (a.has_value() &&
b.has_value()) {
512 this->value_task__output__multi_function_node(socket);
518 void value_task__output__warning(
const SocketInContext &socket)
520 const NodeInContext
node = socket.owner_node();
521 const SocketInContext show_input_socket =
node.input_socket(0);
522 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(show_input_socket);
523 if (!value.has_value()) {
524 this->push_value_task(show_input_socket);
527 all_socket_values_.add_new(socket, *value);
530 void value_task__output__enable_output(
const SocketInContext &socket)
532 const NodeInContext
node = socket.owner_node();
533 const SocketInContext enable_input_socket =
node.input_socket(0);
534 const SocketInContext value_input_socket =
node.input_socket(1);
536 const std::optional<InferenceValue> keep_value = all_socket_values_.lookup_try(
537 enable_input_socket);
538 if (!keep_value.has_value()) {
539 this->push_value_task(enable_input_socket);
542 if (!keep_value->is_primitive_value()) {
546 const bool keep = keep_value->get_primitive<
bool>();
548 const CPPType &type = *socket->typeinfo->base_cpp_type;
552 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(value_input_socket);
553 if (!value.has_value()) {
554 this->push_value_task(value_input_socket);
557 all_socket_values_.add_new(socket, *value);
564 void value_task__output__generic_switch(
565 const SocketInContext &socket,
566 const FunctionRef<
bool(
const SocketInContext &socket, InferenceValue
condition)>
569 const NodeInContext
node = socket.owner_node();
573 const SocketInContext condition_socket{socket.context,
574 get_first_available_bsocket(
node->input_sockets())};
575 const std::optional<InferenceValue> condition_value = all_socket_values_.lookup_try(
577 if (!condition_value.has_value()) {
578 this->push_value_task(condition_socket);
581 if (condition_value->is_unknown()) {
586 Vector<const bNodeSocket *> selected_inputs;
587 for (
const int input_i :
588 node->input_sockets().index_range().drop_front(condition_socket->index() + 1))
590 const SocketInContext input_socket =
node.input_socket(input_i);
591 if (!input_socket->is_available()) {
594 if (input_socket->type ==
SOCK_CUSTOM &&
STREQ(input_socket->idname,
"NodeSocketVirtual")) {
597 const bool is_selected = is_selected_socket(input_socket, *condition_value);
599 selected_inputs.append(input_socket.socket);
602 if (selected_inputs.is_empty()) {
606 if (selected_inputs.size() == 1) {
608 const SocketInContext selected_input{socket.context, selected_inputs[0]};
609 const std::optional<InferenceValue> input_value = all_socket_values_.lookup_try(
611 if (!input_value.has_value()) {
612 this->push_value_task(selected_input);
615 all_socket_values_.add_new(socket, *input_value);
620 if (
node->typeinfo->build_multi_function) {
622 this->value_task__output__multi_function_node(socket);
629 void value_task__output__generic_eval(
630 const SocketInContext &socket,
631 const FunctionRef<std::optional<InferenceValue>(Span<InferenceValue> inputs)> eval_fn)
633 const NodeInContext
node = socket.owner_node();
634 const int inputs_num =
node->input_sockets().size();
637 std::optional<int> next_unknown_input_index;
638 for (
const int input_i :
IndexRange(inputs_num)) {
639 const SocketInContext input_socket =
node.input_socket(input_i);
640 if (!input_socket->is_available()) {
643 const std::optional<InferenceValue> input_value = all_socket_values_.lookup_try(
645 if (!input_value.has_value()) {
646 next_unknown_input_index = input_i;
649 input_values[input_i] = *input_value;
651 const std::optional<InferenceValue> output_value = eval_fn(input_values);
652 if (output_value.has_value()) {
654 all_socket_values_.add_new(socket, *output_value);
657 if (!next_unknown_input_index.has_value()) {
664 const SocketInContext next_input =
node.input_socket(*next_unknown_input_index);
665 this->push_value_task(next_input);
668 void value_task__output__multi_function_node(
const SocketInContext &socket)
670 const NodeInContext
node = socket.owner_node();
671 const int inputs_num =
node->input_sockets().size();
674 Vector<const void *> input_values(inputs_num);
675 for (
const int input_i :
IndexRange(inputs_num)) {
676 const SocketInContext input_socket =
node.input_socket(input_i);
677 const std::optional<InferenceValue> input_value = all_socket_values_.lookup_try(
679 if (!input_value.has_value()) {
680 this->push_value_task(input_socket);
683 if (!input_value->is_primitive_value()) {
687 input_values[input_i] = input_value->get_primitive_ptr();
691 NodeMultiFunctionBuilder builder{*
node.node,
node->owner_tree()};
692 node->typeinfo->build_multi_function(builder);
693 const mf::MultiFunction &fn = builder.function();
696 const IndexMask
mask(1);
699 mf::ParamsBuilder params{fn, &
mask};
700 for (
const int input_i :
IndexRange(inputs_num)) {
701 const SocketInContext input_socket =
node.input_socket(input_i);
702 if (!input_socket->is_available()) {
705 params.add_readonly_single_input(
706 GPointer(input_socket->typeinfo->base_cpp_type, input_values[input_i]));
708 for (
const int output_i :
node->output_sockets().index_range()) {
709 const SocketInContext output_socket =
node.output_socket(output_i);
710 if (!output_socket->is_available()) {
714 const CPPType &base_type = *output_socket->typeinfo->base_cpp_type;
715 void *value = scope_.allocate_owned(base_type);
716 params.add_uninitialized_single_output(
GMutableSpan(base_type, value, 1));
722 fn.call(mask, params, context);
725 void value_task__output__muted_node(
const SocketInContext &socket)
727 const NodeInContext
node = socket.owner_node();
729 SocketInContext input_socket;
730 for (
const bNodeInternalLink &internal_link :
node->internal_links()) {
731 if (internal_link.out == socket.socket) {
732 input_socket = SocketInContext{socket.context, internal_link.in};
741 const std::optional<InferenceValue> input_value = all_socket_values_.lookup_try(input_socket);
742 if (!input_value.has_value()) {
743 this->push_value_task(input_socket);
746 const InferenceValue converted_value = this->convert_type_if_necessary(
747 *input_value, *input_socket.socket, *socket.socket);
748 all_socket_values_.add_new(socket, converted_value);
751 void value_task__input(
const SocketInContext &socket)
753 if (socket->is_multi_input()) {
758 const bNodeLink *source_link =
nullptr;
759 const Span<const bNodeLink *> connected_links = socket->directly_linked_links();
760 for (
const bNodeLink *link : connected_links) {
761 if (!link->is_used()) {
764 if (link->fromnode->is_dangling_reroute()) {
771 this->value_task__input__unlinked(socket);
774 this->value_task__input__linked({socket.context, source_link->fromsock}, socket);
777 void value_task__input__unlinked(
const SocketInContext &socket)
779 if (this->treat_socket_as_unknown(socket)) {
783 if (animated_sockets_.contains(socket.socket)) {
788 if (
const SocketDeclaration *socket_decl = socket.socket->runtime->declaration) {
796 void *value_buffer = scope_.allocate_owned(*socket->typeinfo->base_cpp_type);
797 socket->typeinfo->get_base_cpp_value(socket->default_value, value_buffer);
801 void value_task__input__linked(
const SocketInContext &from_socket,
802 const SocketInContext &to_socket)
804 const std::optional<InferenceValue> from_value = all_socket_values_.lookup_try(from_socket);
805 if (!from_value.has_value()) {
806 this->push_value_task(from_socket);
809 const InferenceValue converted_value = this->convert_type_if_necessary(
810 *from_value, *from_socket.socket, *to_socket.socket);
811 all_socket_values_.add_new(to_socket, converted_value);
814 InferenceValue convert_type_if_necessary(
const InferenceValue &src,
815 const bNodeSocket &from_socket,
816 const bNodeSocket &to_socket)
818 if (!src.is_primitive_value()) {
821 const CPPType *from_type = from_socket.typeinfo->base_cpp_type;
822 const CPPType *
to_type = to_socket.typeinfo->base_cpp_type;
830 if (!conversions.is_convertible(*from_type, *
to_type)) {
833 void *dst = scope_.allocate_owned(*
to_type);
834 conversions.convert_to_uninitialized(*from_type, *
to_type, src.get_primitive_ptr(), dst);
838 bool treat_socket_as_unknown(
const SocketInContext &socket)
const
840 if (!top_level_ignored_inputs_.has_value()) {
843 if (socket.context) {
846 if (socket->is_output()) {
849 return (*top_level_ignored_inputs_)[socket->index_in_all_inputs()];
852 void ensure_animation_data_processed(
const bNodeTree &tree)
854 if (!trees_with_handled_animation_data_.add(&tree)) {
861 static std::regex pattern(R
"#(nodes\["(.*)"\].inputs\[(\d+)\].default_value)#");
862 MultiValueMap<StringRef, int> animated_inputs_by_node_name;
863 auto handle_rna_path = [&](
const char *rna_path) {
865 if (!std::regex_match(rna_path, match, pattern)) {
868 const StringRef node_name{match[1].first, match[1].second - match[1].first};
869 const int socket_index = std::stoi(match[2]);
870 animated_inputs_by_node_name.add(node_name, socket_index);
874 if (tree.adt->action) {
876 tree.adt->action->wrap(), tree.adt->slot_handle, [&](
const FCurve &fcurve) {
877 handle_rna_path(fcurve.rna_path().c_str());
881 for (
const FCurve &driver : tree.adt->drivers) {
882 handle_rna_path(driver.rna_path().c_str());
886 if (!animated_inputs_by_node_name.is_empty()) {
887 for (
const bNode *
node : tree.all_nodes()) {
888 const Span<int> animated_inputs = animated_inputs_by_node_name.lookup(
node->name);
889 const Span<const bNodeSocket *> input_sockets =
node->input_sockets();
890 for (
const int socket_index : animated_inputs) {
891 if (socket_index < 0 || socket_index >= input_sockets.
size()) {
896 const bNodeSocket &socket = *input_sockets[socket_index];
897 animated_sockets_.add(&socket);
903 void push_value_task(
const SocketInContext &socket)
905 value_tasks_.push(socket);
908 template<
typename T> InferenceValue make_primitive_inference_value(
const T &value)
914 static const bNodeSocket *get_first_available_bsocket(
const Span<const bNodeSocket *> sockets)
916 for (
const bNodeSocket *socket : sockets) {
917 if (socket->is_available()) {