Blender V5.3
eval_log.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "NOD_eval_log.hh"
14
15#include "BLI_listbase.hh"
16#include "BLI_stack.hh"
17#include "BLI_string.hh"
18#include "BLI_string_ref.hh"
19#include "BLI_string_utf8.hh"
20
21#include "IMB_imbuf.hh"
22
26#include "BKE_curves.hh"
28#include "BKE_grease_pencil.hh"
29#include "BKE_lib_id.hh"
30#include "BKE_lib_query.hh"
32#include "BKE_node_runtime.hh"
34#include "BKE_report.hh"
35#include "BKE_scene_runtime.hh"
37#include "BKE_volume.hh"
38#include "BKE_volume_grid.hh"
39#include "BKE_volume_openvdb.hh"
40
42#include "DNA_modifier_types.h"
43#include "DNA_space_types.h"
44
45#include "ED_geometry.hh"
46#include "ED_node.hh"
47#include "ED_viewer_path.hh"
48
49#include "MOD_nodes.hh"
50
51#include "UI_resources.hh"
52
54
56
57using bke::bNodeTreeZone;
58using bke::bNodeTreeZones;
59using fn::FieldInput;
60using fn::FieldInputs;
61
66
68{
69 /* Avoid logging the entirety of long strings, to avoid unnecessary memory usage. */
70 if (string.size() <= 100) {
71 this->truncated = false;
72 this->value = allocator.copy_string(string);
73 return;
74 }
75 this->truncated = true;
76 const char *end = BLI_str_find_prev_char_utf8(string.data() + 100, string.data());
77 this->value = allocator.copy_string(StringRef(string.data(), end));
78}
79
80FieldInfoLog::FieldInfoLog(const GField &field) : type(field.cpp_type())
81{
82 const fn::FieldInputsPtr &field_inputs_ptr = field.field_inputs();
83
84 /* Put the deduplicated field inputs into a vector so that they can be sorted below. */
86 if (field_inputs_ptr) {
87 field_inputs.extend(field_inputs_ptr->inputs.begin(), field_inputs_ptr->inputs.end());
88 }
89
90 this->input_tooltips.reserve(field_inputs.size());
91 for (const FieldInput &field_input : field_inputs) {
92 input_tooltips.append(field_input.socket_inspection_name());
93 }
94 std::ranges::sort(input_tooltips, [](const std::string &a, const std::string &b) {
95 return BLI_strcasecmp_natural(a.c_str(), b.c_str()) < 0;
96 });
97}
98
100{
101 this->name = geometry_set.name();
102
103 static std::array all_component_types = {bke::GeometryComponent::Type::Curve,
109
110 /* Keep track handled attribute names to make sure that we do not return the same name twice.
111 * Currently #GeometrySet::attribute_foreach does not do that. Note that this will merge
112 * attributes with the same name but different domains or data types on separate components. */
113 Set<StringRef> names;
114
115 geometry_set.attribute_foreach(
116 all_component_types,
117 true,
118 [&](const StringRef name,
119 const bke::AttributeMetaData &meta_data,
120 const bke::GeometryComponent & /*component*/) {
122 this->attributes.append({name, meta_data.domain, meta_data.data_type});
123 }
124 });
125
126 for (const bke::GeometryComponent *component : geometry_set.get_components()) {
127 this->component_types.append(component->type());
128 switch (component->type()) {
130 const auto &mesh_component = *static_cast<const bke::MeshComponent *>(component);
131 MeshInfo &info = this->mesh_info.emplace();
132 info.verts_num = mesh_component.attribute_domain_size(bke::AttrDomain::Point);
133 info.edges_num = mesh_component.attribute_domain_size(bke::AttrDomain::Edge);
134 info.faces_num = mesh_component.attribute_domain_size(bke::AttrDomain::Face);
135 break;
136 }
138 const auto &curve_component = *static_cast<const bke::CurveComponent *>(component);
139 CurveInfo &info = this->curve_info.emplace();
140 info.points_num = curve_component.attribute_domain_size(bke::AttrDomain::Point);
141 info.splines_num = curve_component.attribute_domain_size(bke::AttrDomain::Curve);
142 break;
143 }
145 const auto &pointcloud_component = *static_cast<const bke::PointCloudComponent *>(
146 component);
147 PointCloudInfo &info = this->pointcloud_info.emplace();
148 info.points_num = pointcloud_component.attribute_domain_size(bke::AttrDomain::Point);
149 break;
150 }
152 const auto &instances_component = *static_cast<const bke::InstancesComponent *>(component);
153 InstancesInfo &info = this->instances_info.emplace();
154 info.instances_num = instances_component.attribute_domain_size(bke::AttrDomain::Instance);
155 break;
156 }
158 const auto &edit_component = *static_cast<const bke::GeometryComponentEditData *>(
159 component);
160 if (!this->edit_data_info) {
161 this->edit_data_info.emplace(EditDataInfo());
162 }
163 EditDataInfo &info = *this->edit_data_info;
164 if (const bke::CurvesEditHints *curve_edit_hints = edit_component.curves_edit_hints_.get())
165 {
166 info.has_deform_matrices = curve_edit_hints->deform_mats.has_value();
167 info.has_deformed_positions = curve_edit_hints->positions().has_value();
168 }
169 if (const bke::GizmoEditHints *gizmo_edit_hints = edit_component.gizmo_edit_hints_.get()) {
170 info.gizmo_transforms_num = gizmo_edit_hints->gizmo_transforms.size();
171 }
172 break;
173 }
175#ifdef WITH_OPENVDB
176 const auto &volume_component = *static_cast<const bke::VolumeComponent *>(component);
177 if (const Volume *volume = volume_component.get()) {
178 VolumeInfo &info = this->volume_info.emplace();
179 info.grids.resize(BKE_volume_num_grids(volume));
180 for (const int i : IndexRange(BKE_volume_num_grids(volume))) {
181 const bke::VolumeGridData *grid = BKE_volume_grid_get(volume, i);
182 info.grids[i] = {grid->name(), bke::volume_grid::get_type(*grid)};
183 }
184 }
185#endif /* WITH_OPENVDB */
186 break;
187 }
189 const auto &grease_pencil_component = *static_cast<const bke::GreasePencilComponent *>(
190 component);
191 if (const GreasePencil *grease_pencil = grease_pencil_component.get()) {
193 info.layers_num = grease_pencil->layers().size();
194 Set<StringRef> unique_layer_names;
195 for (const bke::greasepencil::Layer *layer : grease_pencil->layers()) {
196 const StringRefNull layer_name = layer->name();
197 if (unique_layer_names.add(layer_name)) {
198 info.layer_names.append(layer_name);
199 }
200 }
201 }
202 break;
203 }
204 }
205 }
206}
207
208#ifdef WITH_OPENVDB
209struct GridIsEmptyOp {
210 const openvdb::GridBase &base_grid;
211 bool result = false;
212
213 template<typename GridType> bool operator()()
214 {
215 result = static_cast<const GridType &>(base_grid).empty();
216 return true;
217 }
218};
219#endif /* WITH_OPENVDB */
220
221GridInfoLog::GridInfoLog(const bke::GVolumeGrid &grid)
222{
223#ifdef WITH_OPENVDB
224 bke::VolumeTreeAccessToken token;
225 const openvdb::GridBase &vdb_grid = grid->grid(token);
226 const VolumeGridType grid_type = bke::volume_grid::get_type(vdb_grid);
227
228 GridIsEmptyOp is_empty_op{vdb_grid};
229 if (BKE_volume_grid_type_operation(grid_type, is_empty_op)) {
230 this->is_empty = is_empty_op.result;
231 }
232 else {
233 this->is_empty = true;
234 }
235#else
236 UNUSED_VARS(grid);
237 this->is_empty = true;
238#endif
239}
240
242
245 const std::optional<ClosureSourceLocation> &source_location,
246 std::shared_ptr<ClosureEvalLog> eval_log)
247 : inputs(std::move(inputs)), outputs(std::move(outputs)), eval_log(std::move(eval_log))
248{
249 if (source_location) {
250 const bNodeTree *tree_eval = source_location->tree;
251 const bNodeTree *tree_orig = reinterpret_cast<const bNodeTree *>(
252 DEG_get_original_id(&tree_eval->id));
253 this->source = Source{tree_orig->id.session_uid,
254 source_location->closure_output_node_id,
255 source_location->compute_context_hash};
256 }
257}
258
260{
261 if (!list) {
262 this->size = 0;
263 return;
264 }
265 this->size = list->size();
266}
267
286
287/* Avoid generating these in every translation unit. */
290
292
294{
295 for (const NodeTreeLogger::NodeImagePreview &preview : this->node_image_previews) {
296 IMB_freeImBuf(preview.image_preview);
297 }
298}
299
300NodeLog::NodeLog() = default;
301
306
308 : root_log_(root_log), tree_loggers_(std::move(tree_loggers))
309{
310 for (NodeTreeLogger *tree_logger : tree_loggers_) {
311 for (const ComputeContextHash &hash : tree_logger->children_hashes) {
312 children_hashes_.add(hash);
313 }
314 }
315}
316
317NodeTreeLog::~NodeTreeLog() = default;
318
319void NodeTreeLogger::log_value(const bNode &node, const bNodeSocket &socket, const GPointer value)
320{
321 const CPPType &type = *value.type();
322
323 auto store_logged_value = [&](destruct_ptr<ValueLog> value_log) {
324 auto &socket_values = socket.in_out == SOCK_IN ? this->input_socket_values :
326 socket_values.append(*this->allocator,
327 {node.identifier, socket.index(), std::move(value_log)});
328 };
329
330 auto log_generic_value = [&](const CPPType &type, const void *value) {
331 void *buffer = this->allocator->allocate(type);
332 type.copy_construct(value, buffer);
333 store_logged_value(this->allocator->construct<GenericValueLog>(GMutablePointer{type, buffer}));
334 };
335
336 if (type.is<bke::SocketValueVariant>()) {
337 bke::SocketValueVariant value_variant = *value.get<bke::SocketValueVariant>();
338 if (value_variant.get().is_type<bke::GeometrySet>()) {
339 const bke::GeometrySet &geometry = *value_variant.get_if<bke::GeometrySet>();
340 store_logged_value(this->allocator->construct<GeometryInfoLog>(geometry));
341 }
342 else if (value_variant.is_context_dependent_field()) {
343 const GField field = value_variant.extract<GField>();
344 store_logged_value(this->allocator->construct<FieldInfoLog>(field));
345 }
346#ifdef WITH_OPENVDB
347 else if (value_variant.is_volume_grid()) {
348 const bke::GVolumeGrid grid = value_variant.extract<bke::GVolumeGrid>();
349 store_logged_value(this->allocator->construct<GridInfoLog>(grid));
350 }
351#endif
352 else if (value_variant.is_list()) {
353 const auto list = value_variant.extract<GListPtr>();
354 store_logged_value(this->allocator->construct<ListInfoLog>(list));
355 }
356 else if (value_variant.get().is_type<BundlePtr>()) {
358 if (const BundlePtr bundle = value_variant.extract<BundlePtr>()) {
359 for (const auto &item : bundle->items()) {
360 if (const BundleItemSocketValue *socket_value = std::get_if<BundleItemSocketValue>(
361 &item.value.value))
362 {
363 items.append({item.key.ustr(), {socket_value->type}});
364 }
365 if (const BundleItemInternalValue *internal_value = std::get_if<BundleItemInternalValue>(
366 &item.value.value))
367 {
368 items.append({item.key.ustr(), {internal_value->value->type_name()}});
369 }
370 }
371 }
372 store_logged_value(this->allocator->construct<BundleValueLog>(std::move(items)));
373 }
374 else if (value_variant.get().is_type<ClosurePtr>()) {
377 std::optional<ClosureSourceLocation> source_location;
378 std::shared_ptr<ClosureEvalLog> eval_log;
379 if (const ClosurePtr closure = value_variant.extract<ClosurePtr>()) {
380 const ClosureSignature &signature = closure->signature();
381 for (const ClosureSignature::Item &item : signature.inputs) {
382 inputs.append({item.key, item.type});
383 }
384 for (const ClosureSignature::Item &item : signature.outputs) {
385 outputs.append({item.key, item.type});
386 }
387 source_location = closure->source_location();
388 eval_log = closure->eval_log_ptr();
389 }
390 store_logged_value(this->allocator->construct<ClosureValueLog>(
391 std::move(inputs), std::move(outputs), source_location, eval_log));
392 }
393 else {
394 const GPointer value = value_variant.get();
395 if (value.type()->is<std::string>()) {
396 const std::string &string = *value.get<std::string>();
397 store_logged_value(this->allocator->construct<StringLog>(string, *this->allocator));
398 }
399 else {
400 log_generic_value(*value.type(), value.get());
401 }
402 }
403 }
404 else {
405 if (type.is<std::string>()) {
406 const std::string &string = *value.get<std::string>();
407 store_logged_value(this->allocator->construct<StringLog>(string, *this->allocator));
408 }
409 else {
410 log_generic_value(type, value.get());
411 }
412 }
413}
414
416{
417 main_geometry_cache_mutex_.ensure([&]() {
418 for (const Item &item : this->items) {
419#ifdef WITH_OPENVDB
420 if (item.value.is_volume_grid()) {
421 const bke::GVolumeGrid grid = *item.value.get_if<bke::GVolumeGrid>();
422 Volume *volume = BKE_id_new_nomain<Volume>(nullptr);
423 grid->add_user();
424 BKE_volume_grid_add(volume, grid.get());
425 main_geometry_cache_ = bke::GeometrySet::from_volume(volume);
426 return;
427 }
428#endif
429 if (item.value.is_single() && item.value.get().is_type<bke::GeometrySet>()) {
430 main_geometry_cache_ = *item.value.get().get<bke::GeometrySet>();
431 return;
432 }
433 }
434 });
435 return main_geometry_cache_ ? &*main_geometry_cache_ : nullptr;
436}
437
439{
440 if (reduced_node_warnings_) {
441 return;
442 }
443 if (!nmd.node_group || ID_MISSING(nmd.node_group)) {
444 reduced_node_warnings_ = true;
445 return;
446 }
449 nullptr,
450 &nmd.node_group->id,
451 [&](LibraryIDLinkCallbackData *cb_data) {
452 if (ID *id = *cb_data->id_pointer) {
453 if (GS(id->name) == ID_NT) {
454 const bNodeTree *tree = reinterpret_cast<const bNodeTree *>(id);
455 map.add(id->session_uid, tree);
456 }
457 }
458 return IDWALK_RET_NOP;
459 },
460 nullptr,
462 this->ensure_node_warnings(map);
463}
464
466{
467 if (reduced_node_warnings_) {
468 return;
469 }
471 FOREACH_NODETREE_BEGIN (const_cast<Main *>(&bmain), tree, id) {
472 map.add_new(tree->id.session_uid, tree);
473 }
475 this->ensure_node_warnings(map);
476}
477
479 const Map<uint32_t, const bNodeTree *> &orig_tree_by_session_uid)
480{
481 if (reduced_node_warnings_) {
482 return;
483 }
484 if (tree_loggers_.is_empty()) {
485 return;
486 }
487 const std::optional<uint32_t> tree_uid = tree_loggers_[0]->tree_orig_session_uid;
488 const bNodeTree *tree = tree_uid ? orig_tree_by_session_uid.lookup_default(*tree_uid, nullptr) :
489 nullptr;
490
491 for (NodeTreeLogger *tree_logger : tree_loggers_) {
492 for (const NodeTreeLogger::WarningWithNode &warning : tree_logger->node_warnings) {
494 if (tree) {
495 if (const bNode *node = tree->node_by_id(warning.node_id)) {
496 propagation = node->warning_propagation;
497 }
498 }
499 this->lookup_or_add_node_log(warning.node_id).warnings.add(warning.warning);
500 if (warning_is_propagated(propagation, warning.warning.type)) {
501 this->all_warnings.add(warning.warning);
502 }
503 }
504 }
505 for (const ComputeContextHash &child_hash : children_hashes_) {
506 NodeTreeLog &child_log = root_log_->get_tree_log(child_hash);
507 if (child_log.tree_loggers_.is_empty()) {
508 continue;
509 }
510 const NodeTreeLogger &first_child_logger = *child_log.tree_loggers_[0];
512 const std::optional<int32_t> &caller_node_id = first_child_logger.parent_node_id;
513 if (tree && caller_node_id) {
514 if (const bNode *caller_node = tree->node_by_id(*caller_node_id)) {
515 propagation = caller_node->warning_propagation;
516 }
517 }
518 child_log.ensure_node_warnings(orig_tree_by_session_uid);
519 if (caller_node_id.has_value()) {
520 this->lookup_or_add_node_log(*caller_node_id).warnings.add_multiple(child_log.all_warnings);
521 }
522 for (const NodeWarning &warning : child_log.all_warnings) {
523 if (warning_is_propagated(propagation, warning.type)) {
524 this->all_warnings.add(warning);
525 continue;
526 }
527 }
528 }
529 reduced_node_warnings_ = true;
530}
531
533{
534 if (reduced_execution_times_) {
535 return;
536 }
537 for (NodeTreeLogger *tree_logger : tree_loggers_) {
538 for (const NodeTreeLogger::NodeExecutionTime &timings : tree_logger->node_execution_times) {
539 const std::chrono::nanoseconds duration = timings.end - timings.start;
540 this->lookup_or_add_node_log(timings.node_id).execution_time += duration;
541 }
542 this->execution_time += tree_logger->execution_time;
543 }
544 reduced_execution_times_ = true;
545}
546
548{
549 if (reduced_socket_values_) {
550 return;
551 }
552 for (NodeTreeLogger *tree_logger : tree_loggers_) {
553 for (const NodeTreeLogger::SocketValueLog &value_log_data : tree_logger->input_socket_values) {
554 this->lookup_or_add_node_log(value_log_data.node_id)
555 .input_values_.add(value_log_data.socket_index, value_log_data.value.get());
556 }
557 for (const NodeTreeLogger::SocketValueLog &value_log_data : tree_logger->output_socket_values)
558 {
559 this->lookup_or_add_node_log(value_log_data.node_id)
560 .output_values_.add(value_log_data.socket_index, value_log_data.value.get());
561 }
562 }
563 reduced_socket_values_ = true;
564}
565
567{
568 if (reduced_viewer_node_logs_) {
569 return;
570 }
571 for (NodeTreeLogger *tree_logger : tree_loggers_) {
572 for (const NodeTreeLogger::ViewerNodeLogWithNode &viewer_log : tree_logger->viewer_node_logs) {
573 this->viewer_node_logs.add(viewer_log.node_id, viewer_log.viewer_log.get());
574 }
575 }
576 reduced_viewer_node_logs_ = true;
577}
578
580{
581 if (reduced_existing_attributes_) {
582 return;
583 }
584 this->ensure_socket_values();
585
586 auto handle_value_log = [&](const ValueLog &value_log) {
587 const GeometryInfoLog *geo_log = dynamic_cast<const GeometryInfoLog *>(&value_log);
588 if (geo_log == nullptr) {
589 return;
590 }
591 for (const GeometryAttributeInfo &attribute : geo_log->attributes) {
592 this->existing_attributes.append(&attribute);
593 }
594 };
595
596 for (const destruct_ptr<NodeLog> &node_log : this->nodes.values()) {
597 for (const ValueLog *value_log : node_log->input_values_.values()) {
598 handle_value_log(*value_log);
599 }
600 for (const ValueLog *value_log : node_log->output_values_.values()) {
601 handle_value_log(*value_log);
602 }
603 }
604 reduced_existing_attributes_ = true;
605}
606
608{
609 if (reduced_used_named_attributes_) {
610 return;
611 }
612
613 auto add_attribute = [&](const int32_t node_id,
614 const StringRefNull attribute_name,
615 const NamedAttributeUsage &usage) {
616 this->lookup_or_add_node_log(node_id).used_named_attributes.lookup_or_add(attribute_name,
617 usage) |= usage;
618 this->used_named_attributes.lookup_or_add_as(attribute_name, usage) |= usage;
619 };
620
621 for (NodeTreeLogger *tree_logger : tree_loggers_) {
622 for (const NodeTreeLogger::AttributeUsageWithNode &item : tree_logger->used_named_attributes) {
623 add_attribute(item.node_id, item.attribute_name, item.usage);
624 }
625 }
626 for (const ComputeContextHash &child_hash : children_hashes_) {
627 NodeTreeLog &child_log = root_log_->get_tree_log(child_hash);
628 if (child_log.tree_loggers_.is_empty()) {
629 continue;
630 }
632 if (const std::optional<int32_t> &parent_node_id = child_log.tree_loggers_[0]->parent_node_id)
633 {
634 for (const auto item : child_log.used_named_attributes.items()) {
635 add_attribute(*parent_node_id, item.key, item.value);
636 }
637 }
638 }
639 reduced_used_named_attributes_ = true;
640}
641
643{
644 if (reduced_debug_messages_) {
645 return;
646 }
647 for (NodeTreeLogger *tree_logger : tree_loggers_) {
648 for (const NodeTreeLogger::DebugMessage &debug_message : tree_logger->debug_messages) {
649 this->lookup_or_add_node_log(debug_message.node_id)
650 .debug_messages.append(debug_message.message);
651 }
652 }
653 reduced_debug_messages_ = true;
654}
655
657{
658 if (reduced_evaluated_gizmo_nodes_) {
659 return;
660 }
661 for (const NodeTreeLogger *tree_logger : tree_loggers_) {
662 for (const NodeTreeLogger::EvaluatedGizmoNode &evaluated_gizmo :
663 tree_logger->evaluated_gizmo_nodes)
664 {
665 this->evaluated_gizmo_nodes.add(evaluated_gizmo.node_id);
666 }
667 }
668
669 reduced_evaluated_gizmo_nodes_ = true;
670}
671
673{
674 if (reduced_layer_names_) {
675 return;
676 }
677
678 this->ensure_socket_values();
679
680 auto handle_value_log = [&](const ValueLog &value_log) {
681 const GeometryInfoLog *geo_log = dynamic_cast<const GeometryInfoLog *>(&value_log);
682 if (geo_log == nullptr || !geo_log->grease_pencil_info.has_value()) {
683 return;
684 }
685 for (const std::string &name : geo_log->grease_pencil_info->layer_names) {
686 this->all_layer_names.append(name);
687 }
688 };
689
690 for (const destruct_ptr<NodeLog> &node_log : this->nodes.values()) {
691 for (const ValueLog *value_log : node_log->input_values_.values()) {
692 handle_value_log(*value_log);
693 }
694 for (const ValueLog *value_log : node_log->output_values_.values()) {
695 handle_value_log(*value_log);
696 }
697 }
698
699 reduced_layer_names_ = true;
700}
701
703{
704 if (reduced_node_image_previews_) {
705 return;
706 }
707
708 for (NodeTreeLogger *tree_logger : tree_loggers_) {
709 for (const NodeTreeLogger::NodeImagePreview &preview : tree_logger->node_image_previews) {
711 this->lookup_or_add_node_log(preview.node_id).image_preview = preview.image_preview;
712 }
713 }
714
715 reduced_node_image_previews_ = true;
716}
717
719{
720 const destruct_ptr<NodeLog> *node_log = this->nodes.lookup_ptr(identifier);
721 if (!node_log) {
722 return nullptr;
723 }
724 return node_log->get();
725}
726
728{
729 destruct_ptr<NodeLog> &node_log = this->nodes.lookup_or_add_cb(
730 identifier, [&]() { return this->allocator_.construct<NodeLog>(); });
731 return *node_log.get();
732}
733
735{
741
742 BLI_assert(reduced_socket_values_);
743 if (query_socket.is_multi_input()) {
744 /* Not supported currently. */
745 return nullptr;
746 }
747
748 Set<const bNodeSocket *> added_sockets;
749 Stack<const bNodeSocket *> sockets_to_check;
750 sockets_to_check.push(&query_socket);
751 added_sockets.add(&query_socket);
752 const bNodeTree &tree = query_socket.owner_tree();
753
754 while (!sockets_to_check.is_empty()) {
755 const bNodeSocket &socket = *sockets_to_check.pop();
756 const bNode &node = socket.owner_node();
757 if (NodeLog *node_log = this->find_node_log(node.identifier)) {
758 ValueLog *value_log = socket.is_input() ?
759 node_log->input_values_.lookup_default(socket.index(), nullptr) :
760 node_log->output_values_.lookup_default(socket.index(), nullptr);
761 if (value_log != nullptr) {
762 return value_log;
763 }
764 }
765
766 if (socket.is_input()) {
767 const Span<const bNodeLink *> links = socket.directly_linked_links();
768 for (const bNodeLink *link : links) {
769 const bNodeSocket &from_socket = *link->fromsock;
770 if (added_sockets.add(&from_socket)) {
771 sockets_to_check.push(&from_socket);
772 }
773 }
774 }
775 else {
776 if (node.is_reroute()) {
777 const bNodeSocket &input_socket = node.input_socket(0);
778 if (added_sockets.add(&input_socket)) {
779 sockets_to_check.push(&input_socket);
780 }
781 const Span<const bNodeLink *> links = input_socket.directly_linked_links();
782 for (const bNodeLink *link : links) {
783 const bNodeSocket &from_socket = *link->fromsock;
784 if (added_sockets.add(&from_socket)) {
785 sockets_to_check.push(&from_socket);
786 }
787 }
788 }
789 else if (node.is_muted()) {
790 if (const bNodeSocket *input_socket = socket.internal_link_input()) {
791 if (added_sockets.add(input_socket)) {
792 sockets_to_check.push(input_socket);
793 }
794 const Span<const bNodeLink *> links = input_socket->directly_linked_links();
795 for (const bNodeLink *link : links) {
796 const bNodeSocket &from_socket = *link->fromsock;
797 if (added_sockets.add(&from_socket)) {
798 sockets_to_check.push(&from_socket);
799 }
800 }
801 }
802 }
803 else if (node.is_group_input()) {
804 const int index = socket.index();
805 /* Check if the value is stored for any other group input node. */
806 for (const bNode *other_group_input : tree.group_input_nodes()) {
807 const bNodeSocket &other_socket = other_group_input->output_socket(index);
808 if (added_sockets.add(&other_socket)) {
809 sockets_to_check.push(&other_socket);
810 }
811 }
812 }
813 }
814 }
815
816 return nullptr;
817}
818
820 const CPPType &dst_type,
821 void *dst)
822{
823 const void *src_value = value_log.value.get();
824 if (!src_value) {
825 return false;
826 }
828 const CPPType &src_type = *value_log.value.type();
829 if (!conversions.is_convertible(src_type, dst_type) && src_type != dst_type) {
830 return false;
831 }
832 dst_type.destruct(dst);
833 conversions.convert_to_uninitialized(src_type, dst_type, src_value, dst);
834 return true;
835}
836
837static std::optional<uint32_t> get_original_session_uid(const ID *id)
838{
839 if (!id) {
840 return {};
841 }
842 if (DEG_is_original(id)) {
843 return id->session_uid;
844 }
845 if (const ID *id_orig = DEG_get_original(id)) {
846 return id_orig->session_uid;
847 }
848 return {};
849}
850
852{
853 LocalData &local_data = data_per_thread_.local();
855 local_data.tree_logger_by_context;
856 destruct_ptr<NodeTreeLogger> &tree_logger_ptr = local_tree_loggers.lookup_or_add_default(
857 compute_context.hash());
858 if (tree_logger_ptr) {
859 return *tree_logger_ptr;
860 }
861 tree_logger_ptr = local_data.allocator.construct<NodeTreeLogger>();
862 NodeTreeLogger &tree_logger = *tree_logger_ptr;
863 tree_logger.allocator = &local_data.allocator;
864 const ComputeContext *parent_compute_context = compute_context.parent();
865 std::optional<uint32_t> parent_tree_session_uid;
866 if (parent_compute_context != nullptr) {
867 tree_logger.parent_hash = parent_compute_context->hash();
868 NodeTreeLogger &parent_logger = this->get_local_tree_logger(*parent_compute_context);
869 parent_logger.children_hashes.append(compute_context.hash());
870 parent_tree_session_uid = parent_logger.tree_orig_session_uid;
871 }
872 if (const auto *context = dynamic_cast<const bke::GroupNodeComputeContext *>(&compute_context)) {
873 tree_logger.parent_node_id.emplace(context->node_id());
874 if (const bNode *caller_node = context->node()) {
875 tree_logger.tree_orig_session_uid = get_original_session_uid(caller_node->id);
876 }
877 }
878 else if (const auto *context = dynamic_cast<const bke::RepeatZoneComputeContext *>(
879 &compute_context))
880 {
881 tree_logger.parent_node_id.emplace(context->output_node_id());
882 tree_logger.tree_orig_session_uid = parent_tree_session_uid;
883 }
884 else if (const auto *context =
886 &compute_context))
887 {
888 tree_logger.parent_node_id.emplace(context->output_node_id());
889 tree_logger.tree_orig_session_uid = parent_tree_session_uid;
890 }
891 else if (const auto *context = dynamic_cast<const bke::SimulationZoneComputeContext *>(
892 &compute_context))
893 {
894 tree_logger.parent_node_id.emplace(context->output_node_id());
895 tree_logger.tree_orig_session_uid = parent_tree_session_uid;
896 }
897 else if (const auto *context = dynamic_cast<const bke::EvaluateClosureComputeContext *>(
898 &compute_context))
899 {
900 tree_logger.parent_node_id.emplace(context->node_id());
901 const std::optional<nodes::ClosureSourceLocation> &location =
902 context->closure_source_location();
903 if (location.has_value()) {
904 if (location->tree->runtime->self_geometry_nodes_lazy_function_graph_info) {
905 tree_logger.tree_orig_session_uid =
906 location->tree->runtime->self_geometry_nodes_lazy_function_graph_info
907 ->original_tree_session_uid;
908 }
909 else {
910 tree_logger.tree_orig_session_uid = get_original_session_uid(
911 id_cast<const ID *>(location->tree));
912 }
913 }
914 }
915 else if (const auto *context = dynamic_cast<const bke::GeometryNodesModifierComputeContext *>(
916 &compute_context))
917 {
918 if (const NodesModifierData *nmd = context->nmd()) {
919 tree_logger.tree_orig_session_uid = get_original_session_uid(
920 reinterpret_cast<const ID *>(nmd->node_group));
921 }
922 }
923 else if (const auto *context = dynamic_cast<const bke::SceneCompositorEffectComputeContext *>(
924 &compute_context))
925 {
926 tree_logger.tree_orig_session_uid = get_original_session_uid(
927 reinterpret_cast<const ID *>(context->effect().node_group));
928 }
929 else if (const auto *context = dynamic_cast<const bke::OperatorComputeContext *>(
930 &compute_context))
931 {
932 if (const bNodeTree *tree = context->tree()) {
933 tree_logger.tree_orig_session_uid = tree->id.session_uid;
934 }
935 }
936 return tree_logger;
937}
938
940{
941 NodeTreeLog &reduced_tree_log = *tree_logs_.lookup_or_add_cb(compute_context_hash, [&]() {
942 Vector<NodeTreeLogger *> tree_logs;
943 for (LocalData &local_data : data_per_thread_) {
944 destruct_ptr<NodeTreeLogger> *tree_log = local_data.tree_logger_by_context.lookup_ptr(
945 compute_context_hash);
946 if (tree_log != nullptr) {
947 tree_logs.append(tree_log->get());
948 }
949 }
950 return std::make_unique<NodeTreeLog>(this, std::move(tree_logs));
951 });
952 return reduced_tree_log;
953}
954
956 const bNodeTreeZone &zone,
957 bke::ComputeContextCache &compute_context_cache,
958 const ComputeContext *current,
960{
961 current = ed::space_node::compute_context_for_zone(zone, compute_context_cache, current);
962 if (!current) {
963 return;
964 }
965 r_hash_by_zone.add_new(&zone, current->hash());
966 for (const bNodeTreeZone *child_zone : zone.child_zones) {
967 find_tree_zone_hash_recursive(*child_zone, compute_context_cache, current, r_hash_by_zone);
968 }
969}
970
972 get_context_hash_by_zone_for_node_editor(const SpaceNode &snode,
973 bke::ComputeContextCache &compute_context_cache)
974{
976 snode, compute_context_cache);
977 if (!current) {
978 return {};
979 }
980
981 const bNodeTreeZones *tree_zones = snode.edittree->zones();
982 if (tree_zones == nullptr) {
983 return {};
984 }
986 hash_by_zone.add_new(nullptr, current->hash());
987 for (const bNodeTreeZone *zone : tree_zones->root_zones) {
988 find_tree_zone_hash_recursive(*zone, compute_context_cache, current, hash_by_zone);
989 }
990 return hash_by_zone;
991}
992
994{
997 std::optional<ed::space_node::ObjectAndModifier> object_and_modifier =
999 if (!object_and_modifier) {
1000 return {};
1001 }
1002 return object_and_modifier->nmd->runtime->eval_log.get();
1003 }
1004 case SNODE_GEOMETRY_TOOL: {
1007 if (snode.selected_node_group->id.name + 2 != log.node_group_name) {
1008 return {};
1009 }
1010 return log.log.get();
1011 }
1012 }
1013
1014 return nullptr;
1015}
1016
1018{
1021 const Scene *scene = reinterpret_cast<Scene *>(space_node.id);
1022 if (!scene) {
1023 return nullptr;
1024 }
1025 return scene->runtime->compositor.nodes_evaluation_log.get();
1026 }
1028 return nullptr;
1029 }
1030 }
1031
1032 return nullptr;
1033}
1034
1036{
1037 if (ED_node_is_geometry(&snode)) {
1038 return get_geometry_nodes_root_log(snode);
1039 }
1040
1041 if (ED_node_is_compositor(&snode)) {
1042 return get_compositor_root_log(snode);
1043 }
1044
1045 return nullptr;
1046}
1047
1049{
1050 NodesEvalLog *log = get_root_log(snode);
1051 if (!log) {
1052 return {};
1053 }
1054 bke::ComputeContextCache compute_context_cache;
1056 NodesEvalLog::get_context_hash_by_zone_for_node_editor(snode, compute_context_cache);
1058 for (const auto item : hash_by_zone.items()) {
1059 NodeTreeLog &tree_log = log->get_tree_log(item.value);
1060 tree_logs_by_zone.add(item.key, &tree_log);
1061 }
1062 return {tree_logs_by_zone};
1063}
1064
1066{
1067 const std::optional<ed::viewer_path::ViewerPathForGeometryNodesViewer> parsed_path =
1069 if (!parsed_path.has_value()) {
1070 return nullptr;
1071 }
1072 const Object *object = parsed_path->object;
1073 NodesModifierData *nmd = nullptr;
1074 for (ModifierData &md : object->modifiers) {
1075 if (md.persistent_uid == parsed_path->modifier_uid) {
1076 if (md.type == eModifierType_Nodes) {
1077 nmd = reinterpret_cast<NodesModifierData *>(&md);
1078 }
1079 }
1080 }
1081 if (nmd == nullptr) {
1082 return nullptr;
1083 }
1084 if (!nmd->runtime->eval_log) {
1085 return nullptr;
1086 }
1087 nodes::eval_log::NodesEvalLog *root_log = nmd->runtime->eval_log.get();
1088
1089 bke::ComputeContextCache compute_context_cache;
1090 const ComputeContext *object_context = &compute_context_cache.for_data_block(
1091 nullptr, parsed_path->object->id);
1092 const ComputeContext *compute_context = &compute_context_cache.for_geometry_nodes_modifier(
1093 object_context, *nmd);
1094 for (const ViewerPathElem *elem : parsed_path->node_path) {
1096 *elem, compute_context_cache, compute_context);
1097 if (!compute_context) {
1098 return nullptr;
1099 }
1100 }
1101 const ComputeContextHash context_hash = compute_context->hash();
1102 nodes::eval_log::NodeTreeLog &tree_log = root_log->get_tree_log(context_hash);
1103 tree_log.ensure_viewer_node_logs();
1104
1105 const ViewerNodeLog *viewer_log = tree_log.viewer_node_logs.lookup_default(
1106 parsed_path->viewer_node_id, nullptr);
1107 return viewer_log;
1108}
1109
1112 : tree_logs_by_zone_(std::move(tree_logs_by_zone))
1113{
1114}
1115
1117{
1118 return tree_logs_by_zone_.lookup_default(zone, nullptr);
1119}
1120
1122{
1123 const bNodeTree &tree = node.owner_tree();
1124 const bke::bNodeTreeZones *zones = tree.zones();
1125 if (!zones) {
1126 return nullptr;
1127 }
1128 const bke::bNodeTreeZone *zone = zones->get_zone_by_node(node.identifier);
1129 return this->get_main_tree_log(zone);
1130}
1131
1133{
1134 const bNodeTree &tree = socket.owner_tree();
1135 const bke::bNodeTreeZones *zones = tree.zones();
1136 if (!zones) {
1137 return nullptr;
1138 }
1139 const bke::bNodeTreeZone *zone = zones->get_zone_by_socket(socket);
1140 return this->get_main_tree_log(zone);
1141}
1142
1144{
1145 for (NodeTreeLog *tree_log : tree_logs_by_zone_.values()) {
1146 if (tree_log) {
1147 callback(*tree_log);
1148 }
1149 }
1150}
1151
1152} // namespace blender::nodes::eval_log
Low-level operations for curves.
Low-level operations for grease pencil.
#define FOREACH_NODETREE_END
Definition BKE_node.hh:936
#define FOREACH_NODETREE_BEGIN(bmain, _nodetree, _id)
Definition BKE_node.hh:926
Volume data-block.
#define ID_MISSING(_id)
Definition DNA_ID.h:695
#define UNUSED_VARS(...)
SIMD_FORCE_INLINE btVector3 operator()(const btVector3 &x) const
Return the transform of the vector.
Definition btTransform.h:90
bool is() const
void copy_construct(const void *src, void *dst) const
void destruct(void *ptr) const
const ComputeContext * parent() const
const ComputeContextHash & hash() const
const CPPType * type() const
const CPPType * type() const
const void * get() const
constexpr IndexRange()=default
destruct_ptr< T > construct(Args &&...args)
StringRefNull copy_string(StringRef str)
void * allocate(const int64_t size, const int64_t alignment)
Value & lookup_or_add_default(const Key &key)
Definition BLI_map.hh:639
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
Value lookup_default(const Key &key, const Value &default_value) const
Definition BLI_map.hh:570
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
ItemIterator items() const &
Definition BLI_map.hh:902
bool add(const Key &key)
Definition BLI_set.hh:248
bool is_empty() const
Definition BLI_stack.hh:310
void push(const T &value)
Definition BLI_stack.hh:215
constexpr StringRef()
int64_t size() const
void append(const T &value)
void extend(Span< T > array)
std::unique_ptr< nodes::eval_log::NodesEvalLog > nodes_evaluation_log
const GeometryNodesModifierComputeContext & for_geometry_nodes_modifier(const ComputeContext *parent, const NodesModifierData &nmd)
const DataBlockComputeContext & for_data_block(const ComputeContext *parent, const uint32_t orig_session_uid, const ID *id=nullptr)
void convert_to_uninitialized(const CPPType &from_type, const CPPType &to_type, const void *from_value, void *to_value) const
bool is_convertible(const CPPType &from_type, const CPPType &to_type) const
Vector< bNodeTreeZone * > child_zones
Vector< bNodeTreeZone * > root_zones
const bNodeTreeZone * get_zone_by_node(const int32_t node_id) const
const bNodeTreeZone * get_zone_by_socket(const bNodeSocket &socket) const
const FieldInputsPtr & field_inputs() const
Definition field.cc:504
CustomIDVectorSet< Item, ItemKeyGetter > inputs
CustomIDVectorSet< Item, ItemKeyGetter > outputs
std::shared_ptr< ClosureEvalLog > eval_log
ClosureValueLog(Vector< Item > inputs, Vector< Item > outputs, const std::optional< ClosureSourceLocation > &source_location, std::shared_ptr< ClosureEvalLog > eval_log)
Definition eval_log.cc:243
NodeTreeLog * get_main_tree_log(const bke::bNodeTreeZone *zone) const
Definition eval_log.cc:1116
ContextualNodeTreeLogs(Map< const bke::bNodeTreeZone *, NodeTreeLog * > tree_logs_by_zone={})
Definition eval_log.cc:1110
void foreach_tree_log(FunctionRef< void(NodeTreeLog &)> callback) const
Definition eval_log.cc:1143
FieldInfoLog(const GField &field)
Definition eval_log.cc:80
VectorSet< std::reference_wrapper< const FieldInput > > inputs
Definition FN_field.hh:327
std::optional< GreasePencilInfo > grease_pencil_info
GeometryInfoLog(const bke::GeometrySet &geometry_set)
Definition eval_log.cc:99
std::optional< VolumeInfo > volume_info
std::optional< CurveInfo > curve_info
std::optional< PointCloudInfo > pointcloud_info
Vector< bke::GeometryComponent::Type > component_types
Vector< GeometryAttributeInfo > attributes
std::optional< EditDataInfo > edit_data_info
std::optional< InstancesInfo > instances_info
GridInfoLog(const bke::GVolumeGrid &grid)
Definition eval_log.cc:221
ImageInfoLog(int2 data_size, int2 display_size, int2 data_offset, float3x3 transformation, StringRefNull interpolation, StringRefNull extension_x, StringRefNull extension_y, StringRefNull precision)
Definition eval_log.cc:268
ListInfoLog(const GListPtr &list)
Definition eval_log.cc:259
std::chrono::nanoseconds execution_time
Map< int32_t, destruct_ptr< NodeLog > > nodes
void ensure_node_warnings(const NodesModifierData &nmd)
Definition eval_log.cc:438
Map< int32_t, ViewerNodeLog *, 0 > viewer_node_logs
NodeLog & lookup_or_add_node_log(const int32_t identifier)
Definition eval_log.cc:727
Vector< const GeometryAttributeInfo * > existing_attributes
NodeTreeLog(NodesEvalLog *root_log, Vector< NodeTreeLogger * > tree_loggers)
Definition eval_log.cc:307
VectorSet< NodeWarning > all_warnings
Map< StringRefNull, NamedAttributeUsage > used_named_attributes
NodeLog * find_node_log(int32_t identifier) const
Definition eval_log.cc:718
bool try_convert_primitive_socket_value(const GenericValueLog &value_log, const CPPType &dst_type, void *dst)
Definition eval_log.cc:819
ValueLog * find_socket_value_log(const bNodeSocket &query_socket)
Definition eval_log.cc:734
linear_allocator::ChunkedList< SocketValueLog, 16 > input_socket_values
linear_allocator::ChunkedList< NodeImagePreview, 16 > node_image_previews
Vector< ComputeContextHash > children_hashes
linear_allocator::ChunkedList< SocketValueLog, 16 > output_socket_values
std::optional< uint32_t > tree_orig_session_uid
void log_value(const bNode &node, const bNodeSocket &socket, GPointer value)
Definition eval_log.cc:319
std::optional< int32_t > parent_node_id
NodeTreeLogger & get_local_tree_logger(const ComputeContext &compute_context)
Definition eval_log.cc:851
static ContextualNodeTreeLogs get_contextual_tree_logs(const SpaceNode &snode)
Definition eval_log.cc:1048
static Map< const bke::bNodeTreeZone *, ComputeContextHash > get_context_hash_by_zone_for_node_editor(const SpaceNode &snode, bke::ComputeContextCache &compute_context_cache)
Definition eval_log.cc:972
NodeTreeLog & get_tree_log(const ComputeContextHash &compute_context_hash)
Definition eval_log.cc:939
static const ViewerNodeLog * find_viewer_node_log_for_path(const ViewerPath &viewer_path)
Definition eval_log.cc:1065
const bke::GeometrySet * main_geometry() const
Definition eval_log.cc:415
CustomIDVectorSet< Item, ItemIdentifierGetter > items
#define attribute(slot)
#define layer
#define log
VolumeGridType get_type(const VolumeGridData &grid)
bool attribute_name_is_anonymous(const StringRef name)
const DataTypeConversions & get_implicit_type_conversions()
const GeoOperatorLog & node_group_operator_static_eval_log()
std::optional< ObjectAndModifier > get_geometry_nodes_modifier_for_node_editor(const SpaceNode &snode)
const ComputeContext * compute_context_for_edittree(const SpaceNode &snode, bke::ComputeContextCache &compute_context_cache)
const ComputeContext * compute_context_for_zone(const bke::bNodeTreeZone &zone, bke::ComputeContextCache &compute_context_cache, const ComputeContext *parent_compute_context)
std::optional< ViewerPathForGeometryNodesViewer > parse_geometry_nodes_viewer(const ViewerPath &viewer_path)
const ComputeContext * compute_context_for_viewer_path_elem(const ViewerPathElem &elem, bke::ComputeContextCache &compute_context_cache, const ComputeContext *parent_compute_context)
ImplicitSharingPtr< FieldInputs > FieldInputsPtr
Definition FN_field.hh:45
static NodesEvalLog * get_compositor_root_log(const SpaceNode &space_node)
Definition eval_log.cc:1017
static std::optional< uint32_t > get_original_session_uid(const ID *id)
Definition eval_log.cc:837
static void find_tree_zone_hash_recursive(const bNodeTreeZone &zone, bke::ComputeContextCache &compute_context_cache, const ComputeContext *current, Map< const bNodeTreeZone *, ComputeContextHash > &r_hash_by_zone)
Definition eval_log.cc:955
static NodesEvalLog * get_geometry_nodes_root_log(const SpaceNode &snode)
Definition eval_log.cc:993
static NodesEvalLog * get_root_log(const SpaceNode &snode)
Definition eval_log.cc:1035
ImplicitSharingPtr< Closure > ClosurePtr
bool warning_is_propagated(const NodeWarningPropagation propagation, const NodeWarningType warning_type)
Definition warning.cc:74
ImplicitSharingPtr< Bundle > BundlePtr
bool ED_node_is_compositor(const SpaceNode *snode)
Definition node_edit.cc:135
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool ED_node_is_geometry(const SpaceNode *snode)
Definition node_edit.cc:150
ID * DEG_get_original_id(ID *id)
int char char int int int BLI_strcasecmp_natural(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int BKE_volume_num_grids(const Volume *volume)
@ SNODE_GEOMETRY_MODIFIER
const bke::VolumeGridData * BKE_volume_grid_get(const Volume *volume, int grid_index)
std::unique_ptr< T, DestructValueAtAddress< T > > destruct_ptr
void IMB_refImBuf(ImBuf *ibuf)
bool DEG_is_original(const T *id)
@ NODE_WARNING_PROPAGATION_ALL
SpaceNodeCompositorNodesType
@ SNODE_COMPOSITOR_SEQUENCER
@ SNODE_COMPOSITOR_SCENE
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< int32_t, 2 > int2
BMesh const char void * data
void BKE_volume_grid_add(Volume *volume, const bke::VolumeGridData &grid)
MatBase< float, 3, 3 > float3x3
void * BKE_id_new_nomain(short type, const char *name)
Definition lib_id.cc:1617
const char * BLI_str_find_prev_char_utf8(const char *p, const char *str_start) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1
T * DEG_get_original(T *id)
signed int int32_t
Definition BKE_text.h:78
void BKE_library_foreach_ID_link(Main *bmain, ID *id, FunctionRef< LibraryIDLinkCallback > callback, void *user_data, LibraryForeachIDFlag flag)
Definition lib_query.cc:449
#define hash
Definition noise_c.cc:156
char name[258]
Definition DNA_ID.h:433
unsigned int session_uid
Definition DNA_ID.h:463
NodesModifierRuntime * runtime
std::shared_ptr< nodes::eval_log::NodesEvalLog > eval_log
Definition MOD_nodes.hh:58
bke::SceneRuntime * runtime
struct bNodeTree * selected_node_group
struct bNodeTree * edittree
eNodeSocketInOut in_out
StringRefNull name() const
Vector< const GeometryComponent * > get_components() const
static GeometrySet from_volume(Volume *volume, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
void attribute_foreach(Span< GeometryComponent::Type > component_types, bool include_instances, AttributeForeachCallback callback) const
StringLog(StringRef string, LinearAllocator<> &allocator)
Definition eval_log.cc:67
void reserve(int new_size)
Definition vector.hh:78