Blender V5.3
socket_value_inference.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <regex>
10
11#include "NOD_menu_value.hh"
12#include "NOD_multi_function.hh"
16
17#include "DNA_anim_types.h"
18#include "DNA_material_types.h"
19#include "DNA_node_types.h"
20
24#include "BKE_node_runtime.hh"
26
27#include "ANIM_action.hh"
29
30#include "BLI_listbase.hh"
31#include "BLI_stack.hh"
32
33namespace blender::nodes {
34
36 private:
37 ResourceScope &scope_;
38 bke::ComputeContextCache &compute_context_cache_;
39
40 Stack<SocketInContext> value_tasks_;
45 Map<SocketInContext, InferenceValue> all_socket_values_;
46
47 FunctionRef<InferenceValue(int group_input_i)> group_input_value_fn_;
48
53 Set<const bNodeSocket *> animated_sockets_;
54 Set<const bNodeTree *> trees_with_handled_animation_data_;
55 std::optional<Span<bool>> top_level_ignored_inputs_;
56
57 const bNodeTree &root_tree_;
58
59 public:
61 const bNodeTree &tree,
62 ResourceScope &scope,
63 bke::ComputeContextCache &compute_context_cache,
64 const FunctionRef<InferenceValue(int group_input_i)> group_input_value_fn,
65 const std::optional<Span<bool>> top_level_ignored_inputs)
66 : scope_(scope),
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),
70 root_tree_(tree)
71 {
72 root_tree_.ensure_topology_cache();
73 root_tree_.ensure_interface_cache();
74 this->ensure_animation_data_processed(root_tree_);
75 }
76
78 {
79 const std::optional<InferenceValue> value = all_socket_values_.lookup_try(socket);
80 if (value.has_value()) {
81 return *value;
82 }
83 if (socket->owner_tree().has_available_link_cycle()) {
85 }
86
87 BLI_assert(value_tasks_.is_empty());
88 value_tasks_.push(socket);
89
90 while (!value_tasks_.is_empty()) {
91 const SocketInContext &socket = value_tasks_.peek();
92 this->value_task(socket);
93 if (&socket == &value_tasks_.peek()) {
94 /* The task is finished if it hasn't added any new task it depends on. */
95 value_tasks_.pop();
96 }
97 }
98
99 return all_socket_values_.lookup(socket);
100 }
101
102 private:
103 void value_task(const SocketInContext &socket)
104 {
105 if (all_socket_values_.contains(socket)) {
106 /* Task is done already. */
107 return;
108 }
109 const bNode &node = socket->owner_node();
110 if (node.is_undefined() && !node.is_custom_group()) {
111 all_socket_values_.add_new(socket, InferenceValue::Unknown());
112 return;
113 }
114 const CPPType *base_type = socket->typeinfo->base_cpp_type;
115 if (!base_type) {
116 /* The socket type is unknown for some reason (maybe a socket type from the future?). */
117 all_socket_values_.add_new(socket, InferenceValue::Unknown());
118 return;
119 }
120 if (socket->is_input()) {
121 this->value_task__input(socket);
122 }
123 else {
124 this->value_task__output(socket);
125 }
126 }
127
128 void value_task__output(const SocketInContext &socket)
129 {
130 const NodeInContext node = socket.owner_node();
131 if (node->is_muted()) {
132 this->value_task__output__muted_node(socket);
133 return;
134 }
135 switch (node->type_legacy) {
136 case NODE_GROUP:
137 case NODE_CUSTOM_GROUP: {
138 this->value_task__output__group_node(socket);
139 return;
140 }
141 case NODE_GROUP_INPUT: {
142 this->value_task__output__group_input_node(socket);
143 return;
144 }
145 case NODE_REROUTE: {
146 this->value_task__output__reroute_node(socket);
147 return;
148 }
149 case GEO_NODE_SWITCH: {
150 this->value_task__output__generic_switch(
152 return;
153 }
155 this->value_task__output__generic_switch(
157 return;
158 }
160 if (socket->index() == 0) {
161 this->value_task__output__generic_switch(
163 }
164 else {
165 this->value_task__output__menu_switch_selection(socket);
166 }
167 return;
168 }
169 case SH_NODE_MIX: {
170 this->value_task__output__generic_switch(
172 return;
173 }
174 case SH_NODE_MIX_SHADER: {
175 this->value_task__output__generic_switch(
177 return;
178 }
179 case SH_NODE_MATH: {
180 this->value_task__output__float_math(socket);
181 return;
182 }
183 case SH_NODE_VECTOR_MATH: {
184 this->value_task__output__vector_math(socket);
185 return;
186 }
188 this->value_task__output__integer_math(socket);
189 return;
190 }
192 this->value_task__output__boolean_math(socket);
193 return;
194 }
195 case GEO_NODE_WARNING: {
196 this->value_task__output__warning(socket);
197 return;
198 }
199 default: {
200 if (node->is_type("NodeEnableOutput"_ustr)) {
201 this->value_task__output__enable_output(socket);
202 return;
203 }
204 if (node->is_type("NodeImplicitConversion"_ustr)) {
205 this->value_task__output__implicit_conversion_node(socket);
206 return;
207 }
208 if (node->typeinfo->build_multi_function) {
209 this->value_task__output__multi_function_node(socket);
210 return;
211 }
212 break;
213 }
214 }
215 /* If none of the above cases work, the socket value is set to null which means that it is
216 * unknown/dynamic. */
217 all_socket_values_.add_new(socket, InferenceValue::Unknown());
218 }
219
220 void value_task__output__group_node(const SocketInContext &socket)
221 {
222 const NodeInContext node = socket.owner_node();
223 const bNodeTree *group = reinterpret_cast<const bNodeTree *>(node->id);
224 if (!group || ID_MISSING(&group->id)) {
225 all_socket_values_.add_new(socket, InferenceValue::Unknown());
226 return;
227 }
228 group->ensure_topology_cache();
229 if (group->has_available_link_cycle()) {
230 all_socket_values_.add_new(socket, InferenceValue::Unknown());
231 return;
232 }
233 this->ensure_animation_data_processed(*group);
234 const bNode *group_output_node = group->group_output_node();
235 if (!group_output_node) {
236 /* Can't compute the value if the group does not have an output node. */
237 all_socket_values_.add_new(socket, InferenceValue::Unknown());
238 return;
239 }
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);
247 return;
248 }
249 all_socket_values_.add_new(socket, *value);
250 }
251
252 void value_task__output__group_input_node(const SocketInContext &socket)
253 {
254 const bool is_root_context = socket.context == nullptr;
255 if (is_root_context) {
256 InferenceValue value = InferenceValue::Unknown();
257 if (group_input_value_fn_) {
258 value = group_input_value_fn_(socket->index());
259 }
260 all_socket_values_.add_new(socket, value);
261 return;
262 }
263
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);
271 return;
272 }
273 all_socket_values_.add_new(socket, *value);
274 }
275
276 void value_task__output__reroute_node(const SocketInContext &socket)
277 {
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);
282 return;
283 }
284 all_socket_values_.add_new(socket, *value);
285 }
286
287 void value_task__output__implicit_conversion_node(const SocketInContext &socket)
288 {
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);
293 return;
294 }
295 all_socket_values_.add_new(socket, *value);
296 }
297
298 void value_task__output__menu_switch_selection(const SocketInContext &socket)
299 {
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);
305 return;
306 }
307 const std::optional<MenuValue> menu_value = value->get_if_primitive<MenuValue>();
308 if (!menu_value.has_value()) {
309 all_socket_values_.add_new(socket, InferenceValue::Unknown());
310 return;
311 }
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));
316 }
317
318 void value_task__output__float_math(const SocketInContext &socket)
319 {
320 const NodeInContext node = socket.owner_node();
321 const NodeMathOperation operation = NodeMathOperation(node->custom1);
322 switch (operation) {
323 case NODE_MATH_MULTIPLY: {
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);
330 }
331 if (a.has_value() && b.has_value()) {
332 return this->make_primitive_inference_value(*a * *b);
333 }
334 return std::nullopt;
335 });
336 break;
337 }
338 default: {
339 this->value_task__output__multi_function_node(socket);
340 break;
341 }
342 }
343 }
344
345 void value_task__output__vector_math(const SocketInContext &socket)
346 {
347 const NodeInContext node = socket.owner_node();
348 const NodeVectorMathOperation operation = NodeVectorMathOperation(node->custom1);
349 switch (operation) {
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>();
355 if (a == float3(0.0f) || b == float3(0.0f)) {
356 return this->make_primitive_inference_value(float3(0.0f));
357 }
358 if (a.has_value() && b.has_value()) {
359 return this->make_primitive_inference_value(float3(*a * *b));
360 }
361 return std::nullopt;
362 });
363 break;
364 }
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>();
370 if (a == float3(0.0f) || scale == 0.0f) {
371 return this->make_primitive_inference_value(float3(0.0f));
372 }
373 if (a.has_value() && scale.has_value()) {
374 return this->make_primitive_inference_value(float3(*a * *scale));
375 }
376 return std::nullopt;
377 });
378 break;
379 }
380 default: {
381 this->value_task__output__multi_function_node(socket);
382 break;
383 }
384 }
385 }
386
387 void value_task__output__integer_math(const SocketInContext &socket)
388 {
389 const NodeInContext node = socket.owner_node();
390 const NodeIntegerMathOperation operation = NodeIntegerMathOperation(node->custom1);
391 switch (operation) {
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);
399 }
400 if (a.has_value() && b.has_value()) {
401 return this->make_primitive_inference_value(*a * *b);
402 }
403 return std::nullopt;
404 });
405 break;
406 }
407 default: {
408 this->value_task__output__multi_function_node(socket);
409 break;
410 }
411 }
412 }
413
414 void value_task__output__boolean_math(const SocketInContext &socket)
415 {
416 const NodeInContext node = socket.owner_node();
417 const NodeBooleanMathOperation operation = NodeBooleanMathOperation(node->custom1);
418
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);
426 if (result.has_value()) {
427 return this->make_primitive_inference_value(*result);
428 }
429 return std::nullopt;
430 });
431 };
432 switch (operation) {
434 handle_binary_op(
435 [](const std::optional<bool> &a, const std::optional<bool> &b) -> std::optional<bool> {
436 if (a == false || b == false) {
437 return false;
438 }
439 if (a.has_value() && b.has_value()) {
440 return *a && *b;
441 }
442 return std::nullopt;
443 });
444 break;
445 }
447 handle_binary_op(
448 [](const std::optional<bool> &a, const std::optional<bool> &b) -> std::optional<bool> {
449 if (a == true || b == true) {
450 return true;
451 }
452 if (a.has_value() && b.has_value()) {
453 return *a || *b;
454 }
455 return std::nullopt;
456 });
457 break;
458 }
460 handle_binary_op(
461 [](const std::optional<bool> &a, const std::optional<bool> &b) -> std::optional<bool> {
462 if (a == false || b == false) {
463 return true;
464 }
465 if (a.has_value() && b.has_value()) {
466 return !(*a && *b);
467 }
468 return std::nullopt;
469 });
470 break;
471 }
473 handle_binary_op(
474 [](const std::optional<bool> &a, const std::optional<bool> &b) -> std::optional<bool> {
475 if (a == true || b == true) {
476 return false;
477 }
478 if (a.has_value() && b.has_value()) {
479 return !(*a || *b);
480 }
481 return std::nullopt;
482 });
483 break;
484 }
486 handle_binary_op(
487 [](const std::optional<bool> &a, const std::optional<bool> &b) -> std::optional<bool> {
488 if (a == false || b == true) {
489 return true;
490 }
491 if (a.has_value() && b.has_value()) {
492 return !*a || *b;
493 }
494 return std::nullopt;
495 });
496 break;
497 }
499 handle_binary_op(
500 [](const std::optional<bool> &a, const std::optional<bool> &b) -> std::optional<bool> {
501 if (a == false || b == true) {
502 return false;
503 }
504 if (a.has_value() && b.has_value()) {
505 return *a && !*b;
506 }
507 return std::nullopt;
508 });
509 break;
510 }
511 default: {
512 this->value_task__output__multi_function_node(socket);
513 break;
514 }
515 }
516 }
517
518 void value_task__output__warning(const SocketInContext &socket)
519 {
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);
525 return;
526 }
527 all_socket_values_.add_new(socket, *value);
528 }
529
530 void value_task__output__enable_output(const SocketInContext &socket)
531 {
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);
535
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);
540 return;
541 }
542 if (!keep_value->is_primitive_value()) {
543 all_socket_values_.add_new(socket, InferenceValue::Unknown());
544 return;
545 }
546 const bool keep = keep_value->get_primitive<bool>();
547 if (!keep) {
548 const CPPType &type = *socket->typeinfo->base_cpp_type;
549 all_socket_values_.add_new(socket, InferenceValue::from_primitive(type.default_value()));
550 return;
551 }
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);
555 return;
556 }
557 all_socket_values_.add_new(socket, *value);
558 }
559
564 void value_task__output__generic_switch(
565 const SocketInContext &socket,
566 const FunctionRef<bool(const SocketInContext &socket, InferenceValue condition)>
567 is_selected_socket)
568 {
569 const NodeInContext node = socket.owner_node();
570 BLI_assert(node->input_sockets().size() >= 1);
571 BLI_assert(node->output_sockets().size() >= 1);
572
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(
576 condition_socket);
577 if (!condition_value.has_value()) {
578 this->push_value_task(condition_socket);
579 return;
580 }
581 if (condition_value->is_unknown()) {
582 /* The condition value is not a simple static value, so the output is unknown. */
583 all_socket_values_.add_new(socket, InferenceValue::Unknown());
584 return;
585 }
586 Vector<const bNodeSocket *> selected_inputs;
587 for (const int input_i :
588 node->input_sockets().index_range().drop_front(condition_socket->index() + 1))
589 {
590 const SocketInContext input_socket = node.input_socket(input_i);
591 if (!input_socket->is_available()) {
592 continue;
593 }
594 if (input_socket->type == SOCK_CUSTOM && STREQ(input_socket->idname, "NodeSocketVirtual")) {
595 continue;
596 }
597 const bool is_selected = is_selected_socket(input_socket, *condition_value);
598 if (is_selected) {
599 selected_inputs.append(input_socket.socket);
600 }
601 }
602 if (selected_inputs.is_empty()) {
603 all_socket_values_.add_new(socket, InferenceValue::Unknown());
604 return;
605 }
606 if (selected_inputs.size() == 1) {
607 /* A single input is selected, so just pass through this value without regarding others. */
608 const SocketInContext selected_input{socket.context, selected_inputs[0]};
609 const std::optional<InferenceValue> input_value = all_socket_values_.lookup_try(
610 selected_input);
611 if (!input_value.has_value()) {
612 this->push_value_task(selected_input);
613 return;
614 }
615 all_socket_values_.add_new(socket, *input_value);
616 return;
617 }
618
619 /* Multiple inputs are selected. */
620 if (node->typeinfo->build_multi_function) {
621 /* Try to compute the output value from the multiple selected inputs. */
622 this->value_task__output__multi_function_node(socket);
623 return;
624 }
625 /* Can't compute the output value, so set it to be unknown. */
626 all_socket_values_.add_new(socket, InferenceValue::Unknown());
627 }
628
629 void value_task__output__generic_eval(
630 const SocketInContext &socket,
631 const FunctionRef<std::optional<InferenceValue>(Span<InferenceValue> inputs)> eval_fn)
632 {
633 const NodeInContext node = socket.owner_node();
634 const int inputs_num = node->input_sockets().size();
635
636 Array<InferenceValue, 16> input_values(inputs_num, InferenceValue::Unknown());
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()) {
641 continue;
642 }
643 const std::optional<InferenceValue> input_value = all_socket_values_.lookup_try(
644 input_socket);
645 if (!input_value.has_value()) {
646 next_unknown_input_index = input_i;
647 break;
648 }
649 input_values[input_i] = *input_value;
650 }
651 const std::optional<InferenceValue> output_value = eval_fn(input_values);
652 if (output_value.has_value()) {
653 /* Was able to compute the output value. */
654 all_socket_values_.add_new(socket, *output_value);
655 return;
656 }
657 if (!next_unknown_input_index.has_value()) {
658 /* The output is still unknown even though we know as much about the inputs as possible
659 * already. */
660 all_socket_values_.add_new(socket, InferenceValue::Unknown());
661 return;
662 }
663 /* Request the next input socket. */
664 const SocketInContext next_input = node.input_socket(*next_unknown_input_index);
665 this->push_value_task(next_input);
666 }
667
668 void value_task__output__multi_function_node(const SocketInContext &socket)
669 {
670 const NodeInContext node = socket.owner_node();
671 const int inputs_num = node->input_sockets().size();
672
673 /* Gather all input values are return early if any of them is not known. */
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(
678 input_socket);
679 if (!input_value.has_value()) {
680 this->push_value_task(input_socket);
681 return;
682 }
683 if (!input_value->is_primitive_value()) {
684 all_socket_values_.add_new(socket, InferenceValue::Unknown());
685 return;
686 }
687 input_values[input_i] = input_value->get_primitive_ptr();
688 }
689
690 /* Get the multi-function for the node. */
691 NodeMultiFunctionBuilder builder{*node.node, node->owner_tree()};
692 node->typeinfo->build_multi_function(builder);
693 const mf::MultiFunction &fn = builder.function();
694
695 /* We only evaluate the node for a single value here. */
696 const IndexMask mask(1);
697
698 /* Prepare parameters for the multi-function evaluation. */
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()) {
703 continue;
704 }
705 params.add_readonly_single_input(
706 GPointer(input_socket->typeinfo->base_cpp_type, input_values[input_i]));
707 }
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()) {
711 continue;
712 }
713 /* Allocate memory for the output value. */
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));
717 all_socket_values_.add_new(output_socket, InferenceValue::from_primitive(value));
718 }
719 mf::ContextBuilder context;
720 /* Actually evaluate the multi-function. The outputs will be written into the memory allocated
721 * earlier, which has been added to #all_socket_values_ already. */
722 fn.call(mask, params, context);
723 }
724
725 void value_task__output__muted_node(const SocketInContext &socket)
726 {
727 const NodeInContext node = socket.owner_node();
728
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};
733 break;
734 }
735 }
736 if (!input_socket) {
737 /* The output does not have an internal link to an input. */
738 all_socket_values_.add_new(socket, InferenceValue::Unknown());
739 return;
740 }
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);
744 return;
745 }
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);
749 }
750
751 void value_task__input(const SocketInContext &socket)
752 {
753 if (socket->is_multi_input()) {
754 /* Can't know the single value of a multi-input. */
755 all_socket_values_.add_new(socket, InferenceValue::Unknown());
756 return;
757 }
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()) {
762 continue;
763 }
764 if (link->fromnode->is_dangling_reroute()) {
765 continue;
766 }
767 source_link = link;
768 break;
769 }
770 if (!source_link) {
771 this->value_task__input__unlinked(socket);
772 return;
773 }
774 this->value_task__input__linked({socket.context, source_link->fromsock}, socket);
775 }
776
777 void value_task__input__unlinked(const SocketInContext &socket)
778 {
779 if (this->treat_socket_as_unknown(socket)) {
780 all_socket_values_.add_new(socket, InferenceValue::Unknown());
781 return;
782 }
783 if (animated_sockets_.contains(socket.socket)) {
784 /* The value of animated sockets is not known statically. */
785 all_socket_values_.add_new(socket, InferenceValue::Unknown());
786 return;
787 }
788 if (const SocketDeclaration *socket_decl = socket.socket->runtime->declaration) {
789 if (socket_decl->default_input_type != NODE_DEFAULT_INPUT_VALUE) {
790 /* Implicit fields inputs don't have a single static value. */
791 all_socket_values_.add_new(socket, InferenceValue::Unknown());
792 return;
793 }
794 }
795
796 void *value_buffer = scope_.allocate_owned(*socket->typeinfo->base_cpp_type);
797 socket->typeinfo->get_base_cpp_value(socket->default_value, value_buffer);
798 all_socket_values_.add_new(socket, InferenceValue::from_primitive(value_buffer));
799 }
800
801 void value_task__input__linked(const SocketInContext &from_socket,
802 const SocketInContext &to_socket)
803 {
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);
807 return;
808 }
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);
812 }
813
814 InferenceValue convert_type_if_necessary(const InferenceValue &src,
815 const bNodeSocket &from_socket,
816 const bNodeSocket &to_socket)
817 {
818 if (!src.is_primitive_value()) {
820 }
821 const CPPType *from_type = from_socket.typeinfo->base_cpp_type;
822 const CPPType *to_type = to_socket.typeinfo->base_cpp_type;
823 if (from_type == to_type) {
824 return src;
825 }
826 if (!to_type) {
828 }
829 const bke::DataTypeConversions &conversions = bke::get_implicit_type_conversions();
830 if (!conversions.is_convertible(*from_type, *to_type)) {
832 }
833 void *dst = scope_.allocate_owned(*to_type);
834 conversions.convert_to_uninitialized(*from_type, *to_type, src.get_primitive_ptr(), dst);
836 }
837
838 bool treat_socket_as_unknown(const SocketInContext &socket) const
839 {
840 if (!top_level_ignored_inputs_.has_value()) {
841 return false;
842 }
843 if (socket.context) {
844 return false;
845 }
846 if (socket->is_output()) {
847 return false;
848 }
849 return (*top_level_ignored_inputs_)[socket->index_in_all_inputs()];
850 }
851
852 void ensure_animation_data_processed(const bNodeTree &tree)
853 {
854 if (!trees_with_handled_animation_data_.add(&tree)) {
855 return;
856 }
857 if (!tree.adt) {
858 return;
859 }
860
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) {
864 std::cmatch match;
865 if (!std::regex_match(rna_path, match, pattern)) {
866 return;
867 }
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);
871 };
872
873 /* Gather all inputs controlled by fcurves. */
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());
878 });
879 }
880 /* Gather all inputs controlled by drivers. */
881 for (const FCurve &driver : tree.adt->drivers) {
882 handle_rna_path(driver.rna_path().c_str());
883 }
884
885 /* Actually find the #bNodeSocket for each controlled input. */
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()) {
892 /* This can happen when the animation data is not immediately updated after a socket is
893 * removed. */
894 continue;
895 }
896 const bNodeSocket &socket = *input_sockets[socket_index];
897 animated_sockets_.add(&socket);
898 }
899 }
900 }
901 }
902
903 void push_value_task(const SocketInContext &socket)
904 {
905 value_tasks_.push(socket);
906 }
907
908 template<typename T> InferenceValue make_primitive_inference_value(const T &value)
909 {
910 static_assert(is_same_any_v<std::decay_t<T>, bool, float, int, float3>);
911 return InferenceValue::from_primitive(&scope_.construct<T>(value));
912 }
913
914 static const bNodeSocket *get_first_available_bsocket(const Span<const bNodeSocket *> sockets)
915 {
916 for (const bNodeSocket *socket : sockets) {
917 if (socket->is_available()) {
918 return socket;
919 }
920 }
921 return nullptr;
922 }
923};
924
926 const bNodeTree &tree,
927 ResourceScope &scope,
928 bke::ComputeContextCache &compute_context_cache,
929 const FunctionRef<InferenceValue(int group_input_i)> group_input_value_fn,
930 const std::optional<Span<bool>> top_level_ignored_inputs)
931 : impl_(scope.construct<SocketValueInferencerImpl>(
932 tree, scope, compute_context_cache, group_input_value_fn, top_level_ignored_inputs))
933{
934}
935
937{
938 return impl_.get_socket_value(socket);
939}
940
942
944{
945 if (!condition.is_primitive_value()) {
946 return true;
947 }
948 const bool is_true = condition.get_primitive<bool>();
949 const int selected_index = is_true ? 2 : 1;
950 return socket->index() == selected_index;
951}
952
955{
956 if (!condition.is_primitive_value()) {
957 return true;
958 }
959 const int index = condition.get_primitive<int>();
960 return socket->index() == index + 1;
961}
962
965{
966 if (!condition.is_primitive_value()) {
967 return true;
968 }
969 const NodeMenuSwitch &storage = *static_cast<const NodeMenuSwitch *>(
970 socket->owner_node().storage);
971 const int menu_value = condition.get_primitive<int>();
972 const NodeEnumItem &item = storage.enum_definition.items_array[socket->index() - 1];
973 return menu_value == item.identifier;
974}
975
977{
978 if (!condition.is_primitive_value()) {
979 return true;
980 }
981 const NodeShaderMix &storage = *static_cast<const NodeShaderMix *>(socket.owner_node()->storage);
982 if (storage.data_type == SOCK_RGBA && storage.blend_type != MA_RAMP_BLEND) {
983 return true;
984 }
985
986 const bool clamp_factor = storage.clamp_factor != 0;
987 bool only_a = false;
988 bool only_b = false;
989 if (storage.data_type == SOCK_VECTOR && storage.factor_mode == NODE_MIX_MODE_NON_UNIFORM) {
990 const float3 mix_factor = condition.get_primitive<float3>();
991 if (clamp_factor) {
992 only_a = mix_factor.x <= 0.0f && mix_factor.y <= 0.0f && mix_factor.z <= 0.0f;
993 only_b = mix_factor.x >= 1.0f && mix_factor.y >= 1.0f && mix_factor.z >= 1.0f;
994 }
995 else {
996 only_a = float3{0.0f, 0.0f, 0.0f} == mix_factor;
997 only_b = float3{1.0f, 1.0f, 1.0f} == mix_factor;
998 }
999 }
1000 else {
1001 const float mix_factor = condition.get_primitive<float>();
1002 if (clamp_factor) {
1003 only_a = mix_factor <= 0.0f;
1004 only_b = mix_factor >= 1.0f;
1005 }
1006 else {
1007 only_a = mix_factor == 0.0f;
1008 only_b = mix_factor == 1.0f;
1009 }
1010 }
1011 if (only_a) {
1012 if (STREQ(socket->name, "B")) {
1013 return false;
1014 }
1015 }
1016 if (only_b) {
1017 if (STREQ(socket->name, "A")) {
1018 return false;
1019 }
1020 }
1021 return true;
1022}
1023
1026{
1027 if (!condition.is_primitive_value()) {
1028 return true;
1029 }
1030 const float mix_factor = condition.get_primitive<float>();
1031 if (mix_factor == 0.0f) {
1032 if (STREQ(socket->identifier, "Shader_001")) {
1033 return false;
1034 }
1035 }
1036 else if (mix_factor == 1.0f) {
1037 if (STREQ(socket->identifier, "Shader")) {
1038 return false;
1039 }
1040 }
1041 return true;
1042}
1043
1044} // namespace switch_node_inference_utils
1045
1046} // namespace blender::nodes
Functions and classes to work with Actions.
Functionality to iterate an Action in various ways.
#define NODE_REROUTE
Definition BKE_node.hh:867
#define NODE_CUSTOM_GROUP
Definition BKE_node.hh:870
#define NODE_GROUP
Definition BKE_node.hh:865
#define NODE_GROUP_INPUT
Definition BKE_node.hh:868
#define SH_NODE_MIX_SHADER
#define GEO_NODE_MENU_SWITCH
#define FN_NODE_INTEGER_MATH
#define SH_NODE_VECTOR_MATH
#define SH_NODE_MATH
#define FN_NODE_BOOLEAN_MATH
#define GEO_NODE_SWITCH
#define SH_NODE_MIX
#define GEO_NODE_WARNING
#define GEO_NODE_INDEX_SWITCH
#define ID_MISSING(_id)
Definition DNA_ID.h:695
#define BLI_assert(a)
#define STREQ(a, b)
constexpr int64_t size() const
Definition BLI_span.hh:256
GPointer()=default
constexpr IndexRange()=default
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
bool contains(const Key &key) const
Definition BLI_map.hh:353
static InferenceValue from_primitive(const void *value)
InferenceValue get_socket_value(const SocketInContext &socket)
SocketValueInferencerImpl(const bNodeTree &tree, ResourceScope &scope, bke::ComputeContextCache &compute_context_cache, const FunctionRef< InferenceValue(int group_input_i)> group_input_value_fn, const std::optional< Span< bool > > top_level_ignored_inputs)
SocketValueInferencer(const bNodeTree &tree, ResourceScope &scope, bke::ComputeContextCache &compute_context_cache, FunctionRef< InferenceValue(int group_input_i)> group_input_value_fn=nullptr, std::optional< Span< bool > > top_level_ignored_inputs=std::nullopt)
InferenceValue get_socket_value(const SocketInContext &socket)
#define storage(slot, qualifiers)
#define condition(cond)
float3x3 scale(float3x3 mat, float2 scale)
uint to_type(bool)
#define T
void foreach_fcurve_in_action_slot(Action &action, slot_handle_t handle, FunctionRef< void(FCurve &fcurve)> callback)
const DataTypeConversions & get_implicit_type_conversions()
int context(const bContext *C, const char *member, bContextDataResult *result)
bool is_socket_selected__shader_mix_node(const SocketInContext &socket, const InferenceValue &condition)
bool is_socket_selected__mix_node(const SocketInContext &socket, const InferenceValue &condition)
bool is_socket_selected__menu_switch(const SocketInContext &socket, const InferenceValue &condition)
bool is_socket_selected__index_switch(const SocketInContext &socket, const InferenceValue &condition)
bool is_socket_selected__switch(const SocketInContext &socket, const InferenceValue &condition)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
constexpr bool is_same_any_v
@ NODE_INTEGER_MATH_MULTIPLY
@ NODE_BOOLEAN_MATH_NIMPLY
@ NODE_BOOLEAN_MATH_NAND
@ NODE_BOOLEAN_MATH_AND
@ NODE_BOOLEAN_MATH_IMPLY
@ NODE_BOOLEAN_MATH_OR
@ NODE_BOOLEAN_MATH_NOR
@ NODE_MIX_MODE_NON_UNIFORM
@ NODE_VECTOR_MATH_SCALE
@ NODE_VECTOR_MATH_MULTIPLY
VecBase< float, 3 > float3
void mask(PageMask &srt, TileMaps &tilemaps, const uint3 global_id, const uint local_tile_index)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
bke::bNodeSocketType * typeinfo
const CPPType * base_cpp_type
Definition BKE_node.hh:210