10#include <fmt/format.h>
73#include "RNA_prototypes.hh"
108 nmd->
runtime = MEM_new<NodesModifierRuntime>(__func__);
109 nmd->
runtime->
cache = std::make_shared<bake::ModifierCache>();
117 if (ID *id = IDP_ID_get(property)) {
118 deps.add_generic_id_full(id);
144 if (&
object == ctx->
object) {
148 const bool is_just_collection_instance =
object.type ==
OB_EMPTY &&
149 object.instance_collection !=
nullptr &&
150 object.modifiers.is_empty();
151 if (is_just_collection_instance) {
196 for (
ID *
id : eval_deps.
ids.values()) {
246 if (tree ==
nullptr) {
271 walk(user_data, ob, reinterpret_cast<ID **>(&id_prop->data.pointer), IDWALK_CB_USER);
287 walk(user_data, ob, md, &ptr, prop);
318 nmd.
runtime->
cache = std::make_shared<bake::ModifierCache>();
321 std::lock_guard
lock{modifier_cache.
mutex};
325 existing_bake_ids.
add(
bake.id);
328 auto remove_predicate = [&](
auto item) {
return !existing_bake_ids.
contains(item.key); };
347 new_bake_ids.
append(ref.id);
350 else if (old_bake_by_id.
contains(ref.id)) {
353 new_bake_ids.
append(ref.id);
361 const int id = new_bake_ids[i];
365 new_bake = *old_bake;
370 old_bake->
packed =
nullptr;
383 MEM_SAFE_DELETE(nmd.
bakes);
385 nmd.
bakes = new_bake_data;
401 &
object.
id, RNA_NodesModifierProperties, &nmd);
414NodesModifierBake *NodesModifierData::find_bake(
const int id)
416 return const_cast<NodesModifierBake *
>(std::as_const(*this).find_bake(
id));
419const NodesModifierBake *NodesModifierData::find_bake(
const int id)
const
421 for (
const NodesModifierBake &bake :
Span{this->bakes, this->bakes_num}) {
436 const int final_node_id,
446 compute_context_vec.
append(c);
448 std::reverse(compute_context_vec.
begin(), compute_context_vec.
end());
450 const auto *modifier_compute_context =
452 if (modifier_compute_context ==
nullptr) {
469 if (current_zones ==
nullptr) {
474 if (lf_graph_info ==
nullptr) {
478 compute_context_generic->parent()->
hash();
480 compute_context_generic))
483 compute_context->output_node_id());
484 if (simulation_zone ==
nullptr) {
487 if (simulation_zone->
parent_zone != current_zone) {
492 if (lf_zone_node ==
nullptr) {
495 const lf::FunctionNode *lf_simulation_output_node =
498 if (lf_simulation_output_node ==
nullptr) {
501 local_side_effect_nodes.
nodes_by_context.add(parent_compute_context_hash, lf_zone_node);
504 local_side_effect_nodes.
nodes_by_context.add(compute_context_generic->hash(),
505 lf_simulation_output_node);
507 current_zone = simulation_zone;
510 compute_context_generic))
513 compute_context->output_node_id());
514 if (repeat_zone ==
nullptr) {
522 if (lf_zone_node ==
nullptr) {
525 local_side_effect_nodes.
nodes_by_context.add(parent_compute_context_hash, lf_zone_node);
527 {parent_compute_context_hash, compute_context->output_node_id()},
528 compute_context->iteration());
529 current_zone = repeat_zone;
531 else if (
const auto *compute_context =
533 compute_context_generic))
536 compute_context->output_node_id());
537 if (foreach_zone ==
nullptr) {
545 if (lf_zone_node ==
nullptr) {
548 local_side_effect_nodes.
nodes_by_context.add(parent_compute_context_hash, lf_zone_node);
550 {parent_compute_context_hash, compute_context->output_node_id()},
551 compute_context->index());
552 current_zone = foreach_zone;
555 compute_context_generic))
557 const bNode *group_node = current_tree->node_by_id(compute_context->node_id());
558 if (group_node ==
nullptr) {
561 if (group_node->
id ==
nullptr) {
564 if (group_node->is_muted()) {
572 if (lf_group_node ==
nullptr) {
575 local_side_effect_nodes.
nodes_by_context.add(parent_compute_context_hash, lf_group_node);
576 current_tree =
reinterpret_cast<const bNodeTree *
>(group_node->
id);
577 current_zone =
nullptr;
579 else if (
const auto *compute_context =
582 const bNode *evaluate_node = current_tree->node_by_id(compute_context->node_id());
583 if (!evaluate_node) {
586 if (evaluate_node->is_muted()) {
592 const std::optional<nodes::ClosureSourceLocation> &source_location =
593 compute_context->closure_source_location();
594 if (!source_location) {
597 if (!source_location->tree->zones()) {
600 const lf::FunctionNode *lf_evaluate_node =
603 if (!lf_evaluate_node) {
609 source_location->tree :
612 ctx.
depsgraph, &source_location->tree->id));
613 const bNode *closure_output_node = eval_closure_tree->node_by_id(
614 source_location->closure_output_node_id);
615 if (!closure_output_node) {
618 local_side_effect_nodes.
nodes_by_context.add(parent_compute_context_hash, lf_evaluate_node);
619 current_tree = eval_closure_tree;
620 current_zone = eval_closure_tree->zones()->get_zone_by_node(closure_output_node->
identifier);
626 const bNode *final_node = current_tree->node_by_id(final_node_id);
627 if (final_node ==
nullptr) {
632 if (lf_graph_info ==
nullptr) {
636 if (tree_zones ==
nullptr) {
642 const lf::FunctionNode *lf_node =
644 if (lf_node ==
nullptr) {
664 const std::optional<ed::viewer_path::ViewerPathForGeometryNodesViewer> parsed_path =
666 if (!parsed_path.has_value()) {
678 nullptr, parsed_path->object->id);
680 object_context, nmd);
683 *elem, compute_context_cache, current);
695 const int root_nested_node_id,
702 object_context, nmd);
704 int nested_node_id = root_nested_node_id;
707 const bNestedNodeRef *ref = tree->find_nested_node_ref(nested_node_id);
723 if (
node->is_group()) {
728 compute_context,
node->identifier, tree);
778 compute_context_cache,
780 const bNode &gizmo_node,
783 ctx, compute_context, gizmo_node.
identifier, nmd, r_side_effect_nodes);
784 r_verbose_log_contexts.
add(compute_context.
hash());
787 compute_context, gizmo_node, gizmo_socket, [&](
const ComputeContext &node_context) {
790 r_verbose_log_contexts.
add(node_context.
hash());
820 const View3D &v3d = *
reinterpret_cast<const View3D *
>(sl);
828 nmd, ctx, *
wm, r_side_effect_nodes, r_verbose_log_contexts);
845 if (sl ==
nullptr) [[unlikely]] {
858 snode, compute_context_cache);
860 r_socket_log_contexts.
add(
hash);
880 if (this->old_mappings.
contains(key)) {
884 std::lock_guard
lock{mutex_};
891 if (this->old_mappings.
contains(key)) {
894 std::lock_guard
lock{mutex_};
901 const std::optional<ID_Type> &type)
907 if (type && GS(id->
name) != *type) {
914namespace sim_input = nodes::sim_input;
915namespace sim_output = nodes::sim_output;
924 const Span<std::unique_ptr<bake::FrameCache>> frame_caches,
const SubFrame frame)
927 if (!frame_caches.is_empty()) {
930 [&](
const std::unique_ptr<bake::FrameCache> &value) {
return value->frame > frame; });
931 frame_indices.
next = (first_future_frame_index == frame_caches.size()) ?
933 std::optional<int>(first_future_frame_index);
934 if (first_future_frame_index > 0) {
935 const int index = first_future_frame_index - 1;
936 if (frame_caches[
index]->frame < frame) {
948 return frame_indices;
961 const std::string meta_str{
reinterpret_cast<const char *
>(meta_buffer->data()),
962 size_t(meta_buffer->size())};
963 std::istringstream meta_stream{meta_str};
966 if (!bake_state.has_value()) {
969 frame_cache.
values = std::move(*bake_state);
976 const auto *meta_path = std::get_if<std::string>(&*frame_cache.
meta_data_source);
984 if (!bake_values.has_value()) {
987 frame_cache.
values = std::move(*bake_values);
998 if (
bake.packed->meta_files_num == 0) {
1004 Span{
bake.packed->meta_files,
bake.packed->meta_files_num})
1010 if (!file_by_frame.
add(*frame, &meta_file)) {
1019 std::ranges::sort(frames);
1021 for (
const SubFrame &frame : frames) {
1023 auto frame_cache = std::make_unique<bake::FrameCache>();
1024 frame_cache->frame = frame;
1025 frame_cache->meta_data_source = meta_file.data();
1026 bake_cache.
frames.append(std::move(frame_cache));
1031 Span{
bake.packed->blob_files,
bake.packed->blob_files_num})
1035 bake_cache.
blob_sharing = std::make_unique<bake::BlobReadSharing>();
1049 auto frame_cache = std::make_unique<bake::FrameCache>();
1050 frame_cache->frame = meta_file.frame;
1051 frame_cache->meta_data_source = meta_file.path;
1052 bake_cache.
frames.append(std::move(frame_cache));
1054 bake_cache.
blobs_dir = bake_path->blobs_dir;
1055 bake_cache.
blob_sharing = std::make_unique<bake::BlobReadSharing>();
1061 static constexpr float max_delta_frames = 1.0f;
1066 const Scene *scene_;
1068 bool use_frame_cache_;
1069 bool depsgraph_is_active_;
1072 bool has_invalid_simulation_ =
false;
1083 : nmd_(nmd), ctx_(ctx)
1085 const Depsgraph *depsgraph = ctx_.depsgraph;
1093 fps_ = scene->frames_per_second();
1095 if (!modifier_cache_) {
1098 std::lock_guard
lock{modifier_cache_->mutex};
1099 if (depsgraph_is_active_) {
1102 for (std::unique_ptr<bake::SimulationNodeCache> &node_cache :
1103 modifier_cache_->simulation_cache_by_id.values())
1105 if (node_cache->cache_status != bake::CacheStatus::Baked) {
1106 node_cache->cache_status = bake::CacheStatus::Invalid;
1107 if (!node_cache->bake.frames.is_empty()) {
1108 if (node_cache->bake.frames.last()->frame == current_frame_) {
1111 node_cache->bake.frames.pop_last();
1119 for (
const std::unique_ptr<bake::SimulationNodeCache> &node_cache_ptr :
1120 modifier_cache_->simulation_cache_by_id.values())
1123 if (node_cache.
cache_status == bake::CacheStatus::Invalid) {
1124 has_invalid_simulation_ =
true;
1132 for (
auto item : modifier_cache_->simulation_cache_by_id.items()) {
1133 const int id = item.key;
1135 if (node_cache.
cache_status != bake::CacheStatus::Invalid) {
1139 *scene_, *ctx_.object, nmd_,
id);
1140 if (!sim_frame_range.has_value()) {
1143 const SubFrame start_frame{int(sim_frame_range->start())};
1144 if (current_frame_ <= start_frame) {
1148 current_frame_ < node_cache.
bake.
frames.first()->frame)
1157 if (!modifier_cache_) {
1160 std::lock_guard
lock{modifier_cache_->mutex};
1161 return &this->data_by_zone_id
1164 auto data = std::make_unique<DataPerZone>();
1165 data->behavior.data_block_map = &
data->data_block_map;
1167 zone_id,
data->behavior,
data->data_block_map);
1178 *modifier_cache_->simulation_cache_by_id.lookup_or_add_cb(
1179 zone_id, []() {
return std::make_unique<bake::SimulationNodeCache>(); });
1182 *scene_, *ctx_.object, nmd_, zone_id);
1183 const SubFrame sim_start_frame{int(sim_frame_range.
first())};
1184 const SubFrame sim_end_frame{int(sim_frame_range.
last())};
1186 if (!modifier_cache_->requested_bakes.contains(zone_id)) {
1189 if (node_cache.
cache_status != bake::CacheStatus::Baked) {
1204 data_block_map.
old_mappings.add(data_block, data_block.id);
1210 if (node_cache.
cache_status == bake::CacheStatus::Baked) {
1214 if (use_frame_cache_) {
1217 if (depsgraph_is_active_) {
1219 if (current_frame_ < sim_start_frame || current_frame_ > sim_end_frame) {
1226 if (current_frame_ > sim_start_frame || has_invalid_simulation_) {
1233 if (frame_indices.
prev && !frame_indices.
current && !frame_indices.
next &&
1234 current_frame_ <= sim_end_frame)
1239 const float real_delta_frames =
float(current_frame_) -
float(prev_frame_cache.frame);
1240 if (real_delta_frames != 1) {
1243 const float delta_frames = std::min(max_delta_frames, real_delta_frames);
1244 use_cache_info.delta_time = delta_frames / fps_;
1245 use_cache_info.values = prev_frame_cache.values;
1256 if (node_cache.
prev_cache->frame < current_frame_) {
1258 const float delta_frames = std::min(
1259 max_delta_frames,
float(current_frame_) -
float(node_cache.
prev_cache->frame));
1261 use_cache_info.
delta_time = delta_frames / fps_;
1262 use_cache_info.values = std::move(node_cache.
prev_cache->values);
1266 if (node_cache.
prev_cache->frame == current_frame_) {
1270 use_cache_info.values = node_cache.
prev_cache->values;
1275 if (!depsgraph_is_active_) {
1286 if (depsgraph_is_active_) {
1310 [simulation_cache = modifier_cache_,
1311 node_cache = &node_cache,
1313 std::lock_guard
lock{simulation_cache->mutex};
1314 auto frame_cache = std::make_unique<bake::FrameCache>();
1315 frame_cache->frame = current_frame;
1316 frame_cache->values = std::move(values);
1317 node_cache->
bake.
frames.append(std::move(frame_cache));
1326 [simulation_cache = modifier_cache_,
1327 node_cache = &node_cache,
1329 std::lock_guard
lock{simulation_cache->mutex};
1333 node_cache->
prev_cache->values = std::move(values);
1334 node_cache->
prev_cache->frame = current_frame;
1342 if (frame_indices.
prev) {
1345 const float delta_frames = std::min(max_delta_frames,
1346 float(current_frame_) -
float(frame_cache.frame));
1347 use_cache_info.delta_time = delta_frames / fps_;
1348 use_cache_info.values = frame_cache.values;
1356 else if (frame_indices.
next) {
1357 if (frame_indices.
prev) {
1359 *frame_indices.
prev, *frame_indices.
next, node_cache, zone_behavior);
1365 else if (frame_indices.
prev) {
1384 const int next_frame_index,
1394 (
float(next_frame_cache.
frame) -
1395 float(prev_frame_cache.
frame));
1396 read_interpolated_info.prev_values = prev_frame_cache.
values;
1397 read_interpolated_info.next_values = next_frame_cache.
values;
1408 bool depsgraph_is_active_;
1419 : nmd_(nmd), ctx_(ctx)
1421 const Depsgraph *depsgraph = ctx_.depsgraph;
1430 if (!modifier_cache_) {
1433 std::lock_guard
lock{modifier_cache_->mutex};
1434 return &this->data_by_node_id
1437 auto data = std::make_unique<DataPerNode>();
1438 data->behavior.data_block_map = &
data->data_block_map;
1439 this->init_bake_behavior(
1440 id,
data->behavior,
data->data_block_map);
1448 void init_bake_behavior(
const int id,
1453 id, []() {
return std::make_unique<bake::BakeNodeCache>(); });
1454 const NodesModifierBake &bake = *nmd_.find_bake(
id);
1456 for (
const NodesModifierDataBlock &data_block :
Span{bake.data_blocks, bake.data_blocks_num}) {
1457 data_block_map.
old_mappings.add(data_block, data_block.id);
1460 if (depsgraph_is_active_) {
1463 auto &store_info = behavior.
behavior.emplace<sim_output::StoreNewState>();
1464 store_info.store_fn = [modifier_cache = modifier_cache_,
1465 node_cache = &node_cache,
1466 current_frame = current_frame_](bake::BakeValues values) {
1467 std::lock_guard
lock{modifier_cache->mutex};
1468 auto frame_cache = std::make_unique<bake::FrameCache>();
1469 frame_cache->frame = current_frame;
1470 frame_cache->values = std::move(values);
1471 auto &frames = node_cache->bake.frames;
1472 const int insert_index = binary_search::first_if(
1473 frames, [&](
const std::unique_ptr<bake::FrameCache> &frame_cache) {
1474 return frame_cache->frame > current_frame;
1476 frames.insert(insert_index, std::move(frame_cache));
1483 if (node_cache.bake.frames.is_empty()) {
1484 if (!node_cache.bake.failed_finding_bake) {
1486 node_cache.bake.failed_finding_bake =
true;
1491 if (node_cache.bake.frames.is_empty()) {
1492 behavior.
behavior.emplace<sim_output::PassThrough>();
1497 if (frame_indices.current) {
1498 this->read_single(*frame_indices.current, node_cache, behavior);
1501 if (frame_indices.prev && frame_indices.next) {
1502 this->read_interpolated(*frame_indices.prev, *frame_indices.next, node_cache, behavior);
1505 if (frame_indices.prev) {
1506 this->read_single(*frame_indices.prev, node_cache, behavior);
1509 if (frame_indices.next) {
1510 this->read_single(*frame_indices.next, node_cache, behavior);
1516 void read_single(
const int frame_index,
1517 bake::BakeNodeCache &node_cache,
1518 nodes::BakeNodeBehavior &behavior)
const
1520 bake::FrameCache &frame_cache = *node_cache.bake.frames[frame_index];
1522 if (this->check_read_error(frame_cache, behavior)) {
1525 auto &read_single_info = behavior.behavior.emplace<sim_output::ReadSingle>();
1526 read_single_info.values = frame_cache.values;
1529 void read_interpolated(
const int prev_frame_index,
1530 const int next_frame_index,
1531 bake::BakeNodeCache &node_cache,
1532 nodes::BakeNodeBehavior &behavior)
const
1534 bake::FrameCache &prev_frame_cache = *node_cache.bake.frames[prev_frame_index];
1535 bake::FrameCache &next_frame_cache = *node_cache.bake.frames[next_frame_index];
1538 if (this->check_read_error(prev_frame_cache, behavior) ||
1539 this->check_read_error(next_frame_cache, behavior))
1543 auto &read_interpolated_info = behavior.behavior.emplace<sim_output::ReadInterpolated>();
1544 read_interpolated_info.mix_factor = (
float(current_frame_) -
float(prev_frame_cache.frame)) /
1545 (
float(next_frame_cache.frame) -
1546 float(prev_frame_cache.frame));
1547 read_interpolated_info.prev_values = prev_frame_cache.values;
1548 read_interpolated_info.next_values = next_frame_cache.values;
1551 [[nodiscard]]
bool check_read_error(
const bake::FrameCache &frame_cache,
1552 nodes::BakeNodeBehavior &behavior)
const
1554 if (frame_cache.meta_data_source && frame_cache.values.is_empty()) {
1555 auto &read_error_info = behavior.behavior.emplace<sim_output::ReadError>();
1556 read_error_info.message =
RPT_(
"Cannot load the baked data");
1568 const int old_num =
bake.data_blocks_num;
1569 const int new_num = old_num + missing.
size();
1581 ID *
id = get_data_block(key);
1586 bake.data_blocks_num = new_num;
1591 MEM_SAFE_DELETE(data_block->
id_name);
1592 MEM_SAFE_DELETE(data_block->
lib_name);
1613 struct DataPerBake {
1614 bool reset_first =
false;
1621 if (item.value->data_block_map.old_mappings.size() <
bake.data_blocks_num) {
1622 data.reset_first =
true;
1628 if (!node_cache->bake.frames.is_empty() || node_cache->prev_cache.has_value()) {
1629 data.new_mappings = std::move(item.value->data_block_map.new_mappings);
1632 if (
data.reset_first || !
data.new_mappings.is_empty()) {
1633 writeback_data.
add(item.key, std::move(
data));
1639 if (!node_cache->bake.frames.is_empty()) {
1641 data.new_mappings = std::move(item.value->data_block_map.new_mappings);
1642 writeback_data.
add(item.key, std::move(
data));
1654 [object_eval = ctx.
object,
1658 writeback_data = std::move(writeback_data)]() {
1659 for (auto item : writeback_data.items()) {
1660 const int bake_id = item.key;
1661 DataPerBake data = item.value;
1663 NodesModifierBake &bake_orig = *nmd_orig.find_bake(bake_id);
1664 NodesModifierBake &bake_eval = *nmd_eval.find_bake(bake_id);
1666 if (data.reset_first) {
1668 dna::array::clear<NodesModifierDataBlock>(&bake_orig.data_blocks,
1669 &bake_orig.data_blocks_num,
1670 &bake_orig.active_data_block,
1671 [](NodesModifierDataBlock *data_block) {
1672 nodes_modifier_data_block_destruct(
1676 dna::array::clear<NodesModifierDataBlock>(&bake_eval.data_blocks,
1677 &bake_eval.data_blocks_num,
1678 &bake_eval.active_data_block,
1679 [](NodesModifierDataBlock *data_block) {
1680 nodes_modifier_data_block_destruct(
1685 Vector<bake::BakeDataBlockID> sorted_new_mappings;
1686 sorted_new_mappings.extend(data.new_mappings.keys().begin(),
1687 data.new_mappings.keys().end());
1688 bool needs_reevaluation = false;
1691 add_missing_data_block_mappings(
1692 bake_orig, sorted_new_mappings, [&](const bake::BakeDataBlockID &key) -> ID * {
1693 ID *id_orig = nullptr;
1694 if (ID *id_eval = data.new_mappings.lookup_default(key, nullptr)) {
1695 id_orig = DEG_get_original(id_eval);
1698 needs_reevaluation = true;
1699 id_orig = BKE_libblock_find_name_and_library(
1700 bmain, short(key.type), key.id_name.c_str(), key.lib_name.c_str());
1703 id_us_plus(id_orig);
1711 add_missing_data_block_mappings(
1712 bake_eval, sorted_new_mappings, [&](const bake::BakeDataBlockID &key) -> ID * {
1713 return data.new_mappings.lookup_default(key, nullptr);
1716 if (needs_reevaluation) {
1717 Object *object_orig = DEG_get_original(object_eval);
1718 DEG_id_tag_update(&object_orig->id, ID_RECALC_GEOMETRY);
1719 DEG_relations_tag_update(bmain);
1741 tree.ensure_topology_cache();
1742 const bNode *output_node = tree.group_output_node();
1743 if (output_node ==
nullptr) {
1745 geometry_set.
clear();
1752 geometry_set.
clear();
1756 const bNodeSocket *first_output_socket = group_outputs[0];
1757 if (!
STREQ(first_output_socket->
idname,
"NodeSocketGeometry")) {
1759 geometry_set.
clear();
1765 if (lf_graph_info ==
nullptr) {
1767 geometry_set.
clear();
1771 bool use_orig_index_verts =
false;
1772 bool use_orig_index_edges =
false;
1773 bool use_orig_index_faces =
false;
1785 auto eval_log = std::make_unique<nodes::eval_log::NodesEvalLog>();
1813 tree, properties_ptr, modifier_compute_context, call_data, std::move(geometry_set));
1823 if (use_orig_index_verts || use_orig_index_edges || use_orig_index_faces) {
1828 if (use_orig_index_verts) {
1831 if (use_orig_index_edges) {
1834 if (use_orig_index_faces) {
1849 if (mesh_component.
get() !=
mesh) {
1856 if (new_mesh ==
nullptr) {
1876 tree.ensure_interface_cache();
1877 tree.ensure_topology_cache();
1889 XXH3_state_t *
state = XXH3_createState();
1890 XXH3_64bits_reset(
state);
1894 XXH3_64bits_update(
state, &input_i,
sizeof(input_i));
1898 const CPPType &base_type = *io_socket.socket_typeinfo()->base_cpp_type;
1900 XXH3_64bits_update(
state, &value_hash,
sizeof(value_hash));
1903 const uint64_t new_input_values_hash = XXH3_64bits_digest(
state);
1904 if (new_input_values_hash == input_values_hash_) {
1905 if (this->
inputs.size() == tree.interface_inputs().size() &&
1906 this->outputs.size() == tree.interface_outputs().size())
1913 this->
inputs.reinitialize(tree.interface_inputs().size());
1914 this->
outputs.reinitialize(tree.interface_outputs().size());
1917 input_values_hash_ = new_input_values_hash;
1922 input_values_hash_ = 0;
1968 if (bake_file.packed_file) {
1973 Span{
bake.packed->meta_files,
bake.packed->meta_files_num})
1975 write_bake_file(meta_file);
1978 Span{
bake.packed->blob_files,
bake.packed->blob_files_num})
1980 write_bake_file(blob_file);
2023 reader, &
bake.packed->meta_files, &
bake.packed->meta_files_num);
2025 reader, &
bake.packed->blob_files, &
bake.packed->blob_files_num);
2028 if (bake_file.packed_file) {
2035 read_bake_file(meta_file);
2040 read_bake_file(blob_file);
2045 nmd->
runtime = MEM_new<NodesModifierRuntime>(__func__);
2046 nmd->
runtime->
cache = std::make_shared<bake::ModifierCache>();
2060 if (
bake.directory) {
2063 if (
bake.data_blocks) {
2064 bake.data_blocks = MEM_dupalloc(
bake.data_blocks);
2079 tnmd->
runtime = MEM_new<NodesModifierRuntime>(__func__);
2088 tnmd->
runtime->
cache = std::make_shared<bake::ModifierCache>();
2104 const int bake_files_num) {
2108 *bake_files = MEM_dupalloc(*bake_files);
2111 if (bake_file.packed_file) {
2124 MEM_SAFE_DELETE(file.name);
2125 if (file.packed_file) {
2129 MEM_SAFE_DELETE(files);
2133 MEM_SAFE_DELETE(packed_bake);
2138 MEM_SAFE_DELETE(
bake->directory);
2144 MEM_SAFE_DELETE(
bake->data_blocks);
2157 MEM_SAFE_DELETE(nmd->
bakes);
2173 N_(
"GeometryNodes"),
2174 "NodesModifierData",
2182 ICON_GEOMETRY_NODES,
CustomData interface, see also DNA_customdata_types.h.
#define IDP_BlendDataRead(reader, prop)
#define GEO_NODE_SIMULATION_OUTPUT
General operations, lookup, etc. for blender objects.
General operations for point clouds.
#define BLI_SCOPED_DEFER(function_to_defer)
#define BLO_read_struct(reader, struct_name, ptr_p)
Object groups, one object can be in many groups at once.
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define MEM_realloc_zeroed(vmemh, len)
#define CD_MASK_MDEFORMVERT
uint64_t hash_or_fallback(const void *value, uint64_t fallback_hash) const
const ComputeContext * parent() const
const ComputeContextHash & hash() const
constexpr int64_t first() const
constexpr int64_t last(const int64_t n=0) const
SubIterator begin() const
bool add_overwrite(const Key &key, const Value &value)
ValueIterator values() const &
bool add(const Key &key, const Value &value)
const Value & lookup(const Key &key) const
Value lookup_default(const Key &key, const Value &default_value) const
Value & lookup_or_add_cb(const Key &key, const CreateValueF &create_value)
KeyIterator keys() const &
bool contains(const Key &key) const
Value & lookup_or_add(const Key &key, const Value &value)
ID * lookup_or_remember_missing(const bake::BakeDataBlockID &key) override
Map< bake::BakeDataBlockID, ID * > old_mappings
Map< bake::BakeDataBlockID, ID * > new_mappings
void try_add(ID &id) override
NodesModifierBakeParams(NodesModifierData &nmd, const ModifierEvalContext &ctx)
Map< int, std::unique_ptr< DataPerNode > > data_by_node_id
nodes::BakeNodeBehavior * get(const int id) const override
NodesModifierSimulationParams(NodesModifierData &nmd, const ModifierEvalContext &ctx)
void input_pass_through(nodes::SimulationZoneBehavior &zone_behavior) const
void output_store_frame_cache(bake::SimulationNodeCache &node_cache, nodes::SimulationZoneBehavior &zone_behavior) const
void store_as_prev_items(bake::SimulationNodeCache &node_cache, nodes::SimulationZoneBehavior &zone_behavior) const
void read_single(const int frame_index, bake::SimulationNodeCache &node_cache, nodes::SimulationZoneBehavior &zone_behavior) const
void reset_invalid_node_bakes()
void read_interpolated(const int prev_frame_index, const int next_frame_index, bake::SimulationNodeCache &node_cache, nodes::SimulationZoneBehavior &zone_behavior) const
void read_from_cache(const BakeFrameIndices &frame_indices, bake::SimulationNodeCache &node_cache, nodes::SimulationZoneBehavior &zone_behavior) const
void output_pass_through(nodes::SimulationZoneBehavior &zone_behavior) const
Map< int, std::unique_ptr< DataPerZone > > data_by_zone_id
nodes::SimulationZoneBehavior * get(const int zone_id) const override
void init_simulation_info(const int zone_id, nodes::SimulationZoneBehavior &zone_behavior, NodesModifierBakeDataBlockMap &data_block_map) const
Array< nodes::socket_usage_inference::SocketUsage > outputs
void ensure(const Object &object, const NodesModifierData &nmd)
Array< nodes::socket_usage_inference::SocketUsage > inputs
bool contains(const Key &key) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
void append(const T &value)
IndexRange index_range() const
void extend(Span< T > array)
Span< T > as_span() const
const GeometryNodesModifierComputeContext & for_geometry_nodes_modifier(const ComputeContext *parent, const NodesModifierData &nmd)
const GroupNodeComputeContext & for_group_node(const ComputeContext *parent, int32_t node_id, const bNodeTree *tree=nullptr)
const DataBlockComputeContext & for_data_block(const ComputeContext *parent, const uint32_t orig_session_uid, const ID *id=nullptr)
void ensure_owns_direct_data() override
bNodeTreeZone * parent_zone
std::optional< int > output_node_id
const bNodeTreeZone * get_zone_by_node(const int32_t node_id) const
bool is_primitive_value() const
const void * get_primitive_ptr() const
static Map< const bke::bNodeTreeZone *, ComputeContextHash > get_context_hash_by_zone_for_node_editor(const SpaceNode &snode, bke::ComputeContextCache &compute_context_cache)
int64_t first_if(const Range &range, Predicate &&predicate)
std::optional< BakePath > get_node_bake_path(const Main &bmain, const Object &object, const NodesModifierData &nmd, int node_id)
std::optional< IndexRange > get_node_bake_frame_range(const Scene &scene, const Object &object, const NodesModifierData &nmd, int node_id)
std::optional< BakeValues > deserialize_bake(std::istream &stream, const BlobReader &blob_reader, const BlobReadSharing &blob_sharing)
std::optional< SubFrame > file_name_to_frame(StringRef file_name)
Vector< MetaFile > find_sorted_meta_files(StringRefNull meta_dir)
std::unique_ptr< IDProperty, IDPropertyDeleter > create_group(StringRef prop_name, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_GROUP.
void add(Depsgraph &depsgraph, std::function< void()> fn)
bool node_editor_is_for_geometry_nodes_modifier(const SpaceNode &snode, const Object &object, const NodesModifierData &nmd)
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)
void foreach_active_gizmo_in_modifier(const Object &object, const NodesModifierData &nmd, const wmWindowManager &wm, bke::ComputeContextCache &compute_context_cache, const ForeachGizmoInModifierFn fn)
void foreach_compute_context_on_gizmo_path(const ComputeContext &gizmo_context, const bNode &gizmo_node, const bNodeSocket &gizmo_socket, FunctionRef< void(const ComputeContext &context)> fn)
void infer_group_interface_usage(const bNodeTree &group, const Span< InferenceValue > group_input_values, const MutableSpan< SocketUsage > r_input_usages, const std::optional< MutableSpan< SocketUsage > > r_output_usages)
Vector< InferenceValue > get_geometry_nodes_input_inference_values(const bNodeTree &btree, const PointerRNA &properties_ptr, ResourceScope &scope)
EvalDependencies gather_eval_dependencies_recursive(const bNodeTree &ntree)
const std::shared_ptr< const GeometryNodesLazyFunctionGraphInfo > & ensure_geometry_nodes_lazy_function_graph(const bNodeTree &btree)
void draw_geometry_nodes_modifier_ui(const bContext &C, PointerRNA *modifier_ptr, ui::Layout &layout)
bke::GeometrySet execute_geometry_nodes_on_geometry(const bNodeTree &btree, const PointerRNA &properties_ptr, const ComputeContext &base_compute_context, GeoNodesCallData &call_data, bke::GeometrySet input_geometry)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static bool logging_enabled(const ModifierEvalContext *ctx)
static void find_side_effect_nodes_for_baking(const NodesModifierData &nmd, const ModifierEvalContext &ctx, nodes::GeoNodesSideEffectNodes &r_side_effect_nodes)
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
void BKE_packedfile_blend_write(BlendWriter *writer, const PackedFile *pf)
unsigned __int64 uint64_t
@ NODES_MODIFIER_PANEL_WARNINGS
static void blend_write(BlendWriter *writer, const ID *, const ModifierData *md)
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void DEG_add_generic_id_relation(DepsNodeHandle *node_handle, ID *id, const char *description)
PackedFile * BKE_packedfile_duplicate(const PackedFile *pf_src)
bool DEG_is_active(const Depsgraph *depsgraph)
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
static void find_verbose_log_contexts(const NodesModifierData &nmd, const ModifierEvalContext &ctx, Set< ComputeContextHash > &r_socket_log_contexts)
static bool depends_on_time(Scene *, ModifierData *)
void nodes_modifier_packed_bake_copy(NodesModifierBake &bake_dst, const NodesModifierBake &bake_src)
@ OB_FLAG_USE_SIMULATION_CACHE
void IDP_BlendWrite(BlendWriter *writer, const IDProperty *prop)
void IDP_foreach_property(IDProperty *id_property_root, int type_filter, FunctionRef< void(IDProperty *id_property)> callback)
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
void MOD_nodes_update_interface(Main &bmain, Object *object, NodesModifierData *nmd)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
void BKE_packedfile_free(PackedFile *pf)
ID * DEG_get_evaluated_id(const Depsgraph *depsgraph, ID *id)
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
bScreen * BKE_workspace_active_screen_get(const WorkSpaceInstanceHook *hook) GETTER_ATTRS
ModifierTypeInfo modifierType_Nodes
void DEG_add_collection_geometry_relation(DepsNodeHandle *node_handle, Collection *collection, const char *description)
void DEG_add_depends_on_transform_relation(DepsNodeHandle *node_handle, const char *description)
static BakeFrameIndices get_bake_frame_indices(const Span< std::unique_ptr< bake::FrameCache > > frame_caches, const SubFrame frame)
@ LIB_ID_COPY_SET_COPIED_ON_WRITE
void DEG_add_node_tree_output_relation(DepsNodeHandle *node_handle, bNodeTree *node_tree, const char *description)
static void add_missing_data_block_mappings(NodesModifierBake &bake, const Span< bake::BakeDataBlockID > missing, FunctionRef< ID *(const bake::BakeDataBlockID &)> get_data_block)
WorkSpace * BKE_workspace_active_get(WorkSpaceInstanceHook *hook) GETTER_ATTRS
static void required_data_mask(ModifierData *, CustomData_MeshMasks *r_cddata_masks)
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
static void find_side_effect_nodes_for_viewer_path(const ViewerPath &viewer_path, const NodesModifierData &nmd, const ModifierEvalContext &ctx, nodes::GeoNodesSideEffectNodes &r_side_effect_nodes)
static void try_add_side_effect_node(const ModifierEvalContext &ctx, const ComputeContext &final_compute_context, const int final_node_id, const NodesModifierData &nmd, nodes::GeoNodesSideEffectNodes &r_side_effect_nodes)
void nodes_modifier_data_block_destruct(NodesModifierDataBlock *data_block, const bool do_id_user)
void nodes_modifier_bake_destruct(NodesModifierBake *bake, const bool do_id_user)
static const CustomData_MeshMasks dependency_data_mask
Main * DEG_get_bmain(const Depsgraph *graph)
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
static void free_data(ModifierData *md)
@ NODES_MODIFIER_BAKE_MODE_ANIMATION
@ NODES_MODIFIER_BAKE_MODE_STILL
static void find_dependencies_from_settings(const NodesModifierData &nmd, nodes::EvalDependencies &deps)
static void update_bakes_from_node_group(NodesModifierData &nmd)
static void panel_register(ARegionType *region_type)
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
static void add_data_block_items_writeback(const ModifierEvalContext &ctx, NodesModifierData &nmd_eval, NodesModifierData &nmd_orig, NodesModifierSimulationParams &simulation_params, NodesModifierBakeParams &bake_params)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
static Mesh * modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_AcceptsCVs
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsMesh
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
static void foreach_tex_link(ModifierData *md, Object *ob, TexWalkFunc walk, void *user_data)
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
static void find_side_effect_nodes_for_active_gizmos(const NodesModifierData &nmd, const ModifierEvalContext &ctx, const wmWindowManager &wm, nodes::GeoNodesSideEffectNodes &r_side_effect_nodes, Set< ComputeContextHash > &r_verbose_log_contexts)
static void modifyGeometry(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet &geometry_set)
static void blend_read(BlendDataReader *, ModifierData *md)
static void find_side_effect_nodes(const NodesModifierData &nmd, const ModifierEvalContext &ctx, nodes::GeoNodesSideEffectNodes &r_side_effect_nodes, Set< ComputeContextHash > &r_verbose_log_contexts)
T * DEG_get_original(T *id)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
static void remove_outdated_bake_caches(NodesModifierData &nmd)
static void update_system_properties(Main &bmain, Object &object, NodesModifierData &nmd)
void RNA_ensure_and_sync_system_properties(Main &bmain, PointerRNA &ptr, IDProperty &idprops)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
void DEG_add_collection_geometry_customdata_mask(DepsNodeHandle *node_handle, Collection *collection, const CustomData_MeshMasks *masks)
ID_Type GS(const char *name)
static void ensure_bake_loaded(bake::NodeBakeCache &bake_cache, bake::FrameCache &frame_cache)
Scene * DEG_get_input_scene(const Depsgraph *graph)
@ eModifierFlag_UserModified
bool DEG_object_has_geometry_component(Object *object)
static void find_side_effect_nodes_for_nested_node(const ModifierEvalContext &ctx, const NodesModifierData &nmd, const int root_nested_node_id, nodes::GeoNodesSideEffectNodes &r_side_effect_nodes)
static void panel_draw(const bContext *, Panel *panel)
static bool try_find_baked_data(const NodesModifierBake &bake, bake::NodeBakeCache &bake_cache, const Main &bmain, const Object &object, const NodesModifierData &nmd, const int id)
char * BLI_strdup_null(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_MALLOC
void BKE_packedfile_blend_read(BlendDataReader *reader, PackedFile **pf_p, StringRefNull filepath)
void DEG_add_scene_camera_relation(DepsNodeHandle *node_handle, Scene *scene, eDepsObjectComponentType component, const char *description)
@ DEG_SCENE_COMP_PARAMETERS
void nodes_modifier_packed_bake_free(NodesModifierPackedBake *packed_bake)
void DEG_add_scene_relation(DepsNodeHandle *node_handle, Scene *scene, eDepsSceneComponentType component, const char *description)
static bool is_disabled(const Scene *, ModifierData *md, bool)
bool DEG_is_evaluated(const T *id)
ModifierData * BKE_modifier_get_original(const Object *object, ModifierData *md)
void(*)(void *user_data, Object *ob, ModifierData *md, const PointerRNA *ptr, PropertyRNA *texture_prop) TexWalkFunc
float DEG_get_ctime(const Depsgraph *graph)
void DEG_add_vfont_relation(DepsNodeHandle *handle, VFont *vfont, const char *description)
static void add_object_relation(const ModifierUpdateDepsgraphContext *ctx, Object &object, const nodes::EvalDependencies::ObjectDependencyInfo &info)
static void add_collection_relation(const ModifierUpdateDepsgraphContext *ctx, Collection &collection)
void BLO_read_string(BlendDataReader *reader, char **ptr_p)
void * CustomData_add_layer(CustomData *data, eCustomDataType type, eCDAllocType alloctype, int totelem)
void DEG_add_customdata_mask(DepsNodeHandle *handle, Object *object, const CustomData_MeshMasks *masks)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
std::optional< int > current
std::optional< int > prev
std::optional< int > next
void write_string(const char *data)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_array(const int64_t array_size, const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
ListBaseT< wmWindowManager > wm
uint16_t layout_panel_open_flag
struct IDProperty * system_properties
NodesModifierBakeDataBlockMap data_block_map
nodes::BakeNodeBehavior behavior
NodesModifierDataBlock * data_blocks
NodesModifierPackedBake * packed
NodesModifierBakeMode bake_mode
NodesModifierBake * bakes
struct bNodeTree * node_group
struct NodesModifierSettings settings_legacy
NodesModifierRuntime * runtime
NodesModifierBakeFile * blob_files
NodesModifierBakeFile * meta_files
NodesModifierUsageInferenceCache usage_cache
std::shared_ptr< bke::bake::ModifierCache > cache
std::shared_ptr< nodes::eval_log::NodesEvalLog > eval_log
struct IDProperty * properties
nodes::SimulationZoneBehavior behavior
NodesModifierBakeDataBlockMap data_block_map
ListBaseT< SpaceLink > spacedata
struct bNodeTree * edittree
SpreadsheetTableIDGeometry geometry_id
ListBaseT< struct ScrArea > areabase
GeometryComponent & get_component_for_write(GeometryComponent::Type component_type)
static GeometrySet from_mesh(Mesh *mesh, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
const Mesh * get_mesh() const
Mesh * get_mesh_for_write()
std::optional< std::variant< std::string, Span< std::byte > > > meta_data_source
Map< int, std::unique_ptr< SimulationNodeCache > > simulation_cache_by_id
Map< int, std::unique_ptr< BakeNodeCache > > bake_cache_by_id
Set< int > requested_bakes
std::unique_ptr< MemoryBlobReader > memory_blob_reader
Vector< std::unique_ptr< FrameCache > > frames
std::unique_ptr< BlobReadSharing > blob_sharing
std::optional< std::string > blobs_dir
std::optional< PrevCache > prev_cache
sim_output::Behavior behavior
bool needs_scene_render_params
Map< uint32_t, ID * > ids
Map< uint32_t, ObjectDependencyInfo > objects_info
void add_generic_id_full(ID *id)
const Set< ComputeContextHash > * verbose_log_contexts
GeoNodesSimulationParams * simulation_params
GeoNodesModifierData * modifier_data
GeoNodesBakeParams * bake_params
eval_log::NodesEvalLog * eval_log
const GeoNodesSideEffectNodes * side_effect_nodes
const Object * self_object
MultiValueMap< std::pair< ComputeContextHash, int32_t >, int > iterations_by_iteration_zone
MultiValueMap< ComputeContextHash, const lf::FunctionNode * > nodes_by_context
Map< int, const lf::FunctionNode * > possible_side_effect_node_map
Map< int, const lf::FunctionNode * > zone_node_map
Map< int, const lf::FunctionNode * > group_node_map
GeometryNodeLazyFunctionGraphMapping mapping
sim_output::Behavior output
sim_input::Behavior input
bke::bake::BakeValues values
std::function< void(bke::bake::BakeValues values)> store_fn
struct WorkSpaceInstanceHook * workspace_hook