From 311ca3e6af1d761ab6c5944ae82d2460145e303d Mon Sep 17 00:00:00 2001 From: Jacques Lucke Date: Mon, 22 Jan 2024 13:47:13 +0100 Subject: [PATCH] Core: rename Session UUID to Session UID `UUID` generally stands for "universally unique identifier". The session identifier that we use is neither universally unique, nor does it follow the standard. Therefor, the term "session uuid" is confusing and should be replaced. In #116888 we briefly talked about a better name and ended up with "session uid". The reason for "uid" instead of "id" is that the latter is a very overloaded term in Blender already. This patch changes all uses of "uuid" to "uid" where it's used in the context of a "session uid". It's not always trivial to see whether a specific mention of "uuid" refers to an actual uuid or something else. Therefore, I might have missed some renames. I can't think of an automated way to differentiate the case. BMesh also uses the term "uuid" sometimes in a the wrong context (e.g. `UUIDFaceStepItem`) but there it also does not mean "session uid", so it's *not* changed by this patch. Pull Request: https://projects.blender.org/blender/blender/pulls/117350 --- source/blender/CMakeLists.txt | 2 +- .../asset_system/intern/asset_storage.hh | 2 +- source/blender/blenkernel/BKE_action.h | 4 +- .../blenkernel/BKE_compute_contexts.hh | 2 +- source/blender/blenkernel/BKE_global.h | 4 +- source/blender/blenkernel/BKE_idtype.hh | 4 +- source/blender/blenkernel/BKE_lib_id.hh | 18 ++-- source/blender/blenkernel/BKE_main.hh | 10 +- source/blender/blenkernel/BKE_main_idmap.hh | 4 +- source/blender/blenkernel/BKE_modifier.hh | 8 +- source/blender/blenkernel/BKE_object.hh | 2 +- source/blender/blenkernel/intern/action.cc | 36 ++++---- source/blender/blenkernel/intern/blendfile.cc | 4 +- source/blender/blenkernel/intern/idtype.cc | 4 +- source/blender/blenkernel/intern/image.cc | 2 +- source/blender/blenkernel/intern/lib_id.cc | 36 ++++---- source/blender/blenkernel/intern/main.cc | 18 ++-- .../blender/blenkernel/intern/main_idmap.cc | 38 ++++---- source/blender/blenkernel/intern/modifier.cc | 48 +++++----- source/blender/blenkernel/intern/movieclip.cc | 2 +- source/blender/blenkernel/intern/node.cc | 2 +- source/blender/blenkernel/intern/object.cc | 6 +- .../blender/blenkernel/intern/object_dupli.cc | 2 +- source/blender/blenkernel/intern/scene.cc | 10 +- source/blender/blenkernel/intern/sound.cc | 2 +- source/blender/blenkernel/intern/volume.cc | 2 +- source/blender/blenlib/BLI_session_uid.h | 64 +++++++++++++ source/blender/blenlib/BLI_session_uuid.h | 64 ------------- source/blender/blenlib/BLI_uuid.h | 2 +- source/blender/blenlib/CMakeLists.txt | 6 +- source/blender/blenlib/intern/session_uid.c | 66 +++++++++++++ source/blender/blenlib/intern/session_uuid.c | 66 ------------- .../blenlib/tests/BLI_session_uid_test.cc | 22 +++++ .../blenlib/tests/BLI_session_uuid_test.cc | 22 ----- source/blender/blenloader/BLO_read_write.hh | 6 +- source/blender/blenloader/BLO_undofile.hh | 10 +- source/blender/blenloader/intern/readfile.cc | 92 +++++++++---------- source/blender/blenloader/intern/readfile.hh | 8 +- source/blender/blenloader/intern/undofile.cc | 14 +-- .../blenloader/intern/versioning_250.cc | 2 +- source/blender/blenloader/intern/writefile.cc | 16 ++-- .../intern/builder/deg_builder_nodes.cc | 8 +- .../intern/builder/deg_builder_nodes.h | 2 +- .../intern/eval/deg_eval_copy_on_write.cc | 8 +- .../eval/deg_eval_runtime_backup_object.cc | 22 ++--- .../eval/deg_eval_runtime_backup_object.h | 8 +- .../eval/deg_eval_runtime_backup_sequencer.cc | 12 +-- .../eval/deg_eval_runtime_backup_sequencer.h | 6 +- .../depsgraph/intern/node/deg_node_id.cc | 2 +- .../depsgraph/intern/node/deg_node_id.hh | 2 +- .../editors/geometry/node_group_operator.cc | 2 +- .../editors/interface/interface_dropboxes.cc | 2 +- .../editors/interface/interface_ops.cc | 2 +- source/blender/editors/mesh/editmesh_undo.cc | 10 +- .../editors/object/add_modifier_assets.cc | 2 +- source/blender/editors/object/object_add.cc | 13 ++- .../editors/object/object_bake_simulation.cc | 4 +- .../editors/object/object_relations.cc | 42 ++++----- source/blender/editors/space_node/node_add.cc | 10 +- .../blender/editors/space_node/space_node.cc | 6 +- .../editors/space_outliner/outliner_draw.cc | 4 +- .../editors/space_outliner/outliner_tools.cc | 18 ++-- .../space_sequencer/sequencer_clipboard.cc | 2 +- .../editors/space_sequencer/sequencer_edit.cc | 6 +- .../editors/space_view3d/space_view3d.cc | 12 +-- .../editors/space_view3d/view3d_edit.cc | 2 +- source/blender/editors/undo/memfile_undo.cc | 2 +- source/blender/makesdna/DNA_ID.h | 6 +- source/blender/makesdna/DNA_action_types.h | 4 +- source/blender/makesdna/DNA_mesh_types.h | 2 +- source/blender/makesdna/DNA_modifier_types.h | 4 +- source/blender/makesdna/DNA_sequence_types.h | 6 +- ...n_uuid_types.h => DNA_session_uid_types.h} | 6 +- source/blender/makesrna/intern/rna_ID.cc | 1 - source/blender/modifiers/intern/MOD_nodes.cc | 4 +- source/blender/sequencer/SEQ_relations.hh | 8 +- source/blender/sequencer/intern/proxy.cc | 6 +- source/blender/sequencer/intern/sequencer.cc | 8 +- .../sequencer/intern/strip_relations.cc | 32 +++---- source/blender/windowmanager/WM_api.hh | 22 ++--- .../windowmanager/intern/wm_dragdrop.cc | 4 +- .../windowmanager/intern/wm_operator_props.cc | 29 +++--- .../windowmanager/intern/wm_operators.cc | 2 +- source/creator/creator_args.cc | 10 +- 84 files changed, 546 insertions(+), 549 deletions(-) create mode 100644 source/blender/blenlib/BLI_session_uid.h delete mode 100644 source/blender/blenlib/BLI_session_uuid.h create mode 100644 source/blender/blenlib/intern/session_uid.c delete mode 100644 source/blender/blenlib/intern/session_uuid.c create mode 100644 source/blender/blenlib/tests/BLI_session_uid_test.cc delete mode 100644 source/blender/blenlib/tests/BLI_session_uuid_test.cc rename source/blender/makesdna/{DNA_session_uuid_types.h => DNA_session_uid_types.h} (92%) diff --git a/source/blender/CMakeLists.txt b/source/blender/CMakeLists.txt index b6aa0d1d8b8..593897d4a43 100644 --- a/source/blender/CMakeLists.txt +++ b/source/blender/CMakeLists.txt @@ -69,7 +69,7 @@ set(SRC_DNA_INC ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_screen_types.h ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sdna_types.h ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sequence_types.h - ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_session_uuid_types.h + ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_session_uid_types.h ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_shader_fx_types.h ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sound_types.h ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_space_types.h diff --git a/source/blender/asset_system/intern/asset_storage.hh b/source/blender/asset_system/intern/asset_storage.hh index 89a7247b2e0..91de06703fe 100644 --- a/source/blender/asset_system/intern/asset_storage.hh +++ b/source/blender/asset_system/intern/asset_storage.hh @@ -29,7 +29,7 @@ class AssetStorage { StorageT external_assets_; /* Store local ID assets separately for efficient lookups. - * TODO(Julian): A [ID *, asset] or even [ID.session_uuid, asset] map would be preferable for + * TODO(Julian): A [ID *, asset] or even [ID.session_uid, asset] map would be preferable for * faster lookups. Not possible until each asset is only represented once in the storage. */ StorageT local_id_assets_; diff --git a/source/blender/blenkernel/BKE_action.h b/source/blender/blenkernel/BKE_action.h index 86d48394274..fb8dfea95c0 100644 --- a/source/blender/blenkernel/BKE_action.h +++ b/source/blender/blenkernel/BKE_action.h @@ -260,7 +260,7 @@ void BKE_pose_copy_data(struct bPose **dst, const struct bPose *src, bool copy_c * \note use when copying bones in edit-mode (on returned value from #BKE_pose_channel_ensure) */ void BKE_pose_channel_copy_data(struct bPoseChannel *pchan, const struct bPoseChannel *pchan_from); -void BKE_pose_channel_session_uuid_generate(struct bPoseChannel *pchan); +void BKE_pose_channel_session_uid_generate(struct bPoseChannel *pchan); /** * Return a pointer to the pose channel of the given name * from this pose. @@ -316,7 +316,7 @@ struct bPoseChannel *BKE_pose_channel_ensure(struct bPose *pose, const char *nam struct bPoseChannel *BKE_pose_channel_get_mirrored(const struct bPose *pose, const char *name) ATTR_WARN_UNUSED_RESULT; -void BKE_pose_check_uuids_unique_and_report(const struct bPose *pose); +void BKE_pose_check_uids_unique_and_report(const struct bPose *pose); #ifndef NDEBUG bool BKE_pose_channels_is_valid(const struct bPose *pose) ATTR_WARN_UNUSED_RESULT; diff --git a/source/blender/blenkernel/BKE_compute_contexts.hh b/source/blender/blenkernel/BKE_compute_contexts.hh index c019aa58ced..f724133e51f 100644 --- a/source/blender/blenkernel/BKE_compute_contexts.hh +++ b/source/blender/blenkernel/BKE_compute_contexts.hh @@ -22,7 +22,7 @@ class ModifierComputeContext : public ComputeContext { static constexpr const char *s_static_type = "MODIFIER"; /** - * Use modifier name instead of something like `session_uuid` for now because: + * Use modifier name instead of something like `session_uid` for now because: * - It's more obvious that the name matches between the original and evaluated object. * - We might want that the context hash is consistent between sessions in the future. */ diff --git a/source/blender/blenkernel/BKE_global.h b/source/blender/blenkernel/BKE_global.h index 17b5621f14d..21dfe283244 100644 --- a/source/blender/blenkernel/BKE_global.h +++ b/source/blender/blenkernel/BKE_global.h @@ -208,10 +208,10 @@ enum { G_DEBUG_DEPSGRAPH_TIME = (1 << 11), /* depsgraph timing statistics and messages */ G_DEBUG_DEPSGRAPH_NO_THREADS = (1 << 12), /* single threaded depsgraph */ G_DEBUG_DEPSGRAPH_PRETTY = (1 << 13), /* use pretty colors in depsgraph messages */ - G_DEBUG_DEPSGRAPH_UUID = (1 << 14), /* Verify validness of session-wide identifiers + G_DEBUG_DEPSGRAPH_UID = (1 << 14), /* Verify validness of session-wide identifiers * assigned to ID datablocks */ G_DEBUG_DEPSGRAPH = (G_DEBUG_DEPSGRAPH_BUILD | G_DEBUG_DEPSGRAPH_EVAL | G_DEBUG_DEPSGRAPH_TAG | - G_DEBUG_DEPSGRAPH_TIME | G_DEBUG_DEPSGRAPH_UUID), + G_DEBUG_DEPSGRAPH_TIME | G_DEBUG_DEPSGRAPH_UID), G_DEBUG_SIMDATA = (1 << 15), /* sim debug data display */ G_DEBUG_GPU = (1 << 16), /* gpu debug */ G_DEBUG_IO = (1 << 17), /* IO Debugging (for Collada, ...). */ diff --git a/source/blender/blenkernel/BKE_idtype.hh b/source/blender/blenkernel/BKE_idtype.hh index 79646edea57..6c34de86ade 100644 --- a/source/blender/blenkernel/BKE_idtype.hh +++ b/source/blender/blenkernel/BKE_idtype.hh @@ -48,8 +48,8 @@ enum { }; struct IDCacheKey { - /* The session UUID of the ID owning the cached data. */ - unsigned int id_session_uuid; + /* The session UID of the ID owning the cached data. */ + unsigned int id_session_uid; /* Value uniquely identifying the cache within its ID. * Typically the offset of its member in the data-block struct, but can be anything. */ size_t identifier; diff --git a/source/blender/blenkernel/BKE_lib_id.hh b/source/blender/blenkernel/BKE_lib_id.hh index 13f7e1fe74b..8625c40d3de 100644 --- a/source/blender/blenkernel/BKE_lib_id.hh +++ b/source/blender/blenkernel/BKE_lib_id.hh @@ -73,29 +73,29 @@ void BKE_libblock_init_empty(ID *id) ATTR_NONNULL(1); */ void BKE_libblock_runtime_reset_remapping_status(ID *id) ATTR_NONNULL(1); -/* *** ID's session_uuid management. *** */ +/* *** ID's session_uid management. *** */ /** - * When an ID's UUID is of that value, it is unset/invalid (e.g. for runtime IDs, etc.). + * When an ID's UID is of that value, it is unset/invalid (e.g. for runtime IDs, etc.). */ -#define MAIN_ID_SESSION_UUID_UNSET 0 +#define MAIN_ID_SESSION_UID_UNSET 0 /** - * Generate a session-wise UUID for the given \a id. + * Generate a session-wise UID for the given \a id. * * \note "session-wise" here means while editing a given .blend file. Once a new .blend file is - * loaded or created, undo history is cleared/reset, and so is the UUID counter. + * loaded or created, undo history is cleared/reset, and so is the UID counter. */ -void BKE_lib_libblock_session_uuid_ensure(ID *id); +void BKE_lib_libblock_session_uid_ensure(ID *id); /** - * Re-generate a new session-wise UUID for the given \a id. + * Re-generate a new session-wise UID for the given \a id. * * \warning This has a few very specific use-cases, no other usage is expected currently: * - To handle UI-related data-blocks that are kept across new file reading, when we do keep * existing UI. * - For IDs that are made local without needing any copying. */ -void BKE_lib_libblock_session_uuid_renew(ID *id); +void BKE_lib_libblock_session_uid_renew(ID *id); /** * Generic helper to create a new empty data-block of given type in given \a bmain database. @@ -203,7 +203,7 @@ void BKE_libblock_ensure_unique_name(Main *bmain, ID *id) ATTR_NONNULL(); ID *BKE_libblock_find_name(Main *bmain, short type, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(); -ID *BKE_libblock_find_session_uuid(Main *bmain, short type, uint32_t session_uuid); +ID *BKE_libblock_find_session_uid(Main *bmain, short type, uint32_t session_uid); /** * Duplicate (a.k.a. deep copy) common processing options. * See also eDupli_ID_Flags for options controlling what kind of IDs to duplicate. diff --git a/source/blender/blenkernel/BKE_main.hh b/source/blender/blenkernel/BKE_main.hh index 174eb7dec05..f7a25b9e7c5 100644 --- a/source/blender/blenkernel/BKE_main.hh +++ b/source/blender/blenkernel/BKE_main.hh @@ -55,8 +55,8 @@ struct MainIDRelationsEntryItem { /* For `to_ids` list, an ID used by the hashed ID. */ struct ID **to; } id_pointer; - /* Session uuid of the `id_pointer`. */ - uint session_uuid; + /* Session uid of the `id_pointer`. */ + uint session_uid; int usage_flag; /* Using IDWALK_ enums, defined in BKE_lib_query.hh */ }; @@ -67,8 +67,8 @@ struct MainIDRelationsEntry { /* Linked list of IDs used by that ID. */ struct MainIDRelationsEntryItem *to_ids; - /* Session uuid of the ID matching that entry. */ - uint session_uuid; + /* Session uid of the ID matching that entry. */ + uint session_uid; /* Runtime tags, users should ensure those are reset after usage. */ uint tags; @@ -105,7 +105,7 @@ struct MainIDRelations { /* Mapping from an ID pointer to all of its parents (IDs using it) and children (IDs it uses). * Values are `MainIDRelationsEntry` pointers. */ struct GHash *relations_from_pointers; - /* NOTE: we could add more mappings when needed (e.g. from session uuid?). */ + /* NOTE: we could add more mappings when needed (e.g. from session uid?). */ short flag; diff --git a/source/blender/blenkernel/BKE_main_idmap.hh b/source/blender/blenkernel/BKE_main_idmap.hh index 92d4a167efb..91146da8b14 100644 --- a/source/blender/blenkernel/BKE_main_idmap.hh +++ b/source/blender/blenkernel/BKE_main_idmap.hh @@ -25,7 +25,7 @@ struct Main; enum { MAIN_IDMAP_TYPE_NAME = 1 << 0, - MAIN_IDMAP_TYPE_UUID = 1 << 1, + MAIN_IDMAP_TYPE_UID = 1 << 1, }; /** @@ -57,5 +57,5 @@ ID *BKE_main_idmap_lookup_name(IDNameLib_Map *id_map, ID *BKE_main_idmap_lookup_id(IDNameLib_Map *id_map, const ID *id) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 2); -ID *BKE_main_idmap_lookup_uuid(IDNameLib_Map *id_map, uint session_uuid) ATTR_WARN_UNUSED_RESULT +ID *BKE_main_idmap_lookup_uid(IDNameLib_Map *id_map, uint session_uid) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1); diff --git a/source/blender/blenkernel/BKE_modifier.hh b/source/blender/blenkernel/BKE_modifier.hh index 6f22690218d..e4379f5f4df 100644 --- a/source/blender/blenkernel/BKE_modifier.hh +++ b/source/blender/blenkernel/BKE_modifier.hh @@ -421,8 +421,8 @@ void BKE_modifier_free(ModifierData *md); */ void BKE_modifier_remove_from_list(Object *ob, ModifierData *md); -/* Generate new UUID for the given modifier. */ -void BKE_modifier_session_uuid_generate(ModifierData *md); +/* Generate new UID for the given modifier. */ +void BKE_modifier_session_uid_generate(ModifierData *md); void BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md); @@ -472,7 +472,7 @@ void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *user_dat ModifierData *BKE_modifiers_findby_type(const Object *ob, ModifierType type); ModifierData *BKE_modifiers_findby_name(const Object *ob, const char *name); -ModifierData *BKE_modifiers_findby_session_uuid(const Object *ob, const SessionUUID *session_uuid); +ModifierData *BKE_modifiers_findby_session_uid(const Object *ob, const SessionUID *session_uid); void BKE_modifiers_clear_errors(Object *ob); /** * used for buttons, to find out if the 'draw deformed in edit-mode option is there. @@ -584,7 +584,7 @@ void BKE_modifier_deform_vertsEM(ModifierData *md, */ Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval); -void BKE_modifier_check_uuids_unique_and_report(const Object *object); +void BKE_modifier_check_uids_unique_and_report(const Object *object); void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBase *modbase); void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb, Object *ob); diff --git a/source/blender/blenkernel/BKE_object.hh b/source/blender/blenkernel/BKE_object.hh index 493bf63b354..48f4056556c 100644 --- a/source/blender/blenkernel/BKE_object.hh +++ b/source/blender/blenkernel/BKE_object.hh @@ -685,7 +685,7 @@ Curve *BKE_object_to_curve(Object *object, Depsgraph *depsgraph, bool apply_modi void BKE_object_to_curve_clear(Object *object); -void BKE_object_check_uuids_unique_and_report(const Object *object); +void BKE_object_check_uids_unique_and_report(const Object *object); /** * Return the last subsurf modifier of an object, this does not check whether modifiers on top of diff --git a/source/blender/blenkernel/intern/action.cc b/source/blender/blenkernel/intern/action.cc index 8098d4d260e..d16df153cac 100644 --- a/source/blender/blenkernel/intern/action.cc +++ b/source/blender/blenkernel/intern/action.cc @@ -28,7 +28,7 @@ #include "BLI_math_matrix.h" #include "BLI_math_rotation.h" #include "BLI_math_vector.h" -#include "BLI_session_uuid.h" +#include "BLI_session_uid.h" #include "BLI_string_utils.hh" #include "BLI_utildefines.h" @@ -593,9 +593,9 @@ void action_groups_clear_tempflags(bAction *act) /* *************** Pose channels *************** */ -void BKE_pose_channel_session_uuid_generate(bPoseChannel *pchan) +void BKE_pose_channel_session_uid_generate(bPoseChannel *pchan) { - pchan->runtime.session_uuid = BLI_session_uuid_generate(); + pchan->runtime.session_uid = BLI_session_uid_generate(); } bPoseChannel *BKE_pose_channel_find_name(const bPose *pose, const char *name) @@ -629,7 +629,7 @@ bPoseChannel *BKE_pose_channel_ensure(bPose *pose, const char *name) /* If not, create it and add it */ chan = static_cast(MEM_callocN(sizeof(bPoseChannel), "verifyPoseChannel")); - BKE_pose_channel_session_uuid_generate(chan); + BKE_pose_channel_session_uid_generate(chan); STRNCPY(chan->name, name); @@ -793,7 +793,7 @@ void BKE_pose_copy_data_ex(bPose **dst, } if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { - BKE_pose_channel_session_uuid_generate(pchan); + BKE_pose_channel_session_uid_generate(pchan); } /* warning, O(n2) here, if done without the hash, but these are rarely used features. */ @@ -1033,9 +1033,9 @@ void BKE_pose_channel_runtime_reset(bPoseChannel_Runtime *runtime) void BKE_pose_channel_runtime_reset_on_copy(bPoseChannel_Runtime *runtime) { - const SessionUUID uuid = runtime->session_uuid; + const SessionUID uid = runtime->session_uid; memset(runtime, 0, sizeof(*runtime)); - runtime->session_uuid = uuid; + runtime->session_uid = uid; } void BKE_pose_channel_runtime_free(bPoseChannel_Runtime *runtime) @@ -1778,31 +1778,31 @@ void what_does_obaction(Object *ob, } } -void BKE_pose_check_uuids_unique_and_report(const bPose *pose) +void BKE_pose_check_uids_unique_and_report(const bPose *pose) { if (pose == nullptr) { return; } - GSet *used_uuids = BLI_gset_new( - BLI_session_uuid_ghash_hash, BLI_session_uuid_ghash_compare, "sequencer used uuids"); + GSet *used_uids = BLI_gset_new( + BLI_session_uid_ghash_hash, BLI_session_uid_ghash_compare, "sequencer used uids"); LISTBASE_FOREACH (bPoseChannel *, pchan, &pose->chanbase) { - const SessionUUID *session_uuid = &pchan->runtime.session_uuid; - if (!BLI_session_uuid_is_generated(session_uuid)) { - printf("Pose channel %s does not have UUID generated.\n", pchan->name); + const SessionUID *session_uid = &pchan->runtime.session_uid; + if (!BLI_session_uid_is_generated(session_uid)) { + printf("Pose channel %s does not have UID generated.\n", pchan->name); continue; } - if (BLI_gset_lookup(used_uuids, session_uuid) != nullptr) { - printf("Pose channel %s has duplicate UUID generated.\n", pchan->name); + if (BLI_gset_lookup(used_uids, session_uid) != nullptr) { + printf("Pose channel %s has duplicate UID generated.\n", pchan->name); continue; } - BLI_gset_insert(used_uuids, (void *)session_uuid); + BLI_gset_insert(used_uids, (void *)session_uid); } - BLI_gset_free(used_uuids, nullptr); + BLI_gset_free(used_uids, nullptr); } void BKE_pose_blend_write(BlendWriter *writer, bPose *pose, bArmature *arm) @@ -1868,7 +1868,7 @@ void BKE_pose_blend_read_data(BlendDataReader *reader, ID *id_owner, bPose *pose LISTBASE_FOREACH (bPoseChannel *, pchan, &pose->chanbase) { BKE_pose_channel_runtime_reset(&pchan->runtime); - BKE_pose_channel_session_uuid_generate(pchan); + BKE_pose_channel_session_uid_generate(pchan); pchan->bone = nullptr; BLO_read_data_address(reader, &pchan->parent); diff --git a/source/blender/blenkernel/intern/blendfile.cc b/source/blender/blenkernel/intern/blendfile.cc index 10de3a1df53..8bc9f97495b 100644 --- a/source/blender/blenkernel/intern/blendfile.cc +++ b/source/blender/blenkernel/intern/blendfile.cc @@ -373,8 +373,8 @@ static void swap_old_bmain_data_for_blendfile(ReuseOldBMainData *reuse_data, con } FOREACH_MAIN_LISTBASE_ID_BEGIN (new_lb, reused_id_iter) { - /* Necessary as all `session_uuid` are renewed on blendfile loading. */ - BKE_lib_libblock_session_uuid_renew(reused_id_iter); + /* Necessary as all `session_uid` are renewed on blendfile loading. */ + BKE_lib_libblock_session_uid_renew(reused_id_iter); /* Ensure that the reused ID is remapped to itself, since it is known to be in the `new_bmain`. */ diff --git a/source/blender/blenkernel/intern/idtype.cc b/source/blender/blenkernel/intern/idtype.cc index 40618cb8e9c..dc900d9dd37 100644 --- a/source/blender/blenkernel/intern/idtype.cc +++ b/source/blender/blenkernel/intern/idtype.cc @@ -32,7 +32,7 @@ uint BKE_idtype_cache_key_hash(const void *key_v) { const IDCacheKey *key = static_cast(key_v); - size_t hash = BLI_ghashutil_uinthash(key->id_session_uuid); + size_t hash = BLI_ghashutil_uinthash(key->id_session_uid); hash = BLI_ghashutil_combine_hash(hash, BLI_ghashutil_uinthash(uint(key->identifier))); return uint(hash); } @@ -41,7 +41,7 @@ bool BKE_idtype_cache_key_cmp(const void *key_a_v, const void *key_b_v) { const IDCacheKey *key_a = static_cast(key_a_v); const IDCacheKey *key_b = static_cast(key_b_v); - return (key_a->id_session_uuid != key_b->id_session_uuid) || + return (key_a->id_session_uid != key_b->id_session_uid) || (key_a->identifier != key_b->identifier); } diff --git a/source/blender/blenkernel/intern/image.cc b/source/blender/blenkernel/intern/image.cc index e8aa73d04ae..1dbb23f5718 100644 --- a/source/blender/blenkernel/intern/image.cc +++ b/source/blender/blenkernel/intern/image.cc @@ -235,7 +235,7 @@ static void image_foreach_cache(ID *id, { Image *image = (Image *)id; IDCacheKey key; - key.id_session_uuid = id->session_uuid; + key.id_session_uid = id->session_uid; key.identifier = offsetof(Image, cache); function_callback(id, &key, (void **)&image->cache, 0, user_data); diff --git a/source/blender/blenkernel/intern/lib_id.cc b/source/blender/blenkernel/intern/lib_id.cc index ffdd5f83771..25eb944fbef 100644 --- a/source/blender/blenkernel/intern/lib_id.cc +++ b/source/blender/blenkernel/intern/lib_id.cc @@ -206,9 +206,9 @@ void BKE_lib_id_clear_library_data(Main *bmain, ID *id, const int flags) } /* Conceptually, an ID made local is not the same as the linked one anymore. Reflect that by - * regenerating its session UUID. */ + * regenerating its session UID. */ if ((id->tag & LIB_TAG_TEMP_MAIN) == 0) { - BKE_lib_libblock_session_uuid_renew(id); + BKE_lib_libblock_session_uid_renew(id); } if (ID_IS_ASSET(id)) { @@ -1021,7 +1021,7 @@ void BKE_libblock_management_main_add(Main *bmain, void *idv) bmain->is_memfile_undo_written = false; BKE_main_unlock(bmain); - BKE_lib_libblock_session_uuid_ensure(id); + BKE_lib_libblock_session_uid_ensure(id); } void BKE_libblock_management_main_remove(Main *bmain, void *idv) @@ -1268,11 +1268,11 @@ void *BKE_libblock_alloc(Main *bmain, short type, const char *name, const int fl BLI_strncpy(id->name + 2, name, sizeof(id->name) - 2); } - /* We also need to ensure a valid `session_uuid` for some non-main data (like embedded IDs). + /* We also need to ensure a valid `session_uid` for some non-main data (like embedded IDs). * IDs not allocated however should not need those (this would e.g. avoid generating session - * uuids for depsgraph CoW IDs, if it was using this function). */ + * uids for depsgraph CoW IDs, if it was using this function). */ if ((flag & LIB_ID_CREATE_NO_ALLOCATE) == 0) { - BKE_lib_libblock_session_uuid_ensure(id); + BKE_lib_libblock_session_uid_ensure(id); } } @@ -1301,26 +1301,26 @@ void BKE_libblock_runtime_reset_remapping_status(ID *id) id->runtime.remap.skipped_indirect = 0; } -/* ********** ID session-wise UUID management. ********** */ -static uint global_session_uuid = 0; +/* ********** ID session-wise UID management. ********** */ +static uint global_session_uid = 0; -void BKE_lib_libblock_session_uuid_ensure(ID *id) +void BKE_lib_libblock_session_uid_ensure(ID *id) { - if (id->session_uuid == MAIN_ID_SESSION_UUID_UNSET) { + if (id->session_uid == MAIN_ID_SESSION_UID_UNSET) { BLI_assert((id->tag & LIB_TAG_TEMP_MAIN) == 0); /* Caller must ensure this. */ - id->session_uuid = atomic_add_and_fetch_uint32(&global_session_uuid, 1); + id->session_uid = atomic_add_and_fetch_uint32(&global_session_uid, 1); /* In case overflow happens, still assign a valid ID. This way opening files many times works * correctly. */ - if (UNLIKELY(id->session_uuid == MAIN_ID_SESSION_UUID_UNSET)) { - id->session_uuid = atomic_add_and_fetch_uint32(&global_session_uuid, 1); + if (UNLIKELY(id->session_uid == MAIN_ID_SESSION_UID_UNSET)) { + id->session_uid = atomic_add_and_fetch_uint32(&global_session_uid, 1); } } } -void BKE_lib_libblock_session_uuid_renew(ID *id) +void BKE_lib_libblock_session_uid_renew(ID *id) { - id->session_uuid = MAIN_ID_SESSION_UUID_UNSET; - BKE_lib_libblock_session_uuid_ensure(id); + id->session_uid = MAIN_ID_SESSION_UID_UNSET; + BKE_lib_libblock_session_uid_ensure(id); } void *BKE_id_new(Main *bmain, const short type, const char *name) @@ -1477,12 +1477,12 @@ ID *BKE_libblock_find_name(Main *bmain, const short type, const char *name) return static_cast(BLI_findstring(lb, name, offsetof(ID, name) + 2)); } -ID *BKE_libblock_find_session_uuid(Main *bmain, const short type, const uint32_t session_uuid) +ID *BKE_libblock_find_session_uid(Main *bmain, const short type, const uint32_t session_uid) { ListBase *lb = which_libbase(bmain, type); BLI_assert(lb != nullptr); LISTBASE_FOREACH (ID *, id, lb) { - if (id->session_uuid == session_uuid) { + if (id->session_uid == session_uid) { return id; } } diff --git a/source/blender/blenkernel/intern/main.cc b/source/blender/blenkernel/intern/main.cc index fb4a7574885..ae4d61fe5bb 100644 --- a/source/blender/blenkernel/intern/main.cc +++ b/source/blender/blenkernel/intern/main.cc @@ -470,17 +470,17 @@ static int main_relations_create_idlink_cb(LibraryIDLinkCallbackData *cb_data) bmain_relations->relations_from_pointers, self_id, (void ***)&entry_p)) { *entry_p = static_cast(MEM_callocN(sizeof(**entry_p), __func__)); - (*entry_p)->session_uuid = self_id->session_uuid; + (*entry_p)->session_uid = self_id->session_uid; } else { - BLI_assert((*entry_p)->session_uuid == self_id->session_uuid); + BLI_assert((*entry_p)->session_uid == self_id->session_uid); } MainIDRelationsEntryItem *to_id_entry = static_cast( BLI_mempool_alloc(bmain_relations->entry_items_pool)); to_id_entry->next = (*entry_p)->to_ids; to_id_entry->id_pointer.to = id_pointer; - to_id_entry->session_uuid = (*id_pointer != nullptr) ? (*id_pointer)->session_uuid : - MAIN_ID_SESSION_UUID_UNSET; + to_id_entry->session_uid = (*id_pointer != nullptr) ? (*id_pointer)->session_uid : + MAIN_ID_SESSION_UID_UNSET; to_id_entry->usage_flag = cb_flag; (*entry_p)->to_ids = to_id_entry; } @@ -491,16 +491,16 @@ static int main_relations_create_idlink_cb(LibraryIDLinkCallbackData *cb_data) bmain_relations->relations_from_pointers, *id_pointer, (void ***)&entry_p)) { *entry_p = static_cast(MEM_callocN(sizeof(**entry_p), __func__)); - (*entry_p)->session_uuid = (*id_pointer)->session_uuid; + (*entry_p)->session_uid = (*id_pointer)->session_uid; } else { - BLI_assert((*entry_p)->session_uuid == (*id_pointer)->session_uuid); + BLI_assert((*entry_p)->session_uid == (*id_pointer)->session_uid); } MainIDRelationsEntryItem *from_id_entry = static_cast( BLI_mempool_alloc(bmain_relations->entry_items_pool)); from_id_entry->next = (*entry_p)->from_ids; from_id_entry->id_pointer.from = self_id; - from_id_entry->session_uuid = self_id->session_uuid; + from_id_entry->session_uid = self_id->session_uid; from_id_entry->usage_flag = cb_flag; (*entry_p)->from_ids = from_id_entry; } @@ -533,10 +533,10 @@ void BKE_main_relations_create(Main *bmain, const short flag) MainIDRelationsEntry **entry_p; if (!BLI_ghash_ensure_p(bmain->relations->relations_from_pointers, id, (void ***)&entry_p)) { *entry_p = static_cast(MEM_callocN(sizeof(**entry_p), __func__)); - (*entry_p)->session_uuid = id->session_uuid; + (*entry_p)->session_uid = id->session_uid; } else { - BLI_assert((*entry_p)->session_uuid == id->session_uuid); + BLI_assert((*entry_p)->session_uid == id->session_uid); } BKE_library_foreach_ID_link( diff --git a/source/blender/blenkernel/intern/main_idmap.cc b/source/blender/blenkernel/intern/main_idmap.cc index fe76f4c0597..8fd262ed4c7 100644 --- a/source/blender/blenkernel/intern/main_idmap.cc +++ b/source/blender/blenkernel/intern/main_idmap.cc @@ -54,7 +54,7 @@ struct IDNameLib_TypeMap { */ struct IDNameLib_Map { IDNameLib_TypeMap type_maps[INDEX_ID_MAX]; - GHash *uuid_map; + GHash *uid_map; Main *bmain; GSet *valid_id_pointers; int idmap_types; @@ -94,14 +94,14 @@ IDNameLib_Map *BKE_main_idmap_create(Main *bmain, BLI_assert(index == INDEX_ID_MAX); id_map->type_maps_keys_pool = nullptr; - if (idmap_types & MAIN_IDMAP_TYPE_UUID) { + if (idmap_types & MAIN_IDMAP_TYPE_UID) { ID *id; - id_map->uuid_map = BLI_ghash_int_new(__func__); + id_map->uid_map = BLI_ghash_int_new(__func__); FOREACH_MAIN_ID_BEGIN (bmain, id) { - BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET); + BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET); void **id_ptr_v; const bool existing_key = BLI_ghash_ensure_p( - id_map->uuid_map, POINTER_FROM_UINT(id->session_uuid), &id_ptr_v); + id_map->uid_map, POINTER_FROM_UINT(id->session_uid), &id_ptr_v); BLI_assert(existing_key == false); UNUSED_VARS_NDEBUG(existing_key); @@ -110,7 +110,7 @@ IDNameLib_Map *BKE_main_idmap_create(Main *bmain, FOREACH_MAIN_ID_END; } else { - id_map->uuid_map = nullptr; + id_map->uid_map = nullptr; } if (create_valid_ids_set) { @@ -144,12 +144,12 @@ void BKE_main_idmap_insert_id(IDNameLib_Map *id_map, ID *id) } } - if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) { - BLI_assert(id_map->uuid_map != nullptr); - BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET); + if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) { + BLI_assert(id_map->uid_map != nullptr); + BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET); void **id_ptr_v; const bool existing_key = BLI_ghash_ensure_p( - id_map->uuid_map, POINTER_FROM_UINT(id->session_uuid), &id_ptr_v); + id_map->uid_map, POINTER_FROM_UINT(id->session_uid), &id_ptr_v); BLI_assert(existing_key == false); UNUSED_VARS_NDEBUG(existing_key); @@ -174,11 +174,11 @@ void BKE_main_idmap_remove_id(IDNameLib_Map *id_map, ID *id) } } - if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) { - BLI_assert(id_map->uuid_map != nullptr); - BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET); + if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) { + BLI_assert(id_map->uid_map != nullptr); + BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET); - BLI_ghash_remove(id_map->uuid_map, POINTER_FROM_UINT(id->session_uuid), nullptr, nullptr); + BLI_ghash_remove(id_map->uid_map, POINTER_FROM_UINT(id->session_uid), nullptr, nullptr); } } @@ -251,10 +251,10 @@ ID *BKE_main_idmap_lookup_id(IDNameLib_Map *id_map, const ID *id) return nullptr; } -ID *BKE_main_idmap_lookup_uuid(IDNameLib_Map *id_map, const uint session_uuid) +ID *BKE_main_idmap_lookup_uid(IDNameLib_Map *id_map, const uint session_uid) { - if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) { - return static_cast(BLI_ghash_lookup(id_map->uuid_map, POINTER_FROM_UINT(session_uuid))); + if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) { + return static_cast(BLI_ghash_lookup(id_map->uid_map, POINTER_FROM_UINT(session_uid))); } return nullptr; } @@ -274,8 +274,8 @@ void BKE_main_idmap_destroy(IDNameLib_Map *id_map) id_map->type_maps_keys_pool = nullptr; } } - if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) { - BLI_ghash_free(id_map->uuid_map, nullptr, nullptr); + if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) { + BLI_ghash_free(id_map->uid_map, nullptr, nullptr); } BLI_assert(id_map->type_maps_keys_pool == nullptr); diff --git a/source/blender/blenkernel/intern/modifier.cc b/source/blender/blenkernel/intern/modifier.cc index 39380be89a6..40150b4d53b 100644 --- a/source/blender/blenkernel/intern/modifier.cc +++ b/source/blender/blenkernel/intern/modifier.cc @@ -36,7 +36,7 @@ #include "BLI_linklist.h" #include "BLI_listbase.h" #include "BLI_path_util.h" -#include "BLI_session_uuid.h" +#include "BLI_session_uid.h" #include "BLI_string.h" #include "BLI_string_utf8.h" #include "BLI_string_utils.hh" @@ -162,7 +162,7 @@ ModifierData *BKE_modifier_new(int type) { ModifierData *md = modifier_allocate_and_init(ModifierType(type)); - BKE_modifier_session_uuid_generate(md); + BKE_modifier_session_uid_generate(md); return md; } @@ -220,9 +220,9 @@ void BKE_modifier_remove_from_list(Object *ob, ModifierData *md) BLI_remlink(&ob->modifiers, md); } -void BKE_modifier_session_uuid_generate(ModifierData *md) +void BKE_modifier_session_uid_generate(ModifierData *md) { - md->session_uuid = BLI_session_uuid_generate(); + md->session_uid = BLI_session_uid_generate(); } void BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md) @@ -266,10 +266,10 @@ ModifierData *BKE_modifiers_findby_name(const Object *ob, const char *name) BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name))); } -ModifierData *BKE_modifiers_findby_session_uuid(const Object *ob, const SessionUUID *session_uuid) +ModifierData *BKE_modifiers_findby_session_uid(const Object *ob, const SessionUID *session_uid) { LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) { - if (BLI_session_uuid_is_equal(&md->session_uuid, session_uuid)) { + if (BLI_session_uid_is_equal(&md->session_uid, session_uid)) { return md; } } @@ -370,14 +370,14 @@ void BKE_modifier_copydata_ex(const ModifierData *md, ModifierData *target, cons } if (flag & LIB_ID_CREATE_NO_MAIN) { - /* Make sure UUID is the same between the source and the target. - * This is needed in the cases when UUID is to be preserved and when there is no copy_data + /* Make sure UID is the same between the source and the target. + * This is needed in the cases when UID is to be preserved and when there is no copy_data * callback, or the copy_data does not do full byte copy of the modifier data. */ - target->session_uuid = md->session_uuid; + target->session_uid = md->session_uid; } else { - /* In the case copy_data made full byte copy force UUID to be re-generated. */ - BKE_modifier_session_uuid_generate(target); + /* In the case copy_data made full byte copy force UID to be re-generated. */ + BKE_modifier_session_uid_generate(target); } } @@ -985,7 +985,7 @@ Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval) ModifierData *BKE_modifier_get_original(const Object *object, ModifierData *md) { const Object *object_orig = DEG_get_original_object((Object *)object); - return BKE_modifiers_findby_session_uuid(object_orig, &md->session_uuid); + return BKE_modifiers_findby_session_uid(object_orig, &md->session_uid); } ModifierData *BKE_modifier_get_evaluated(Depsgraph *depsgraph, Object *object, ModifierData *md) @@ -994,30 +994,30 @@ ModifierData *BKE_modifier_get_evaluated(Depsgraph *depsgraph, Object *object, M if (object_eval == object) { return md; } - return BKE_modifiers_findby_session_uuid(object_eval, &md->session_uuid); + return BKE_modifiers_findby_session_uid(object_eval, &md->session_uid); } -void BKE_modifier_check_uuids_unique_and_report(const Object *object) +void BKE_modifier_check_uids_unique_and_report(const Object *object) { - GSet *used_uuids = BLI_gset_new( - BLI_session_uuid_ghash_hash, BLI_session_uuid_ghash_compare, "modifier used uuids"); + GSet *used_uids = BLI_gset_new( + BLI_session_uid_ghash_hash, BLI_session_uid_ghash_compare, "modifier used uids"); LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) { - const SessionUUID *session_uuid = &md->session_uuid; - if (!BLI_session_uuid_is_generated(session_uuid)) { - printf("Modifier %s -> %s does not have UUID generated.\n", object->id.name + 2, md->name); + const SessionUID *session_uid = &md->session_uid; + if (!BLI_session_uid_is_generated(session_uid)) { + printf("Modifier %s -> %s does not have UID generated.\n", object->id.name + 2, md->name); continue; } - if (BLI_gset_lookup(used_uuids, session_uuid) != nullptr) { - printf("Modifier %s -> %s has duplicate UUID generated.\n", object->id.name + 2, md->name); + if (BLI_gset_lookup(used_uids, session_uid) != nullptr) { + printf("Modifier %s -> %s has duplicate UID generated.\n", object->id.name + 2, md->name); continue; } - BLI_gset_insert(used_uuids, (void *)session_uuid); + BLI_gset_insert(used_uids, (void *)session_uid); } - BLI_gset_free(used_uuids, nullptr); + BLI_gset_free(used_uids, nullptr); } void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBase *modbase) @@ -1245,7 +1245,7 @@ void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb, Object BLO_read_list(reader, lb); LISTBASE_FOREACH (ModifierData *, md, lb) { - BKE_modifier_session_uuid_generate(md); + BKE_modifier_session_uid_generate(md); md->error = nullptr; md->runtime = nullptr; diff --git a/source/blender/blenkernel/intern/movieclip.cc b/source/blender/blenkernel/intern/movieclip.cc index 92702409758..b1e86e81b78 100644 --- a/source/blender/blenkernel/intern/movieclip.cc +++ b/source/blender/blenkernel/intern/movieclip.cc @@ -141,7 +141,7 @@ static void movie_clip_foreach_cache(ID *id, { MovieClip *movie_clip = (MovieClip *)id; IDCacheKey key{}; - key.id_session_uuid = id->session_uuid; + key.id_session_uid = id->session_uid; key.identifier = offsetof(MovieClip, cache); function_callback(id, &key, (void **)&movie_clip->cache, 0, user_data); diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc index fab16d71d72..ded2767c7f3 100644 --- a/source/blender/blenkernel/intern/node.cc +++ b/source/blender/blenkernel/intern/node.cc @@ -398,7 +398,7 @@ static void node_foreach_cache(ID *id, { bNodeTree *nodetree = reinterpret_cast(id); IDCacheKey key = {0}; - key.id_session_uuid = id->session_uuid; + key.id_session_uid = id->session_uid; key.identifier = offsetof(bNodeTree, previews); /* TODO: see also `direct_link_nodetree()` in `readfile.cc`. */ diff --git a/source/blender/blenkernel/intern/object.cc b/source/blender/blenkernel/intern/object.cc index 48d9177780e..dfebe40c36a 100644 --- a/source/blender/blenkernel/intern/object.cc +++ b/source/blender/blenkernel/intern/object.cc @@ -5336,10 +5336,10 @@ void BKE_object_to_curve_clear(Object *object) object->runtime->object_as_temp_curve = nullptr; } -void BKE_object_check_uuids_unique_and_report(const Object *object) +void BKE_object_check_uids_unique_and_report(const Object *object) { - BKE_pose_check_uuids_unique_and_report(object->pose); - BKE_modifier_check_uuids_unique_and_report(object); + BKE_pose_check_uids_unique_and_report(object->pose); + BKE_modifier_check_uids_unique_and_report(object); } SubsurfModifierData *BKE_object_get_last_subsurf_modifier(const Object *ob) diff --git a/source/blender/blenkernel/intern/object_dupli.cc b/source/blender/blenkernel/intern/object_dupli.cc index c781d216021..3338f27847c 100644 --- a/source/blender/blenkernel/intern/object_dupli.cc +++ b/source/blender/blenkernel/intern/object_dupli.cc @@ -417,7 +417,7 @@ static void make_child_duplis(const DupliContext *ctx, } else { /* FIXME: using a mere counter to generate a 'persistent' dupli id is very weak. One possible - * better solution could be to use `session_uuid` of ID's instead? */ + * better solution could be to use `session_uid` of ID's instead? */ int persistent_dupli_id = 0; DEGObjectIterSettings deg_iter_settings{}; deg_iter_settings.depsgraph = ctx->depsgraph; diff --git a/source/blender/blenkernel/intern/scene.cc b/source/blender/blenkernel/intern/scene.cc index 82034cc2c98..8d0f3898802 100644 --- a/source/blender/blenkernel/intern/scene.cc +++ b/source/blender/blenkernel/intern/scene.cc @@ -498,8 +498,8 @@ static void scene_foreach_toolsettings_id_pointer_process( ID *id_old = *id_old_p; /* Old data has not been remapped to new values of the pointers, if we want to keep the old * pointer here we need its new address. */ - ID *id_old_new = id_old != nullptr ? BLO_read_get_new_id_address_from_session_uuid( - reader, id_old->session_uuid) : + ID *id_old_new = id_old != nullptr ? BLO_read_get_new_id_address_from_session_uid( + reader, id_old->session_uid) : nullptr; /* The new address may be the same as the old one, in which case there is nothing to do. */ if (id_old_new == id_old) { @@ -521,10 +521,10 @@ static void scene_foreach_toolsettings_id_pointer_process( * There is a nasty twist here though: a previous call to 'undo_preserve' on the Scene ID may * have modified it, even though the undo step detected it as unmodified. In such case, the * value of `*id_p` may end up also pointing to an invalid (no more in newly read Main) ID, - * so it also needs to be checked from its `session_uuid`. */ + * so it also needs to be checked from its `session_uid`. */ ID *id = *id_p; ID *id_new = id != nullptr ? - BLO_read_get_new_id_address_from_session_uuid(reader, id->session_uuid) : + BLO_read_get_new_id_address_from_session_uid(reader, id->session_uid) : nullptr; if (id_new != id) { *id_p = id_new; @@ -964,7 +964,7 @@ static void scene_foreach_cache(ID *id, { Scene *scene = (Scene *)id; IDCacheKey key{}; - key.id_session_uuid = id->session_uuid; + key.id_session_uid = id->session_uid; key.identifier = offsetof(Scene, eevee.light_cache_data); function_callback(id, diff --git a/source/blender/blenkernel/intern/sound.cc b/source/blender/blenkernel/intern/sound.cc index 82c2a0075f4..cfd19a02bc4 100644 --- a/source/blender/blenkernel/intern/sound.cc +++ b/source/blender/blenkernel/intern/sound.cc @@ -121,7 +121,7 @@ static void sound_foreach_cache(ID *id, { bSound *sound = (bSound *)id; IDCacheKey key{}; - key.id_session_uuid = id->session_uuid; + key.id_session_uid = id->session_uid; key.identifier = offsetof(bSound, waveform); function_callback(id, &key, &sound->waveform, 0, user_data); diff --git a/source/blender/blenkernel/intern/volume.cc b/source/blender/blenkernel/intern/volume.cc index 58c1b5ea486..6aff96326aa 100644 --- a/source/blender/blenkernel/intern/volume.cc +++ b/source/blender/blenkernel/intern/volume.cc @@ -202,7 +202,7 @@ static void volume_foreach_cache(ID *id, { Volume *volume = (Volume *)id; IDCacheKey key = { - /*id_session_uuid*/ id->session_uuid, + /*id_session_uid*/ id->session_uid, /*identifier*/ 1, }; diff --git a/source/blender/blenlib/BLI_session_uid.h b/source/blender/blenlib/BLI_session_uid.h new file mode 100644 index 00000000000..4683046a5d3 --- /dev/null +++ b/source/blender/blenlib/BLI_session_uid.h @@ -0,0 +1,64 @@ +/* SPDX-FileCopyrightText: 2023 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +#pragma once + +/** \file + * \ingroup bli + * + * Functions for generating and handling "Session UIDs". + * + * Note that these are not true universally-unique identifiers, but only unique during the current + * Blender session. + * + * For true UUIDs, see `BLI_uuid.h`. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "DNA_session_uid_types.h" + +/** Generate new UID which is unique throughout the Blender session. */ +SessionUID BLI_session_uid_generate(void); + +/** Check whether the UID is properly generated. */ +bool BLI_session_uid_is_generated(const SessionUID *uid); + +/** Check whether two UIDs are identical. */ +bool BLI_session_uid_is_equal(const SessionUID *lhs, const SessionUID *rhs); + +uint64_t BLI_session_uid_hash_uint64(const SessionUID *uid); + +/* Utility functions to make it possible to create GHash/GSet with UID as a key. */ + +uint BLI_session_uid_ghash_hash(const void *uid_v); +bool BLI_session_uid_ghash_compare(const void *lhs_v, const void *rhs_v); + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus + +namespace blender { + +inline const bool operator==(const SessionUID &lhs, const SessionUID &rhs) +{ + return BLI_session_uid_is_equal(&lhs, &rhs); +} + +template struct DefaultHash; + +template<> struct DefaultHash { + uint64_t operator()(const SessionUID &value) const + { + return BLI_session_uid_hash_uint64(&value); + } +}; + +} // namespace blender + +#endif diff --git a/source/blender/blenlib/BLI_session_uuid.h b/source/blender/blenlib/BLI_session_uuid.h deleted file mode 100644 index 421d6c3acb9..00000000000 --- a/source/blender/blenlib/BLI_session_uuid.h +++ /dev/null @@ -1,64 +0,0 @@ -/* SPDX-FileCopyrightText: 2023 Blender Authors - * - * SPDX-License-Identifier: GPL-2.0-or-later */ - -#pragma once - -/** \file - * \ingroup bli - * - * Functions for generating and handling "Session UUIDs". - * - * Note that these are not true universally-unique identifiers, but only unique during the current - * Blender session. - * - * For true UUIDs, see `BLI_uuid.h`. - */ - -#ifdef __cplusplus -extern "C" { -#endif - -#include "DNA_session_uuid_types.h" - -/** Generate new UUID which is unique throughout the Blender session. */ -SessionUUID BLI_session_uuid_generate(void); - -/** Check whether the UUID is properly generated. */ -bool BLI_session_uuid_is_generated(const SessionUUID *uuid); - -/** Check whether two UUIDs are identical. */ -bool BLI_session_uuid_is_equal(const SessionUUID *lhs, const SessionUUID *rhs); - -uint64_t BLI_session_uuid_hash_uint64(const SessionUUID *uuid); - -/* Utility functions to make it possible to create GHash/GSet with UUID as a key. */ - -uint BLI_session_uuid_ghash_hash(const void *uuid_v); -bool BLI_session_uuid_ghash_compare(const void *lhs_v, const void *rhs_v); - -#ifdef __cplusplus -} -#endif - -#ifdef __cplusplus - -namespace blender { - -inline const bool operator==(const SessionUUID &lhs, const SessionUUID &rhs) -{ - return BLI_session_uuid_is_equal(&lhs, &rhs); -} - -template struct DefaultHash; - -template<> struct DefaultHash { - uint64_t operator()(const SessionUUID &value) const - { - return BLI_session_uuid_hash_uint64(&value); - } -}; - -} // namespace blender - -#endif diff --git a/source/blender/blenlib/BLI_uuid.h b/source/blender/blenlib/BLI_uuid.h index 64a392bb281..91122776ae3 100644 --- a/source/blender/blenlib/BLI_uuid.h +++ b/source/blender/blenlib/BLI_uuid.h @@ -10,7 +10,7 @@ * Functions for generating and handling UUID structs according to RFC4122. * * Note that these are true UUIDs, not to be confused with the "session uuid" defined in - * `BLI_session_uuid.h`. + * `BLI_session_uid.h`. */ #include "DNA_uuid_types.h" diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt index 5a2a3a0865c..b01224442d0 100644 --- a/source/blender/blenlib/CMakeLists.txt +++ b/source/blender/blenlib/CMakeLists.txt @@ -132,7 +132,7 @@ set(SRC intern/scanfill.c intern/scanfill_utils.c intern/serialize.cc - intern/session_uuid.c + intern/session_uid.c intern/smaa_textures.c intern/sort.c intern/sort_utils.c @@ -335,7 +335,7 @@ set(SRC BLI_resource_scope.hh BLI_scanfill.h BLI_serialize.hh - BLI_session_uuid.h + BLI_session_uid.h BLI_set.hh BLI_set_slots.hh BLI_shared_cache.hh @@ -544,7 +544,7 @@ if(WITH_GTESTS) tests/BLI_pool_test.cc tests/BLI_ressource_strings.h tests/BLI_serialize_test.cc - tests/BLI_session_uuid_test.cc + tests/BLI_session_uid_test.cc tests/BLI_set_test.cc tests/BLI_span_test.cc tests/BLI_stack_cxx_test.cc diff --git a/source/blender/blenlib/intern/session_uid.c b/source/blender/blenlib/intern/session_uid.c new file mode 100644 index 00000000000..d13151e27e9 --- /dev/null +++ b/source/blender/blenlib/intern/session_uid.c @@ -0,0 +1,66 @@ +/* SPDX-FileCopyrightText: 2023 Blender Authors + * + * SPDX-License-Identifier: GPL-2.0-or-later */ + +/** \file + * \ingroup bli + */ + +#include "BLI_session_uid.h" + +#include "BLI_utildefines.h" + +#include "atomic_ops.h" + +/* Special value which indicates the UID has not been assigned yet. */ +#define BLI_session_uid_NONE 0 + +static const SessionUID global_session_uid_none = {BLI_session_uid_NONE}; + +/* Denotes last used UID. + * It might eventually overflow, and easiest is to add more bits to it. */ +static SessionUID global_session_uid = {BLI_session_uid_NONE}; + +SessionUID BLI_session_uid_generate(void) +{ + SessionUID result; + result.uid_ = atomic_add_and_fetch_uint64(&global_session_uid.uid_, 1); + if (!BLI_session_uid_is_generated(&result)) { + /* Happens when the UID overflows. + * + * Just request the UID once again, hoping that there are not a lot of high-priority threads + * which will overflow the counter once again between the previous call and this one. + * + * NOTE: It is possible to have collisions after such overflow. */ + result.uid_ = atomic_add_and_fetch_uint64(&global_session_uid.uid_, 1); + } + return result; +} + +bool BLI_session_uid_is_generated(const SessionUID *uid) +{ + return !BLI_session_uid_is_equal(uid, &global_session_uid_none); +} + +bool BLI_session_uid_is_equal(const SessionUID *lhs, const SessionUID *rhs) +{ + return lhs->uid_ == rhs->uid_; +} + +uint64_t BLI_session_uid_hash_uint64(const SessionUID *uid) +{ + return uid->uid_; +} + +uint BLI_session_uid_ghash_hash(const void *uid_v) +{ + const SessionUID *uid = (const SessionUID *)uid_v; + return uid->uid_ & 0xffffffff; +} + +bool BLI_session_uid_ghash_compare(const void *lhs_v, const void *rhs_v) +{ + const SessionUID *lhs = (const SessionUID *)lhs_v; + const SessionUID *rhs = (const SessionUID *)rhs_v; + return !BLI_session_uid_is_equal(lhs, rhs); +} diff --git a/source/blender/blenlib/intern/session_uuid.c b/source/blender/blenlib/intern/session_uuid.c deleted file mode 100644 index b8d4e308d79..00000000000 --- a/source/blender/blenlib/intern/session_uuid.c +++ /dev/null @@ -1,66 +0,0 @@ -/* SPDX-FileCopyrightText: 2023 Blender Authors - * - * SPDX-License-Identifier: GPL-2.0-or-later */ - -/** \file - * \ingroup bli - */ - -#include "BLI_session_uuid.h" - -#include "BLI_utildefines.h" - -#include "atomic_ops.h" - -/* Special value which indicates the UUID has not been assigned yet. */ -#define BLI_SESSION_UUID_NONE 0 - -static const SessionUUID global_session_uuid_none = {BLI_SESSION_UUID_NONE}; - -/* Denotes last used UUID. - * It might eventually overflow, and easiest is to add more bits to it. */ -static SessionUUID global_session_uuid = {BLI_SESSION_UUID_NONE}; - -SessionUUID BLI_session_uuid_generate(void) -{ - SessionUUID result; - result.uuid_ = atomic_add_and_fetch_uint64(&global_session_uuid.uuid_, 1); - if (!BLI_session_uuid_is_generated(&result)) { - /* Happens when the UUID overflows. - * - * Just request the UUID once again, hoping that there are not a lot of high-priority threads - * which will overflow the counter once again between the previous call and this one. - * - * NOTE: It is possible to have collisions after such overflow. */ - result.uuid_ = atomic_add_and_fetch_uint64(&global_session_uuid.uuid_, 1); - } - return result; -} - -bool BLI_session_uuid_is_generated(const SessionUUID *uuid) -{ - return !BLI_session_uuid_is_equal(uuid, &global_session_uuid_none); -} - -bool BLI_session_uuid_is_equal(const SessionUUID *lhs, const SessionUUID *rhs) -{ - return lhs->uuid_ == rhs->uuid_; -} - -uint64_t BLI_session_uuid_hash_uint64(const SessionUUID *uuid) -{ - return uuid->uuid_; -} - -uint BLI_session_uuid_ghash_hash(const void *uuid_v) -{ - const SessionUUID *uuid = (const SessionUUID *)uuid_v; - return uuid->uuid_ & 0xffffffff; -} - -bool BLI_session_uuid_ghash_compare(const void *lhs_v, const void *rhs_v) -{ - const SessionUUID *lhs = (const SessionUUID *)lhs_v; - const SessionUUID *rhs = (const SessionUUID *)rhs_v; - return !BLI_session_uuid_is_equal(lhs, rhs); -} diff --git a/source/blender/blenlib/tests/BLI_session_uid_test.cc b/source/blender/blenlib/tests/BLI_session_uid_test.cc new file mode 100644 index 00000000000..87060829037 --- /dev/null +++ b/source/blender/blenlib/tests/BLI_session_uid_test.cc @@ -0,0 +1,22 @@ +/* SPDX-FileCopyrightText: 2023 Blender Authors + * + * SPDX-License-Identifier: Apache-2.0 */ + +#include "testing/testing.h" + +#include "BLI_session_uid.h" + +TEST(SessionUID, GenerateBasic) +{ + { + const SessionUID uid = BLI_session_uid_generate(); + EXPECT_TRUE(BLI_session_uid_is_generated(&uid)); + } + + { + const SessionUID uid1 = BLI_session_uid_generate(); + const SessionUID uid2 = BLI_session_uid_generate(); + + EXPECT_FALSE(BLI_session_uid_is_equal(&uid1, &uid2)); + } +} diff --git a/source/blender/blenlib/tests/BLI_session_uuid_test.cc b/source/blender/blenlib/tests/BLI_session_uuid_test.cc deleted file mode 100644 index bd78ef25a73..00000000000 --- a/source/blender/blenlib/tests/BLI_session_uuid_test.cc +++ /dev/null @@ -1,22 +0,0 @@ -/* SPDX-FileCopyrightText: 2023 Blender Authors - * - * SPDX-License-Identifier: Apache-2.0 */ - -#include "testing/testing.h" - -#include "BLI_session_uuid.h" - -TEST(SessionUUID, GenerateBasic) -{ - { - const SessionUUID uuid = BLI_session_uuid_generate(); - EXPECT_TRUE(BLI_session_uuid_is_generated(&uuid)); - } - - { - const SessionUUID uuid1 = BLI_session_uuid_generate(); - const SessionUUID uuid2 = BLI_session_uuid_generate(); - - EXPECT_FALSE(BLI_session_uuid_is_equal(&uuid1, &uuid2)); - } -} diff --git a/source/blender/blenloader/BLO_read_write.hh b/source/blender/blenloader/BLO_read_write.hh index eb54fedca3d..ffdb968e184 100644 --- a/source/blender/blenloader/BLO_read_write.hh +++ b/source/blender/blenloader/BLO_read_write.hh @@ -277,9 +277,9 @@ ID *BLO_read_get_new_id_address(BlendLibReader *reader, ID *id) ATTR_NONNULL(2); /** - * Search for the new address of the ID for the given `session_uuid`. + * Search for the new address of the ID for the given `session_uid`. * - * Only IDs existing in the newly read Main will be returned. If no matching `session_uuid` in new + * Only IDs existing in the newly read Main will be returned. If no matching `session_uid` in new * main can be found, `nullptr` is returned. * * This expected to be used during library-linking and/or 'undo_preserve' processes in undo case @@ -287,7 +287,7 @@ ID *BLO_read_get_new_id_address(BlendLibReader *reader, * coming from the previous, existing Main data, when it is preserved in newly read Main. * See e.g. the #scene_undo_preserve code-path. */ -ID *BLO_read_get_new_id_address_from_session_uuid(BlendLibReader *reader, uint session_uuid) +ID *BLO_read_get_new_id_address_from_session_uid(BlendLibReader *reader, uint session_uid) ATTR_NONNULL(1); /* Misc. */ diff --git a/source/blender/blenloader/BLO_undofile.hh b/source/blender/blenloader/BLO_undofile.hh index 8301bc7c579..c9056c6ac26 100644 --- a/source/blender/blenloader/BLO_undofile.hh +++ b/source/blender/blenloader/BLO_undofile.hh @@ -27,9 +27,9 @@ struct MemFileChunk { * detect unchanged IDs). * Defined when writing the next step (i.e. last undo step has those always false). */ bool is_identical_future; - /** Session UUID of the ID being currently written (MAIN_ID_SESSION_UUID_UNSET when not writing + /** Session UID of the ID being currently written (MAIN_ID_SESSION_UID_UNSET when not writing * ID-related data). Used to find matching chunks in previous memundo step. */ - uint id_session_uuid; + uint id_session_uid; }; struct MemFile { @@ -41,11 +41,11 @@ struct MemFileWriteData { MemFile *written_memfile; MemFile *reference_memfile; - uint current_id_session_uuid; + uint current_id_session_uid; MemFileChunk *reference_current_chunk; - /** Maps an ID session uuid to its first reference MemFileChunk, if existing. */ - blender::Map id_session_uuid_mapping; + /** Maps an ID session uid to its first reference MemFileChunk, if existing. */ + blender::Map id_session_uid_mapping; }; struct MemFileUndoData { diff --git a/source/blender/blenloader/intern/readfile.cc b/source/blender/blenloader/intern/readfile.cc index acb9f9f2a25..bdd942d0667 100644 --- a/source/blender/blenloader/intern/readfile.cc +++ b/source/blender/blenloader/intern/readfile.cc @@ -1354,11 +1354,11 @@ void blo_filedata_free(FileData *fd) if (fd->libmap && !(fd->flags & FD_FLAGS_NOT_MY_LIBMAP)) { oldnewmap_free(fd->libmap); } - if (fd->old_idmap_uuid != nullptr) { - BKE_main_idmap_destroy(fd->old_idmap_uuid); + if (fd->old_idmap_uid != nullptr) { + BKE_main_idmap_destroy(fd->old_idmap_uid); } - if (fd->new_idmap_uuid != nullptr) { - BKE_main_idmap_destroy(fd->new_idmap_uuid); + if (fd->new_idmap_uid != nullptr) { + BKE_main_idmap_destroy(fd->new_idmap_uid); } blo_cache_storage_end(fd); if (fd->bheadmap) { @@ -1591,10 +1591,10 @@ void blo_end_packed_pointer_map(FileData *fd, Main *oldmain) void blo_make_old_idmap_from_main(FileData *fd, Main *bmain) { - if (fd->old_idmap_uuid != nullptr) { - BKE_main_idmap_destroy(fd->old_idmap_uuid); + if (fd->old_idmap_uid != nullptr) { + BKE_main_idmap_destroy(fd->old_idmap_uid); } - fd->old_idmap_uuid = BKE_main_idmap_create(bmain, false, nullptr, MAIN_IDMAP_TYPE_UUID); + fd->old_idmap_uid = BKE_main_idmap_create(bmain, false, nullptr, MAIN_IDMAP_TYPE_UID); } struct BLOCacheStorage { @@ -1611,7 +1611,7 @@ struct BLOCacheStorageValue { static void blo_cache_storage_entry_register( ID *id, const IDCacheKey *key, void **cache_p, uint /*flags*/, void *cache_storage_v) { - BLI_assert(key->id_session_uuid == id->session_uuid); + BLI_assert(key->id_session_uid == id->session_uid); UNUSED_VARS_NDEBUG(id); BLOCacheStorage *cache_storage = static_cast(cache_storage_v); @@ -2069,13 +2069,13 @@ static void direct_link_id_common( BlendDataReader *reader, Library *current_library, ID *id, ID *id_old, const int id_tag) { if (!BLO_read_data_is_undo(reader)) { - /* When actually reading a file, we do want to reset/re-generate session UUIDS. + /* When actually reading a file, we do want to reset/re-generate session UIDS. * In undo case, we want to re-use existing ones. */ - id->session_uuid = MAIN_ID_SESSION_UUID_UNSET; + id->session_uid = MAIN_ID_SESSION_UID_UNSET; } if ((id_tag & LIB_TAG_TEMP_MAIN) == 0) { - BKE_lib_libblock_session_uuid_ensure(id); + BKE_lib_libblock_session_uid_ensure(id); } id->lib = current_library; @@ -2383,7 +2383,7 @@ static ID *create_placeholder(Main *mainvar, } if ((tag & LIB_TAG_TEMP_MAIN) == 0) { - BKE_lib_libblock_session_uuid_ensure(ph_id); + BKE_lib_libblock_session_uid_ensure(ph_id); } return ph_id; @@ -2625,7 +2625,7 @@ static void read_undo_reuse_noundo_local_ids(FileData *fd) /* Update mappings accordingly. */ LISTBASE_FOREACH (ID *, id_iter, new_lb) { - BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_iter); + BKE_main_idmap_insert_id(fd->new_idmap_uid, id_iter); id_iter->tag |= LIB_TAG_UNDO_OLD_ID_REUSED_NOUNDO; } } @@ -2642,14 +2642,14 @@ static void read_undo_move_libmain_data( BLI_addtail(&new_main->libraries, libmain->curlib); curlib->id.tag |= LIB_TAG_UNDO_OLD_ID_REUSED_NOUNDO; - BKE_main_idmap_insert_id(fd->new_idmap_uuid, &curlib->id); + BKE_main_idmap_insert_id(fd->new_idmap_uid, &curlib->id); if (bhead != nullptr) { oldnewmap_lib_insert(fd, bhead->old, &curlib->id, GS(curlib->id.name)); } ID *id_iter; FOREACH_MAIN_ID_BEGIN (libmain, id_iter) { - BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_iter); + BKE_main_idmap_insert_id(fd->new_idmap_uid, id_iter); } FOREACH_MAIN_ID_END; } @@ -2709,7 +2709,7 @@ static bool read_libblock_undo_restore_linked( CLOG_INFO(&LOG_UNDO, 2, "UNDO: restore linked datablock %s", id->name); if (*r_id_old == nullptr) { - /* If the linked ID had to be re-read at some point, its session_uuid may not be the same as + /* If the linked ID had to be re-read at some point, its session_uid may not be the same as * its reference stored in the memfile anymore. Do a search by name then. */ *r_id_old = library_id_is_yet_read(fd, libmain, bhead); @@ -2729,19 +2729,19 @@ static bool read_libblock_undo_restore_linked( libmain->curlib ? libmain->curlib->filepath : ""); /* The Library ID 'owning' this linked ID should already have been moved to new main by a call * to #read_libblock_undo_restore_library. */ - BLI_assert(*r_id_old == static_cast(BKE_main_idmap_lookup_uuid( - fd->new_idmap_uuid, (*r_id_old)->session_uuid))); + BLI_assert(*r_id_old == static_cast(BKE_main_idmap_lookup_uid( + fd->new_idmap_uid, (*r_id_old)->session_uid))); } else { CLOG_INFO(&LOG_UNDO, 2, - " from %s (%s): found by session_uuid", + " from %s (%s): found by session_uid", libmain->curlib ? libmain->curlib->id.name : "", libmain->curlib ? libmain->curlib->filepath : ""); /* The Library ID 'owning' this linked ID should already have been moved to new main by a call * to #read_libblock_undo_restore_library. */ - BLI_assert(*r_id_old == static_cast( - BKE_main_idmap_lookup_uuid(fd->new_idmap_uuid, id->session_uuid))); + BLI_assert(*r_id_old == + static_cast(BKE_main_idmap_lookup_uid(fd->new_idmap_uid, id->session_uid))); } oldnewmap_lib_insert(fd, bhead->old, *r_id_old, GS((*r_id_old)->name)); @@ -2789,7 +2789,7 @@ static void read_libblock_undo_restore_identical( * remapped, so no need to store this info here. */ oldnewmap_lib_insert(fd, bhead->old, id_old, bhead->code); - BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_old); + BKE_main_idmap_insert_id(fd->new_idmap_uid, id_old); if (GS(id_old->name) == ID_OB) { Object *ob = (Object *)id_old; @@ -2843,7 +2843,7 @@ static void read_libblock_undo_restore_at_old_address(FileData *fd, Main *main, static bool read_libblock_undo_restore( FileData *fd, Main *main, BHead *bhead, int id_tag, ID **r_id_old) { - BLI_assert(fd->old_idmap_uuid != nullptr); + BLI_assert(fd->old_idmap_uid != nullptr); /* Get pointer to memory of new ID that we will be reading. */ const ID *id = static_cast(peek_struct_undo(fd, bhead)); @@ -2859,8 +2859,8 @@ static bool read_libblock_undo_restore( /* Find the 'current' existing ID we want to reuse instead of the one we * would read from the undo memfile. */ - ID *id_old = (fd->old_idmap_uuid != nullptr) ? - BKE_main_idmap_lookup_uuid(fd->old_idmap_uuid, id->session_uuid) : + ID *id_old = (fd->old_idmap_uid != nullptr) ? + BKE_main_idmap_lookup_uid(fd->old_idmap_uid, id->session_uid) : nullptr; if (bhead->code == ID_LI) { @@ -2881,14 +2881,14 @@ static bool read_libblock_undo_restore( /* If that local noundo ID still exists currently, the call to * #read_undo_reuse_noundo_local_ids at the beginning of #blo_read_file_internal will already - * have moved it into the new main, and populated accordingly the new_idmap_uuid. + * have moved it into the new main, and populated accordingly the new_idmap_uid. * * If this is the case, it can also be remapped for newly read data. Otherwise, this is 'lost' * data that cannot be restored on undo, so no remapping should exist for it in the ID * oldnewmap. */ if (id_old) { - BLI_assert(id_old == static_cast( - BKE_main_idmap_lookup_uuid(fd->new_idmap_uuid, id->session_uuid))); + BLI_assert(id_old == + static_cast(BKE_main_idmap_lookup_uid(fd->new_idmap_uid, id->session_uid))); oldnewmap_lib_insert(fd, bhead->old, id_old, bhead->code); } return true; @@ -2897,9 +2897,9 @@ static bool read_libblock_undo_restore( if (!do_partial_undo) { CLOG_INFO(&LOG_UNDO, 2, - "UNDO: read %s (uuid %u) -> no partial undo, always read at new address", + "UNDO: read %s (uid %u) -> no partial undo, always read at new address", id->name, - id->session_uuid); + id->session_uid); return false; } @@ -2908,9 +2908,9 @@ static bool read_libblock_undo_restore( /* Local datablock was unchanged, restore from the old main. */ CLOG_INFO(&LOG_UNDO, 2, - "UNDO: read %s (uuid %u) -> keep identical datablock", + "UNDO: read %s (uid %u) -> keep identical datablock", id->name, - id->session_uuid); + id->session_uid); read_libblock_undo_restore_identical(fd, main, id, id_old, bhead, id_tag); @@ -2921,16 +2921,16 @@ static bool read_libblock_undo_restore( /* Local datablock was changed. Restore at the address of the old datablock. */ CLOG_INFO(&LOG_UNDO, 2, - "UNDO: read %s (uuid %u) -> read to old existing address", + "UNDO: read %s (uid %u) -> read to old existing address", id->name, - id->session_uuid); + id->session_uid); *r_id_old = id_old; return false; } /* Local datablock does not exist in the undo step, so read from scratch. */ CLOG_INFO( - &LOG_UNDO, 2, "UNDO: read %s (uuid %u) -> read at new address", id->name, id->session_uuid); + &LOG_UNDO, 2, "UNDO: read %s (uid %u) -> read at new address", id->name, id->session_uid); return false; } @@ -3051,8 +3051,8 @@ static BHead *read_libblock(FileData *fd, /* For undo, store contents read into id at id_old. */ read_libblock_undo_restore_at_old_address(fd, main, id, id_old); } - if (fd->new_idmap_uuid != nullptr) { - BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_target); + if (fd->new_idmap_uid != nullptr) { + BKE_main_idmap_insert_id(fd->new_idmap_uid, id_target); } if (main->id_map != nullptr) { BKE_main_idmap_insert_id(main->id_map, id_target); @@ -3520,10 +3520,10 @@ static int read_undo_remap_noundo_data_cb(LibraryIDLinkCallbackData *cb_data) return IDWALK_RET_NOP; } - IDNameLib_Map *new_idmap_uuid = static_cast(cb_data->user_data); + IDNameLib_Map *new_idmap_uid = static_cast(cb_data->user_data); ID **id_pointer = cb_data->id_pointer; if (*id_pointer != nullptr) { - *id_pointer = BKE_main_idmap_lookup_uuid(new_idmap_uuid, (*id_pointer)->session_uuid); + *id_pointer = BKE_main_idmap_lookup_uid(new_idmap_uid, (*id_pointer)->session_uid); } return IDWALK_RET_NOP; @@ -3535,7 +3535,7 @@ static int read_undo_remap_noundo_data_cb(LibraryIDLinkCallbackData *cb_data) * re-used IDs (the 'unchanged' ones), there is no guarantee that all the ID pointers they use are * still valid. * - * This code performs a remapping based on the session_uuid. */ + * This code performs a remapping based on the session_uid. */ static void read_undo_remap_noundo_data(FileData *fd) { Main *new_bmain = static_cast
(fd->mainlist->first); @@ -3549,7 +3549,7 @@ static void read_undo_remap_noundo_data(FileData *fd) } BKE_library_foreach_ID_link( - new_bmain, id_iter, read_undo_remap_noundo_data_cb, fd->new_idmap_uuid, IDWALK_INCLUDE_UI); + new_bmain, id_iter, read_undo_remap_noundo_data_cb, fd->new_idmap_uid, IDWALK_INCLUDE_UI); } FOREACH_MAIN_ID_END; } @@ -3621,10 +3621,10 @@ BlendFileData *blo_read_file_internal(FileData *fd, const char *filepath) } if (is_undo) { - /* This idmap will store uuids of all IDs ending up in the new main, whether they are newly + /* This idmap will store uids of all IDs ending up in the new main, whether they are newly * read, or re-used from the old main. */ - fd->new_idmap_uuid = BKE_main_idmap_create( - static_cast
(fd->mainlist->first), false, nullptr, MAIN_IDMAP_TYPE_UUID); + fd->new_idmap_uid = BKE_main_idmap_create( + static_cast
(fd->mainlist->first), false, nullptr, MAIN_IDMAP_TYPE_UID); /* Copy all 'no undo' local data from old to new bmain. */ read_undo_reuse_noundo_local_ids(fd); @@ -4858,9 +4858,9 @@ ID *BLO_read_get_new_id_address(BlendLibReader *reader, return static_cast(newlibadr(reader->fd, self_id, is_linked_only, id)); } -ID *BLO_read_get_new_id_address_from_session_uuid(BlendLibReader *reader, uint session_uuid) +ID *BLO_read_get_new_id_address_from_session_uid(BlendLibReader *reader, uint session_uid) { - return BKE_main_idmap_lookup_uuid(reader->fd->new_idmap_uuid, session_uuid); + return BKE_main_idmap_lookup_uid(reader->fd->new_idmap_uid, session_uid); } int BLO_read_fileversion_get(BlendDataReader *reader) diff --git a/source/blender/blenloader/intern/readfile.hh b/source/blender/blenloader/intern/readfile.hh index b761d0812d3..51a85457a46 100644 --- a/source/blender/blenloader/intern/readfile.hh +++ b/source/blender/blenloader/intern/readfile.hh @@ -118,11 +118,11 @@ struct FileData { /** Used for undo. */ ListBase *old_mainlist; /** - * IDMap using UUID's as keys of all the old IDs in the old bmain. Used during undo to find a + * IDMap using UID's as keys of all the old IDs in the old bmain. Used during undo to find a * matching old data when reading a new ID. */ - IDNameLib_Map *old_idmap_uuid; + IDNameLib_Map *old_idmap_uid; /** - * IDMap using uuids as keys of the IDs read (or moved) in the new main(s). + * IDMap using uids as keys of the IDs read (or moved) in the new main(s). * * Used during undo to ensure that the ID pointers from the 'no undo' IDs remain valid (these * IDs are re-used from old main even if their content is not the same as in the memfile undo @@ -130,7 +130,7 @@ struct FileData { * * Also used to find current valid pointers (or none) of these 'no undo' IDs existing in * read memfile. */ - IDNameLib_Map *new_idmap_uuid; + IDNameLib_Map *new_idmap_uid; BlendFileReadReport *reports; }; diff --git a/source/blender/blenloader/intern/undofile.cc b/source/blender/blenloader/intern/undofile.cc index 245d713a3fe..d7b101eeded 100644 --- a/source/blender/blenloader/intern/undofile.cc +++ b/source/blender/blenloader/intern/undofile.cc @@ -97,17 +97,17 @@ void BLO_memfile_write_init(MemFileWriteData *mem_data, reference_memfile->chunks.first) : nullptr; - /* If we have a reference memfile, we generate a mapping between the session_uuid's of the + /* If we have a reference memfile, we generate a mapping between the session_uid's of the * IDs stored in that previous undo step, and its first matching memchunk. This will allow * us to easily find the existing undo memory storage of IDs even when some re-ordering in * current Main data-base broke the order matching with the memchunks from previous step. */ if (reference_memfile != nullptr) { - uint current_session_uuid = MAIN_ID_SESSION_UUID_UNSET; + uint current_session_uid = MAIN_ID_SESSION_UID_UNSET; LISTBASE_FOREACH (MemFileChunk *, mem_chunk, &reference_memfile->chunks) { - if (!ELEM(mem_chunk->id_session_uuid, MAIN_ID_SESSION_UUID_UNSET, current_session_uuid)) { - current_session_uuid = mem_chunk->id_session_uuid; - mem_data->id_session_uuid_mapping.add_new(current_session_uuid, mem_chunk); + if (!ELEM(mem_chunk->id_session_uid, MAIN_ID_SESSION_UID_UNSET, current_session_uid)) { + current_session_uid = mem_chunk->id_session_uid; + mem_data->id_session_uid_mapping.add_new(current_session_uid, mem_chunk); } } } @@ -115,7 +115,7 @@ void BLO_memfile_write_init(MemFileWriteData *mem_data, void BLO_memfile_write_finalize(MemFileWriteData *mem_data) { - mem_data->id_session_uuid_mapping.clear_and_shrink(); + mem_data->id_session_uid_mapping.clear_and_shrink(); } void BLO_memfile_chunk_add(MemFileWriteData *mem_data, const char *buf, size_t size) @@ -132,7 +132,7 @@ void BLO_memfile_chunk_add(MemFileWriteData *mem_data, const char *buf, size_t s * perform an undo push may make changes after the last undo push that * will then not be undo. Though it's not entirely clear that is wrong behavior. */ curchunk->is_identical_future = true; - curchunk->id_session_uuid = mem_data->current_id_session_uuid; + curchunk->id_session_uid = mem_data->current_id_session_uid; BLI_addtail(&memfile->chunks, curchunk); /* we compare compchunk with buf */ diff --git a/source/blender/blenloader/intern/versioning_250.cc b/source/blender/blenloader/intern/versioning_250.cc index 355e853d3d4..0ca8f91f420 100644 --- a/source/blender/blenloader/intern/versioning_250.cc +++ b/source/blender/blenloader/intern/versioning_250.cc @@ -450,7 +450,7 @@ static void versions_gpencil_add_main(Main *bmain, ListBase *lb, ID *id, const c /* alphabetic insertion: is in BKE_id_new_name_validate */ if ((id->tag & LIB_TAG_TEMP_MAIN) == 0) { - BKE_lib_libblock_session_uuid_ensure(id); + BKE_lib_libblock_session_uid_ensure(id); } if (G.debug & G_DEBUG) { diff --git a/source/blender/blenloader/intern/writefile.cc b/source/blender/blenloader/intern/writefile.cc index 504c9aa760d..d883efaebdd 100644 --- a/source/blender/blenloader/intern/writefile.cc +++ b/source/blender/blenloader/intern/writefile.cc @@ -612,27 +612,27 @@ static bool mywrite_end(WriteData *wd) static void mywrite_id_begin(WriteData *wd, ID *id) { if (wd->use_memfile) { - wd->mem.current_id_session_uuid = id->session_uuid; + wd->mem.current_id_session_uid = id->session_uid; /* If current next memchunk does not match the ID we are about to write, or is not the _first_ - * one for said ID, try to find the correct memchunk in the mapping using ID's session_uuid. */ + * one for said ID, try to find the correct memchunk in the mapping using ID's session_uid. */ MemFileChunk *curr_memchunk = wd->mem.reference_current_chunk; MemFileChunk *prev_memchunk = curr_memchunk != nullptr ? static_cast(curr_memchunk->prev) : nullptr; - if ((curr_memchunk == nullptr || curr_memchunk->id_session_uuid != id->session_uuid || + if ((curr_memchunk == nullptr || curr_memchunk->id_session_uid != id->session_uid || (prev_memchunk != nullptr && - (prev_memchunk->id_session_uuid == curr_memchunk->id_session_uuid)))) + (prev_memchunk->id_session_uid == curr_memchunk->id_session_uid)))) { - if (MemFileChunk *ref = wd->mem.id_session_uuid_mapping.lookup_default(id->session_uuid, - nullptr)) + if (MemFileChunk *ref = wd->mem.id_session_uid_mapping.lookup_default(id->session_uid, + nullptr)) { wd->mem.reference_current_chunk = static_cast(ref); } /* Else, no existing memchunk found, i.e. this is supposed to be a new ID. */ } /* Otherwise, we try with the current memchunk in any case, whether it is matching current - * ID's session_uuid or not. */ + * ID's session_uid or not. */ } } @@ -647,7 +647,7 @@ static void mywrite_id_end(WriteData *wd, ID * /*id*/) /* Very important to do it after every ID write now, otherwise we cannot know whether a * specific ID changed or not. */ mywrite_flush(wd); - wd->mem.current_id_session_uuid = MAIN_ID_SESSION_UUID_UNSET; + wd->mem.current_id_session_uid = MAIN_ID_SESSION_UID_UNSET; } } diff --git a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc index 7f4820e6a7f..e813a338c1e 100644 --- a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc +++ b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc @@ -150,7 +150,7 @@ DepsgraphNodeBuilder::~DepsgraphNodeBuilder() IDNode *DepsgraphNodeBuilder::add_id_node(ID *id) { - BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET); + BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET); const ID_Type id_type = GS(id->name); IDNode *id_node = nullptr; @@ -158,7 +158,7 @@ IDNode *DepsgraphNodeBuilder::add_id_node(ID *id) IDComponentsMask previously_visible_components_mask = 0; uint32_t previous_eval_flags = 0; DEGCustomDataMeshMasks previous_customdata_masks; - IDInfo *id_info = id_info_hash_.lookup_default(id->session_uuid, nullptr); + IDInfo *id_info = id_info_hash_.lookup_default(id->session_uid, nullptr); if (id_info != nullptr) { id_cow = id_info->id_cow; previously_visible_components_mask = id_info->previously_visible_components_mask; @@ -397,8 +397,8 @@ void DepsgraphNodeBuilder::begin_build() id_info->previously_visible_components_mask = id_node->visible_components_mask; id_info->previous_eval_flags = id_node->eval_flags; id_info->previous_customdata_masks = id_node->customdata_masks; - BLI_assert(!id_info_hash_.contains(id_node->id_orig_session_uuid)); - id_info_hash_.add_new(id_node->id_orig_session_uuid, id_info); + BLI_assert(!id_info_hash_.contains(id_node->id_orig_session_uid)); + id_info_hash_.add_new(id_node->id_orig_session_uid, id_info); id_node->id_cow = nullptr; } diff --git a/source/blender/depsgraph/intern/builder/deg_builder_nodes.h b/source/blender/depsgraph/intern/builder/deg_builder_nodes.h index 9124480ed25..f8a14854726 100644 --- a/source/blender/depsgraph/intern/builder/deg_builder_nodes.h +++ b/source/blender/depsgraph/intern/builder/deg_builder_nodes.h @@ -322,7 +322,7 @@ class DepsgraphNodeBuilder : public DepsgraphBuilder { * very root is visible (aka not restricted.). */ bool is_parent_collection_visible_; - /* Indexed by original ID.session_uuid, values are IDInfo. */ + /* Indexed by original ID.session_uid, values are IDInfo. */ Map id_info_hash_; /* Set of IDs which were already build. Makes it easier to keep track of diff --git a/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc b/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc index 54f4d71b379..e3e33357b55 100644 --- a/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc +++ b/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc @@ -270,11 +270,11 @@ bool id_copy_inplace_no_main(const ID *id, ID *newid) { const ID *id_for_copy = id; - if (G.debug & G_DEBUG_DEPSGRAPH_UUID) { + if (G.debug & G_DEBUG_DEPSGRAPH_UID) { const ID_Type id_type = GS(id_for_copy->name); if (id_type == ID_OB) { const Object *object = reinterpret_cast(id_for_copy); - BKE_object_check_uuids_unique_and_report(object); + BKE_object_check_uids_unique_and_report(object); } } @@ -303,8 +303,8 @@ bool id_copy_inplace_no_main(const ID *id, ID *newid) bool scene_copy_inplace_no_main(const Scene *scene, Scene *new_scene) { - if (G.debug & G_DEBUG_DEPSGRAPH_UUID) { - SEQ_relations_check_uuids_unique_and_report(scene); + if (G.debug & G_DEBUG_DEPSGRAPH_UID) { + SEQ_relations_check_uids_unique_and_report(scene); } #ifdef NESTED_ID_NASTY_WORKAROUND diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc index aca4b4b223b..cd17460ae5b 100644 --- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc +++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc @@ -58,10 +58,10 @@ void ObjectRuntimeBackup::backup_modifier_runtime_data(Object *object) continue; } - const SessionUUID &session_uuid = modifier_data->session_uuid; - BLI_assert(BLI_session_uuid_is_generated(&session_uuid)); + const SessionUID &session_uid = modifier_data->session_uid; + BLI_assert(BLI_session_uid_is_generated(&session_uid)); - modifier_runtime_data.add(session_uuid, ModifierDataBackup(modifier_data)); + modifier_runtime_data.add(session_uid, ModifierDataBackup(modifier_data)); modifier_data->runtime = nullptr; } } @@ -70,10 +70,10 @@ void ObjectRuntimeBackup::backup_pose_channel_runtime_data(Object *object) { if (object->pose != nullptr) { LISTBASE_FOREACH (bPoseChannel *, pchan, &object->pose->chanbase) { - const SessionUUID &session_uuid = pchan->runtime.session_uuid; - BLI_assert(BLI_session_uuid_is_generated(&session_uuid)); + const SessionUID &session_uid = pchan->runtime.session_uid; + BLI_assert(BLI_session_uid_is_generated(&session_uid)); - pose_channel_runtime_data.add(session_uuid, pchan->runtime); + pose_channel_runtime_data.add(session_uid, pchan->runtime); BKE_pose_channel_runtime_reset(&pchan->runtime); } } @@ -149,10 +149,10 @@ void ObjectRuntimeBackup::restore_to_object(Object *object) void ObjectRuntimeBackup::restore_modifier_runtime_data(Object *object) { LISTBASE_FOREACH (ModifierData *, modifier_data, &object->modifiers) { - const SessionUUID &session_uuid = modifier_data->session_uuid; - BLI_assert(BLI_session_uuid_is_generated(&session_uuid)); + const SessionUID &session_uid = modifier_data->session_uid; + BLI_assert(BLI_session_uid_is_generated(&session_uid)); - optional backup = modifier_runtime_data.pop_try(session_uuid); + optional backup = modifier_runtime_data.pop_try(session_uid); if (backup.has_value()) { modifier_data->runtime = backup->runtime; } @@ -178,8 +178,8 @@ void ObjectRuntimeBackup::restore_pose_channel_runtime_data(Object *object) { if (object->pose != nullptr) { LISTBASE_FOREACH (bPoseChannel *, pchan, &object->pose->chanbase) { - const SessionUUID &session_uuid = pchan->runtime.session_uuid; - optional runtime = pose_channel_runtime_data.pop_try(session_uuid); + const SessionUID &session_uid = pchan->runtime.session_uid; + optional runtime = pose_channel_runtime_data.pop_try(session_uid); if (runtime.has_value()) { pchan->runtime = *runtime; } diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h index 846904df76a..197ab7c7ce5 100644 --- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h +++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h @@ -9,11 +9,11 @@ #pragma once #include "DNA_object_types.h" -#include "DNA_session_uuid_types.h" +#include "DNA_session_uid_types.h" #include "BKE_object_types.hh" -#include "BLI_session_uuid.h" +#include "BLI_session_uid.h" #include "intern/depsgraph_type.hh" #include "intern/eval/deg_eval_runtime_backup_modifier.h" @@ -46,8 +46,8 @@ class ObjectRuntimeBackup { optional light_linking_runtime; short base_flag; unsigned short base_local_view_bits; - Map modifier_runtime_data; - Map pose_channel_runtime_data; + Map modifier_runtime_data; + Map pose_channel_runtime_data; }; } // namespace blender::deg diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc index 753943a7e8d..9d7363b4b53 100644 --- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc +++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc @@ -27,9 +27,9 @@ static bool seq_init_cb(Sequence *seq, void *user_data) SequenceBackup sequence_backup(sb->depsgraph); sequence_backup.init_from_sequence(seq); if (!sequence_backup.isEmpty()) { - const SessionUUID &session_uuid = seq->runtime.session_uuid; - BLI_assert(BLI_session_uuid_is_generated(&session_uuid)); - sb->sequences_backup.add(session_uuid, sequence_backup); + const SessionUID &session_uid = seq->runtime.session_uid; + BLI_assert(BLI_session_uid_is_generated(&session_uid)); + sb->sequences_backup.add(session_uid, sequence_backup); } return true; } @@ -44,9 +44,9 @@ void SequencerBackup::init_from_scene(Scene *scene) static bool seq_restore_cb(Sequence *seq, void *user_data) { SequencerBackup *sb = (SequencerBackup *)user_data; - const SessionUUID &session_uuid = seq->runtime.session_uuid; - BLI_assert(BLI_session_uuid_is_generated(&session_uuid)); - SequenceBackup *sequence_backup = sb->sequences_backup.lookup_ptr(session_uuid); + const SessionUID &session_uid = seq->runtime.session_uid; + BLI_assert(BLI_session_uid_is_generated(&session_uid)); + SequenceBackup *sequence_backup = sb->sequences_backup.lookup_ptr(session_uid); if (sequence_backup != nullptr) { sequence_backup->restore_to_sequence(seq); } diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h index 29e85cb8638..9d321a42ea2 100644 --- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h +++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h @@ -8,9 +8,9 @@ #pragma once -#include "DNA_session_uuid_types.h" +#include "DNA_session_uid_types.h" -#include "BLI_session_uuid.h" +#include "BLI_session_uid.h" #include "intern/depsgraph_type.hh" #include "intern/eval/deg_eval_runtime_backup_sequence.h" @@ -31,7 +31,7 @@ class SequencerBackup { const Depsgraph *depsgraph; - Map sequences_backup; + Map sequences_backup; }; } // namespace blender::deg diff --git a/source/blender/depsgraph/intern/node/deg_node_id.cc b/source/blender/depsgraph/intern/node/deg_node_id.cc index c9cff6f8cda..3079a2290cd 100644 --- a/source/blender/depsgraph/intern/node/deg_node_id.cc +++ b/source/blender/depsgraph/intern/node/deg_node_id.cc @@ -62,7 +62,7 @@ void IDNode::init(const ID *id, const char * /*subdata*/) /* Store ID-pointer. */ id_type = GS(id->name); id_orig = (ID *)id; - id_orig_session_uuid = id->session_uuid; + id_orig_session_uid = id->session_uid; eval_flags = 0; previous_eval_flags = 0; customdata_masks = DEGCustomDataMeshMasks(); diff --git a/source/blender/depsgraph/intern/node/deg_node_id.hh b/source/blender/depsgraph/intern/node/deg_node_id.hh index 90bae07f5e9..1aef3afa9e1 100644 --- a/source/blender/depsgraph/intern/node/deg_node_id.hh +++ b/source/blender/depsgraph/intern/node/deg_node_id.hh @@ -71,7 +71,7 @@ struct IDNode : public Node { * Is used on relations update to map evaluated state from old nodes to the new ones, without * relying on pointers (which are not guaranteed to be unique) and without dereferencing id_orig * which could be "stale" pointer. */ - uint id_orig_session_uuid; + uint id_orig_session_uid; /* Evaluated data-block. * Will be covered by the copy-on-write system if the ID Type needs it. */ diff --git a/source/blender/editors/geometry/node_group_operator.cc b/source/blender/editors/geometry/node_group_operator.cc index db447842674..0f559cf5441 100644 --- a/source/blender/editors/geometry/node_group_operator.cc +++ b/source/blender/editors/geometry/node_group_operator.cc @@ -85,7 +85,7 @@ static const bNodeTree *get_asset_or_local_node_group(const bContext &C, { Main &bmain = *CTX_data_main(&C); if (bNodeTree *group = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(&bmain, &ptr, ID_NT))) + WM_operator_properties_id_lookup_from_name_or_session_uid(&bmain, &ptr, ID_NT))) { return group; } diff --git a/source/blender/editors/interface/interface_dropboxes.cc b/source/blender/editors/interface/interface_dropboxes.cc index 0bd7ef280ad..7ceb8ff5cbd 100644 --- a/source/blender/editors/interface/interface_dropboxes.cc +++ b/source/blender/editors/interface/interface_dropboxes.cc @@ -93,7 +93,7 @@ static bool ui_drop_material_poll(bContext *C, wmDrag *drag, const wmEvent * /*e static void ui_drop_material_copy(bContext *C, wmDrag *drag, wmDropBox *drop) { const ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, ID_MA); - RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); + RNA_int_set(drop->ptr, "session_uid", int(id->session_uid)); } static std::string ui_drop_material_tooltip(bContext *C, diff --git a/source/blender/editors/interface/interface_ops.cc b/source/blender/editors/interface/interface_ops.cc index a0fe01ff8fd..ff5f99ae475 100644 --- a/source/blender/editors/interface/interface_ops.cc +++ b/source/blender/editors/interface/interface_ops.cc @@ -2572,7 +2572,7 @@ static int ui_drop_material_exec(bContext *C, wmOperator *op) { Main *bmain = CTX_data_main(C); - Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uuid( + Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uid( bmain, op->ptr, ID_MA); if (ma == nullptr) { return OPERATOR_CANCELLED; diff --git a/source/blender/editors/mesh/editmesh_undo.cc b/source/blender/editors/mesh/editmesh_undo.cc index c52d0cb0480..3dcc631311f 100644 --- a/source/blender/editors/mesh/editmesh_undo.cc +++ b/source/blender/editors/mesh/editmesh_undo.cc @@ -680,13 +680,13 @@ static void um_arraystore_free(UndoMesh *um) */ static UndoMesh **mesh_undostep_reference_elems_from_objects(Object **object, int object_len) { - /* Map: `Mesh.id.session_uuid` -> `UndoMesh`. */ + /* Map: `Mesh.id.session_uid` -> `UndoMesh`. */ GHash *uuid_map = BLI_ghash_ptr_new_ex(__func__, object_len); UndoMesh **um_references = static_cast( MEM_callocN(sizeof(UndoMesh *) * object_len, __func__)); for (int i = 0; i < object_len; i++) { const Mesh *mesh = static_cast(object[i]->data); - BLI_ghash_insert(uuid_map, POINTER_FROM_INT(mesh->id.session_uuid), &um_references[i]); + BLI_ghash_insert(uuid_map, POINTER_FROM_INT(mesh->id.session_uid), &um_references[i]); } int uuid_map_len = object_len; @@ -696,8 +696,8 @@ static UndoMesh **mesh_undostep_reference_elems_from_objects(Object **object, in UndoMesh *um_iter = static_cast(um_arraystore.local_links.last); while (um_iter && (uuid_map_len != 0)) { UndoMesh **um_p; - if ((um_p = static_cast(BLI_ghash_popkey( - uuid_map, POINTER_FROM_INT(um_iter->mesh.id.session_uuid), nullptr)))) + if ((um_p = static_cast( + BLI_ghash_popkey(uuid_map, POINTER_FROM_INT(um_iter->mesh.id.session_uid), nullptr)))) { *um_p = um_iter; uuid_map_len--; @@ -957,7 +957,7 @@ static bool mesh_undosys_step_encode(bContext *C, Main *bmain, UndoStep *us_p) #ifdef USE_ARRAY_STORE /** As this is only data storage it is safe to set the session ID here. */ - elem->data.mesh.id.session_uuid = mesh->id.session_uuid; + elem->data.mesh.id.session_uid = mesh->id.session_uid; #endif } MEM_freeN(objects); diff --git a/source/blender/editors/object/add_modifier_assets.cc b/source/blender/editors/object/add_modifier_assets.cc index 2abb5ebc7b1..df3abf35c22 100644 --- a/source/blender/editors/object/add_modifier_assets.cc +++ b/source/blender/editors/object/add_modifier_assets.cc @@ -262,7 +262,7 @@ static bNodeTree *get_asset_or_local_node_group(const bContext &C, { Main &bmain = *CTX_data_main(&C); if (bNodeTree *group = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(&bmain, &ptr, ID_NT))) + WM_operator_properties_id_lookup_from_name_or_session_uid(&bmain, &ptr, ID_NT))) { return group; } diff --git a/source/blender/editors/object/object_add.cc b/source/blender/editors/object/object_add.cc index a6d8d61a4c9..38c2e8e2567 100644 --- a/source/blender/editors/object/object_add.cc +++ b/source/blender/editors/object/object_add.cc @@ -1809,7 +1809,7 @@ static std::optional collection_add_info_get_from_op(bContext PropertyRNA *prop_location = RNA_struct_find_property(op->ptr, "location"); add_info.collection = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_GR)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_GR)); bool update_location_if_necessary = false; if (add_info.collection) { @@ -2055,8 +2055,7 @@ static int object_data_instance_add_exec(bContext *C, wmOperator *op) PropertyRNA *prop_location = RNA_struct_find_property(op->ptr, "location"); const short id_type = RNA_property_enum_get(op->ptr, prop_type); - id = WM_operator_properties_id_lookup_from_name_or_session_uuid( - bmain, op->ptr, (ID_Type)id_type); + id = WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, (ID_Type)id_type); if (id == nullptr) { return OPERATOR_CANCELLED; } @@ -4055,7 +4054,7 @@ static int object_add_named_exec(bContext *C, wmOperator *op) /* Find object, create fake base. */ Object *ob = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB)); if (ob == nullptr) { BKE_report(op->reports, RPT_ERROR, "Object not found"); @@ -4169,7 +4168,7 @@ static int object_transform_to_mouse_exec(bContext *C, wmOperator *op) ViewLayer *view_layer = CTX_data_view_layer(C); Object *ob = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB)); if (!ob) { BKE_view_layer_synced_ensure(scene, view_layer); @@ -4257,10 +4256,10 @@ void OBJECT_OT_transform_to_mouse(wmOperatorType *ot) nullptr, MAX_ID_NAME - 2, "Name", - "Object name to place (uses the active object when this and 'session_uuid' are unset)"); + "Object name to place (uses the active object when this and 'session_uid' are unset)"); RNA_def_property_flag(prop, (PropertyFlag)(PROP_SKIP_SAVE | PROP_HIDDEN)); prop = RNA_def_int(ot->srna, - "session_uuid", + "session_uid", 0, INT32_MIN, INT32_MAX, diff --git a/source/blender/editors/object/object_bake_simulation.cc b/source/blender/editors/object/object_bake_simulation.cc index df93a2bf6be..980d809cddf 100644 --- a/source/blender/editors/object/object_bake_simulation.cc +++ b/source/blender/editors/object/object_bake_simulation.cc @@ -778,7 +778,7 @@ static Vector bake_single_node_gather_bake_request(bContext *C, Main *bmain = CTX_data_main(C); Scene *scene = CTX_data_scene(C); Object *object = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB)); if (object == nullptr) { return {}; } @@ -890,7 +890,7 @@ static int delete_single_bake_exec(bContext *C, wmOperator *op) { Main *bmain = CTX_data_main(C); Object *object = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB)); if (object == nullptr) { return OPERATOR_CANCELLED; } diff --git a/source/blender/editors/object/object_relations.cc b/source/blender/editors/object/object_relations.cc index fab99fd2969..c5fa500ff56 100644 --- a/source/blender/editors/object/object_relations.cc +++ b/source/blender/editors/object/object_relations.cc @@ -2384,8 +2384,8 @@ static int make_override_library_exec(bContext *C, wmOperator *op) } else if (!make_override_library_object_overridable_check(bmain, obact)) { const int i = RNA_property_int_get(op->ptr, op->type->prop); - const uint collection_session_uuid = *((const uint *)&i); - if (collection_session_uuid == MAIN_ID_SESSION_UUID_UNSET) { + const uint collection_session_uid = *((const uint *)&i); + if (collection_session_uid == MAIN_ID_SESSION_UID_UNSET) { BKE_reportf(op->reports, RPT_ERROR_INVALID_INPUT, "Could not find an overridable root hierarchy for object '%s'", @@ -2394,9 +2394,9 @@ static int make_override_library_exec(bContext *C, wmOperator *op) } Collection *collection = static_cast( BLI_listbase_bytes_find(&bmain->collections, - &collection_session_uuid, - sizeof(collection_session_uuid), - offsetof(ID, session_uuid))); + &collection_session_uid, + sizeof(collection_session_uid), + offsetof(ID, session_uid))); id_root = &collection->id; user_overrides_from_selected_objects = true; } @@ -2441,7 +2441,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op) else if (user_overrides_from_selected_objects) { /* Only selected objects can be 'user overrides'. */ FOREACH_SELECTED_OBJECT_BEGIN (view_layer, CTX_wm_view3d(C), ob_iter) { - BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uuid)); + BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uid)); } FOREACH_SELECTED_OBJECT_END; } @@ -2449,7 +2449,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op) /* Only armatures inside the root collection (and their children) can be 'user overrides'. */ FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN ((Collection *)id_root, ob_iter) { if (ob_iter->type == OB_ARMATURE) { - BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uuid)); + BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uid)); } } FOREACH_COLLECTION_OBJECT_RECURSIVE_END; @@ -2467,7 +2467,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op) } LISTBASE_FOREACH (CollectionObject *, coll_ob_iter, &coll_iter->gobject) { if (BLI_gset_haskey(user_overrides_objects_uids, - POINTER_FROM_UINT(coll_ob_iter->ob->id.session_uuid))) + POINTER_FROM_UINT(coll_ob_iter->ob->id.session_uid))) { /* Tag for remapping when creating overrides. */ coll_iter->id.tag |= LIB_TAG_DOIT; @@ -2499,7 +2499,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op) continue; } if (BLI_gset_haskey(user_overrides_objects_uids, - POINTER_FROM_UINT(id_iter->override_library->reference->session_uuid))) + POINTER_FROM_UINT(id_iter->override_library->reference->session_uid))) { id_iter->override_library->flag &= ~LIBOVERRIDE_FLAG_SYSTEM_DEFINED; } @@ -2627,12 +2627,12 @@ static int make_override_library_invoke(bContext *C, wmOperator *op, const wmEve } if (potential_root_collections.is_empty()) { - RNA_property_int_set(op->ptr, op->type->prop, MAIN_ID_SESSION_UUID_UNSET); + RNA_property_int_set(op->ptr, op->type->prop, MAIN_ID_SESSION_UID_UNSET); return make_override_library_exec(C, op); } if (potential_root_collections.size() == 1) { Collection *collection_root = potential_root_collections.pop(); - RNA_property_int_set(op->ptr, op->type->prop, *((int *)&collection_root->id.session_uuid)); + RNA_property_int_set(op->ptr, op->type->prop, *((int *)&collection_root->id.session_uid)); return make_override_library_exec(C, op); } @@ -2677,11 +2677,11 @@ void OBJECT_OT_make_override_library(wmOperatorType *ot) PropertyRNA *prop; prop = RNA_def_int(ot->srna, "collection", - MAIN_ID_SESSION_UUID_UNSET, + MAIN_ID_SESSION_UID_UNSET, INT_MIN, INT_MAX, "Override Collection", - "Session UUID of the directly linked collection containing the selected " + "Session UID of the directly linked collection containing the selected " "object, to make an override from", INT_MIN, INT_MAX); @@ -2957,7 +2957,7 @@ static int drop_named_material_invoke(bContext *C, wmOperator *op, const wmEvent Object *ob = ED_view3d_give_material_slot_under_cursor(C, event->mval, &mat_slot); mat_slot = max_ii(mat_slot, 1); - Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uuid( + Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uid( bmain, op->ptr, ID_MA); if (ob == nullptr || ma == nullptr) { @@ -3007,8 +3007,8 @@ std::string ED_object_ot_drop_geometry_nodes_tooltip(bContext *C, return {}; } - const uint32_t session_uuid = RNA_int_get(properties, "session_uuid"); - const ID *id = BKE_libblock_find_session_uuid(CTX_data_main(C), ID_NT, session_uuid); + const uint32_t session_uid = RNA_int_get(properties, "session_uid"); + const ID *id = BKE_libblock_find_session_uid(CTX_data_main(C), ID_NT, session_uid); if (!id) { return {}; } @@ -3046,8 +3046,8 @@ static int drop_geometry_nodes_invoke(bContext *C, wmOperator *op, const wmEvent Main *bmain = CTX_data_main(C); Scene *scene = CTX_data_scene(C); - const uint32_t uuid = RNA_int_get(op->ptr, "session_uuid"); - bNodeTree *node_tree = (bNodeTree *)BKE_libblock_find_session_uuid(bmain, ID_NT, uuid); + const uint32_t uid = RNA_int_get(op->ptr, "session_uid"); + bNodeTree *node_tree = (bNodeTree *)BKE_libblock_find_session_uid(bmain, ID_NT, uid); if (!node_tree) { return OPERATOR_CANCELLED; } @@ -3092,12 +3092,12 @@ void OBJECT_OT_drop_geometry_nodes(wmOperatorType *ot) ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL; PropertyRNA *prop = RNA_def_int(ot->srna, - "session_uuid", + "session_uid", 0, INT32_MIN, INT32_MAX, - "Session UUID", - "Session UUID of the geometry node group being dropped", + "Session UID", + "Session UID of the geometry node group being dropped", INT32_MIN, INT32_MAX); RNA_def_property_flag(prop, (PropertyFlag)(PROP_HIDDEN | PROP_SKIP_SAVE)); diff --git a/source/blender/editors/space_node/node_add.cc b/source/blender/editors/space_node/node_add.cc index b6af6260b74..9355480e466 100644 --- a/source/blender/editors/space_node/node_add.cc +++ b/source/blender/editors/space_node/node_add.cc @@ -292,7 +292,7 @@ static int node_add_group_exec(bContext *C, wmOperator *op) bNodeTree *ntree = snode->edittree; bNodeTree *node_group = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_NT)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_NT)); if (!node_group) { return OPERATOR_CANCELLED; } @@ -511,7 +511,7 @@ static int node_add_object_exec(bContext *C, wmOperator *op) bNodeTree *ntree = snode->edittree; Object *object = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB)); if (!object) { return OPERATOR_CANCELLED; @@ -597,7 +597,7 @@ static int node_add_collection_exec(bContext *C, wmOperator *op) bNodeTree &ntree = *snode.edittree; Collection *collection = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_GR)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_GR)); if (!collection) { return OPERATOR_CANCELLED; @@ -808,7 +808,7 @@ static int node_add_mask_exec(bContext *C, wmOperator *op) Main *bmain = CTX_data_main(C); SpaceNode &snode = *CTX_wm_space_node(C); - ID *mask = WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_MSK); + ID *mask = WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_MSK); if (!mask) { return OPERATOR_CANCELLED; } @@ -861,7 +861,7 @@ static int node_add_material_exec(bContext *C, wmOperator *op) bNodeTree *ntree = snode->edittree; Material *material = reinterpret_cast( - WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_MA)); + WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_MA)); if (!material) { return OPERATOR_CANCELLED; diff --git a/source/blender/editors/space_node/space_node.cc b/source/blender/editors/space_node/space_node.cc index c63920df835..1bfea2c80f7 100644 --- a/source/blender/editors/space_node/space_node.cc +++ b/source/blender/editors/space_node/space_node.cc @@ -907,7 +907,7 @@ static void node_group_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, 0); - RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); + RNA_int_set(drop->ptr, "session_uid", int(id->session_uid)); RNA_boolean_set(drop->ptr, "show_datablock_in_node", (drag->type != WM_DRAG_ASSET)); } @@ -916,7 +916,7 @@ static void node_id_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, 0); - RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); + RNA_int_set(drop->ptr, "session_uid", int(id->session_uid)); } static void node_id_path_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop) @@ -924,7 +924,7 @@ static void node_id_path_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop) ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, 0); if (id) { - RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); + RNA_int_set(drop->ptr, "session_uid", int(id->session_uid)); RNA_struct_property_unset(drop->ptr, "filepath"); return; } diff --git a/source/blender/editors/space_outliner/outliner_draw.cc b/source/blender/editors/space_outliner/outliner_draw.cc index 7a31fe76a41..c71b3754188 100644 --- a/source/blender/editors/space_outliner/outliner_draw.cc +++ b/source/blender/editors/space_outliner/outliner_draw.cc @@ -1964,8 +1964,8 @@ static bool outliner_but_identity_cmp_context_id_fn(const uiBut *a, const uiBut const ID *id_a = (const ID *)idptr_a->data; const ID *id_b = (const ID *)idptr_b->data; - /* Using session UUID to compare is safer than using the pointer. */ - return id_a->session_uuid == id_b->session_uuid; + /* Using session UID to compare is safer than using the pointer. */ + return id_a->session_uid == id_b->session_uid; } static void outliner_draw_overrides_restrictbuts(Main *bmain, diff --git a/source/blender/editors/space_outliner/outliner_tools.cc b/source/blender/editors/space_outliner/outliner_tools.cc index 54f199cc007..72188001c22 100644 --- a/source/blender/editors/space_outliner/outliner_tools.cc +++ b/source/blender/editors/space_outliner/outliner_tools.cc @@ -1056,7 +1056,7 @@ struct OutlinerLibOverrideData { * solving broken overrides while not losing *all* of your overrides. */ bool do_resync_hierarchy_enforce; - /** A set of the selected tree elements' ID 'uuid'. Used to clear 'system override' flags on + /** A set of the selected tree elements' ID 'uid'. Used to clear 'system override' flags on * their newly-created liboverrides in post-process step of override hierarchy creation. */ Set selected_id_uid; @@ -1067,7 +1067,7 @@ struct OutlinerLibOverrideData { * override), or an actual already existing override. */ Map> id_hierarchy_roots; - /** All 'session_uuid' of all hierarchy root IDs used or created by the operation. */ + /** All 'session_uid' of all hierarchy root IDs used or created by the operation. */ Set id_hierarchy_roots_uid; void id_root_add(ID *id_hierarchy_root_reference, @@ -1125,10 +1125,10 @@ static void id_override_library_create_hierarchy_pre_process_fn(bContext *C, /* Only process a given ID once. Otherwise, all kind of weird things can happen if e.g. a * selected sub-collection is part of more than one override hierarchies. */ - if (data->selected_id_uid.contains(id_root_reference->session_uuid)) { + if (data->selected_id_uid.contains(id_root_reference->session_uid)) { return; } - data->selected_id_uid.add(id_root_reference->session_uuid); + data->selected_id_uid.add(id_root_reference->session_uid); if (ID_IS_OVERRIDE_LIBRARY_REAL(id_root_reference) && !ID_IS_LINKED(id_root_reference)) { id_root_reference->override_library->flag &= ~LIBOVERRIDE_FLAG_SYSTEM_DEFINED; @@ -1157,7 +1157,7 @@ static void id_override_library_create_hierarchy_pre_process_fn(bContext *C, Collection *root_collection = reinterpret_cast(id_root_reference); FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (root_collection, object_iter) { if (id_root_reference->lib == object_iter->id.lib && object_iter->type == OB_ARMATURE) { - data->selected_id_uid.add(object_iter->id.session_uuid); + data->selected_id_uid.add(object_iter->id.session_uid); } } FOREACH_COLLECTION_OBJECT_RECURSIVE_END; @@ -1357,7 +1357,7 @@ static void id_override_library_create_hierarchy( BLI_assert(id_hierarchy_root_override == id_hierarchy_root_reference); } data_idroot.id_hierarchy_root_override = id_hierarchy_root_override; - data.id_hierarchy_roots_uid.add(id_hierarchy_root_override->session_uuid); + data.id_hierarchy_roots_uid.add(id_hierarchy_root_override->session_uid); } } else if (ID_IS_OVERRIDABLE_LIBRARY(data_idroot.id_root_reference)) { @@ -1423,12 +1423,12 @@ static void id_override_library_create_hierarchy_process(bContext *C, } if (id_iter->override_library->hierarchy_root != nullptr && !data.id_hierarchy_roots_uid.contains( - id_iter->override_library->hierarchy_root->session_uuid)) + id_iter->override_library->hierarchy_root->session_uid)) { continue; } - if (data.selected_id_uid.contains(id_iter->override_library->reference->session_uuid) || - data.selected_id_uid.contains(id_iter->session_uuid)) + if (data.selected_id_uid.contains(id_iter->override_library->reference->session_uid) || + data.selected_id_uid.contains(id_iter->session_uid)) { id_iter->override_library->flag &= ~LIBOVERRIDE_FLAG_SYSTEM_DEFINED; } diff --git a/source/blender/editors/space_sequencer/sequencer_clipboard.cc b/source/blender/editors/space_sequencer/sequencer_clipboard.cc index e7070d9859f..d4a62093a21 100644 --- a/source/blender/editors/space_sequencer/sequencer_clipboard.cc +++ b/source/blender/editors/space_sequencer/sequencer_clipboard.cc @@ -350,7 +350,7 @@ int sequencer_clipboard_paste_exec(bContext *C, wmOperator *op) ListBase nseqbase = {nullptr, nullptr}; /* NOTE: SEQ_sequence_base_dupli_recursive() takes care of generating - * new UUIDs for sequences in the new list. */ + * new UIDs for sequences in the new list. */ SEQ_sequence_base_dupli_recursive( scene_src, scene_dst, &nseqbase, &scene_src->ed->seqbase, 0, 0); diff --git a/source/blender/editors/space_sequencer/sequencer_edit.cc b/source/blender/editors/space_sequencer/sequencer_edit.cc index a2bab7fd804..2f43aa4aa5f 100644 --- a/source/blender/editors/space_sequencer/sequencer_edit.cc +++ b/source/blender/editors/space_sequencer/sequencer_edit.cc @@ -1605,7 +1605,7 @@ static int sequencer_add_duplicate_exec(bContext *C, wmOperator * /*op*/) Sequence *seq = static_cast(duplicated_strips.first); /* Rely on the `duplicated_strips` list being added at the end. - * Their UUIDs has been re-generated by the #SEQ_sequence_base_dupli_recursive(). */ + * Their UIDs has been re-generated by the #SEQ_sequence_base_dupli_recursive(). */ BLI_movelisttolist(ed->seqbasep, &duplicated_strips); /* Handle duplicated strips: set active, select, ensure unique name and duplicate animation @@ -2004,7 +2004,7 @@ static int sequencer_meta_make_exec(bContext *C, wmOperator *op) Sequence *seqm = SEQ_sequence_alloc(active_seqbase, 1, 1, SEQ_TYPE_META); /* Remove all selected from main list, and put in meta. - * Sequence is moved within the same edit, no need to re-generate the UUID. */ + * Sequence is moved within the same edit, no need to re-generate the UID. */ LISTBASE_FOREACH_MUTABLE (Sequence *, seq, active_seqbase) { if (seq != seqm && seq->flag & SELECT) { BLI_remlink(active_seqbase, seq); @@ -2070,7 +2070,7 @@ static int sequencer_meta_separate_exec(bContext *C, wmOperator * /*op*/) } /* Remove all selected from meta, and put in main list. - * Sequence is moved within the same edit, no need to re-generate the UUID. */ + * Sequence is moved within the same edit, no need to re-generate the UID. */ BLI_movelisttolist(ed->seqbasep, &active_seq->seqbase); BLI_listbase_clear(&active_seq->seqbase); diff --git a/source/blender/editors/space_view3d/space_view3d.cc b/source/blender/editors/space_view3d/space_view3d.cc index b7c4f67ba69..dcdf237d12c 100644 --- a/source/blender/editors/space_view3d/space_view3d.cc +++ b/source/blender/editors/space_view3d/space_view3d.cc @@ -715,9 +715,9 @@ static bool view3d_geometry_nodes_drop_poll(bContext *C, wmDrag *drag, const wmE return false; } if (wmDropBox *drop_box = drag->drop_state.active_dropbox) { - const uint32_t uuid = RNA_int_get(drop_box->ptr, "session_uuid"); + const uint32_t uid = RNA_int_get(drop_box->ptr, "session_uid"); const bNodeTree *node_tree = reinterpret_cast( - BKE_libblock_find_session_uuid(CTX_data_main(C), ID_NT, uuid)); + BKE_libblock_find_session_uid(CTX_data_main(C), ID_NT, uid)); if (node_tree) { return node_tree->type == NTREE_GEOMETRY; } @@ -763,7 +763,7 @@ static void view3d_ob_drop_copy_local_id(bContext * /*C*/, wmDrag *drag, wmDropB { ID *id = WM_drag_get_local_ID(drag, ID_OB); - RNA_int_set(drop->ptr, "session_uuid", id->session_uuid); + RNA_int_set(drop->ptr, "session_uid", id->session_uid); /* Don't duplicate ID's which were just imported. Only do that for existing, local IDs. */ BLI_assert(drag->type != WM_DRAG_ASSET); @@ -797,7 +797,7 @@ static void view3d_ob_drop_copy_external_asset(bContext *C, wmDrag *drag, wmDrop DEG_relations_tag_update(CTX_data_main(C)); WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene); - RNA_int_set(drop->ptr, "session_uuid", id->session_uuid); + RNA_int_set(drop->ptr, "session_uid", id->session_uid); BKE_view_layer_synced_ensure(scene, view_layer); Base *base = BKE_view_layer_base_find(view_layer, (Object *)id); @@ -821,7 +821,7 @@ static void view3d_ob_drop_copy_external_asset(bContext *C, wmDrag *drag, wmDrop static void view3d_collection_drop_copy_local_id(bContext * /*C*/, wmDrag *drag, wmDropBox *drop) { ID *id = WM_drag_get_local_ID(drag, ID_GR); - RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); + RNA_int_set(drop->ptr, "session_uid", int(id->session_uid)); } /* Mostly the same logic as #view3d_ob_drop_copy_external_asset(), just different enough to make @@ -843,7 +843,7 @@ static void view3d_collection_drop_copy_external_asset(bContext *C, wmDrag *drag DEG_relations_tag_update(CTX_data_main(C)); WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene); - RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid)); + RNA_int_set(drop->ptr, "session_uid", int(id->session_uid)); /* Make an object active, just use the first one in the collection. */ CollectionObject *cobject = static_cast(collection->gobject.first); diff --git a/source/blender/editors/space_view3d/view3d_edit.cc b/source/blender/editors/space_view3d/view3d_edit.cc index 7ed51ba546f..161e0a97b21 100644 --- a/source/blender/editors/space_view3d/view3d_edit.cc +++ b/source/blender/editors/space_view3d/view3d_edit.cc @@ -692,7 +692,7 @@ static int drop_world_exec(bContext *C, wmOperator *op) Main *bmain = CTX_data_main(C); Scene *scene = CTX_data_scene(C); - World *world = (World *)WM_operator_properties_id_lookup_from_name_or_session_uuid( + World *world = (World *)WM_operator_properties_id_lookup_from_name_or_session_uid( bmain, op->ptr, ID_WO); if (world == nullptr) { return OPERATOR_CANCELLED; diff --git a/source/blender/editors/undo/memfile_undo.cc b/source/blender/editors/undo/memfile_undo.cc index fa61e8e5d31..afb361ef731 100644 --- a/source/blender/editors/undo/memfile_undo.cc +++ b/source/blender/editors/undo/memfile_undo.cc @@ -375,7 +375,7 @@ void ED_undosys_stack_memfile_id_changed_tag(UndoStack *ustack, ID *id) MemFile *memfile = &((MemFileUndoStep *)us)->data->memfile; LISTBASE_FOREACH (MemFileChunk *, mem_chunk, &memfile->chunks) { - if (mem_chunk->id_session_uuid == id->session_uuid) { + if (mem_chunk->id_session_uid == id->session_uid) { mem_chunk->is_identical_future = false; break; } diff --git a/source/blender/makesdna/DNA_ID.h b/source/blender/makesdna/DNA_ID.h index 23ee67b2a84..78f84409ca6 100644 --- a/source/blender/makesdna/DNA_ID.h +++ b/source/blender/makesdna/DNA_ID.h @@ -493,7 +493,7 @@ typedef struct ID { * A session-wide unique identifier for a given ID, that remain the same across potential * re-allocations (e.g. due to undo/redo steps). */ - unsigned int session_uuid; + unsigned int session_uid; IDProperty *properties; @@ -914,7 +914,7 @@ enum { * processing, because it is a 'NO_UNDO' type of ID. * * \note: Also means that such ID does not need to be lib-linked during undo readfile process. It - * does need to be relinked in a different way however, doing a `session_uuid`-based lookup into + * does need to be relinked in a different way however, doing a `session_uid`-based lookup into * the newly read main database. * * RESET_AFTER_USE @@ -941,7 +941,7 @@ enum { * RESET_NEVER * * Don't allow assigning this to non-temporary members (since it's likely to cause errors). - * When set #ID.session_uuid isn't initialized, since the data isn't part of the session. + * When set #ID.session_uid isn't initialized, since the data isn't part of the session. */ LIB_TAG_TEMP_MAIN = 1 << 20, /** General ID management info, for freeing or copying behavior e.g. */ diff --git a/source/blender/makesdna/DNA_action_types.h b/source/blender/makesdna/DNA_action_types.h index 84cf5f62898..b18bf5dd5a6 100644 --- a/source/blender/makesdna/DNA_action_types.h +++ b/source/blender/makesdna/DNA_action_types.h @@ -15,7 +15,7 @@ #include "DNA_ID.h" #include "DNA_armature_types.h" #include "DNA_listBase.h" -#include "DNA_session_uuid_types.h" +#include "DNA_session_uid_types.h" #include "DNA_userdef_types.h" /* ThemeWireColor */ #include "DNA_vec_types.h" #include "DNA_view2d_types.h" @@ -197,7 +197,7 @@ typedef struct bPoseChannel_BBoneSegmentBoundary { } bPoseChannel_BBoneSegmentBoundary; typedef struct bPoseChannel_Runtime { - SessionUUID session_uuid; + SessionUID session_uid; /* Cached dual quaternion for deformation. */ struct DualQuat deform_dual_quat; diff --git a/source/blender/makesdna/DNA_mesh_types.h b/source/blender/makesdna/DNA_mesh_types.h index c0e948999a2..ff718c55205 100644 --- a/source/blender/makesdna/DNA_mesh_types.h +++ b/source/blender/makesdna/DNA_mesh_types.h @@ -11,7 +11,7 @@ #include "DNA_ID.h" #include "DNA_customdata_types.h" #include "DNA_defs.h" -#include "DNA_session_uuid_types.h" +#include "DNA_session_uid_types.h" /** Workaround to forward-declare C++ type in C header. */ #ifdef __cplusplus diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h index a22aa241220..9f2f2f6d201 100644 --- a/source/blender/makesdna/DNA_modifier_types.h +++ b/source/blender/makesdna/DNA_modifier_types.h @@ -12,7 +12,7 @@ #include "DNA_defs.h" #include "DNA_listBase.h" -#include "DNA_session_uuid_types.h" +#include "DNA_session_uid_types.h" #ifdef __cplusplus namespace blender { @@ -138,7 +138,7 @@ typedef struct ModifierData { char *error; /** Runtime field which contains unique identifier of the modifier. */ - SessionUUID session_uuid; + SessionUID session_uid; /** Runtime field which contains runtime data which is specific to a modifier type. */ void *runtime; diff --git a/source/blender/makesdna/DNA_sequence_types.h b/source/blender/makesdna/DNA_sequence_types.h index f33b2349cc1..4aeed151a02 100644 --- a/source/blender/makesdna/DNA_sequence_types.h +++ b/source/blender/makesdna/DNA_sequence_types.h @@ -18,8 +18,8 @@ #include "DNA_color_types.h" #include "DNA_defs.h" #include "DNA_listBase.h" -#include "DNA_session_uuid_types.h" /* for #SessionUUID */ -#include "DNA_vec_types.h" /* for #rctf */ +#include "DNA_session_uid_types.h" /* for #SessionUID */ +#include "DNA_vec_types.h" /* for #rctf */ struct Ipo; struct MovieClip; @@ -139,7 +139,7 @@ typedef struct SeqRetimingKey { } SeqRetimingKey; typedef struct SequenceRuntime { - SessionUUID session_uuid; + SessionUID session_uid; } SequenceRuntime; /** diff --git a/source/blender/makesdna/DNA_session_uuid_types.h b/source/blender/makesdna/DNA_session_uid_types.h similarity index 92% rename from source/blender/makesdna/DNA_session_uuid_types.h rename to source/blender/makesdna/DNA_session_uid_types.h index a68dcdb414d..3e3f380f067 100644 --- a/source/blender/makesdna/DNA_session_uuid_types.h +++ b/source/blender/makesdna/DNA_session_uid_types.h @@ -17,10 +17,10 @@ * - It allows to add more bits, more than standard fixed-size types can store. For example, if * we ever need to go 128 bits, it is as simple as adding extra 64bit field. */ -typedef struct SessionUUID { +typedef struct SessionUID { /** * Never access directly, as it might cause a headache when more bits are needed: if the field * is used directly it will not be easy to find all places where partial access is used. */ - uint64_t uuid_; -} SessionUUID; + uint64_t uid_; +} SessionUID; diff --git a/source/blender/makesrna/intern/rna_ID.cc b/source/blender/makesrna/intern/rna_ID.cc index a38c0452fd3..c808e1c0afd 100644 --- a/source/blender/makesrna/intern/rna_ID.cc +++ b/source/blender/makesrna/intern/rna_ID.cc @@ -2196,7 +2196,6 @@ static void rna_def_ID(BlenderRNA *brna) RNA_def_property_override_flag(prop, PROPOVERRIDE_IGNORE); prop = RNA_def_property(srna, "session_uid", PROP_INT, PROP_NONE); - RNA_def_property_int_sdna(prop, nullptr, "session_uuid"); RNA_def_property_ui_text( prop, "Session UID", diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc index 933b0723fdf..b403b8cb257 100644 --- a/source/blender/modifiers/intern/MOD_nodes.cc +++ b/source/blender/modifiers/intern/MOD_nodes.cc @@ -1565,7 +1565,7 @@ static NodesModifierData *get_modifier_data(Main &bmain, return nullptr; } - const Object *object = (Object *)BKE_libblock_find_session_uuid( + const Object *object = (Object *)BKE_libblock_find_session_uid( &bmain, ID_OB, data.object_session_uid); if (object == nullptr) { return nullptr; @@ -1702,7 +1702,7 @@ static void add_attribute_search_button(const bContext &C, } AttributeSearchData *data = MEM_new(__func__); - data->object_session_uid = object->id.session_uuid; + data->object_session_uid = object->id.session_uid; STRNCPY(data->modifier_name, nmd.modifier.name); STRNCPY(data->socket_identifier, socket.identifier); data->is_output = is_output; diff --git a/source/blender/sequencer/SEQ_relations.hh b/source/blender/sequencer/SEQ_relations.hh index 11234d50085..bd4a8e7c687 100644 --- a/source/blender/sequencer/SEQ_relations.hh +++ b/source/blender/sequencer/SEQ_relations.hh @@ -44,14 +44,14 @@ void SEQ_relations_invalidate_cache_in_range(Scene *scene, */ void SEQ_relations_free_all_anim_ibufs(Scene *scene, int timeline_frame); /** - * A debug and development function which checks whether sequences have unique UUIDs. + * A debug and development function which checks whether sequences have unique UIDs. * Errors will be reported to the console. */ -void SEQ_relations_check_uuids_unique_and_report(const Scene *scene); +void SEQ_relations_check_uids_unique_and_report(const Scene *scene); /** - * Generate new UUID for the given sequence. + * Generate new UID for the given sequence. */ -void SEQ_relations_session_uuid_generate(Sequence *sequence); +void SEQ_relations_session_uid_generate(Sequence *sequence); void SEQ_cache_cleanup(Scene *scene); void SEQ_cache_iterate( diff --git a/source/blender/sequencer/intern/proxy.cc b/source/blender/sequencer/intern/proxy.cc index 663fa7a83da..de1ae2e2465 100644 --- a/source/blender/sequencer/intern/proxy.cc +++ b/source/blender/sequencer/intern/proxy.cc @@ -18,7 +18,7 @@ #include "BLI_fileops.h" #include "BLI_listbase.h" #include "BLI_path_util.h" -#include "BLI_session_uuid.h" +#include "BLI_session_uid.h" #include "BLI_string.h" #ifdef WIN32 @@ -67,7 +67,7 @@ struct SeqIndexBuildContext { Depsgraph *depsgraph; Scene *scene; Sequence *seq, *orig_seq; - SessionUUID orig_seq_uuid; + SessionUID orig_seq_uid; }; int SEQ_rendersize_to_proxysize(int render_size) @@ -477,7 +477,7 @@ bool SEQ_proxy_rebuild_context(Main *bmain, context->depsgraph = depsgraph; context->scene = scene; context->orig_seq = seq; - context->orig_seq_uuid = seq->runtime.session_uuid; + context->orig_seq_uid = seq->runtime.session_uid; context->seq = nseq; context->view_id = i; /* only for images */ diff --git a/source/blender/sequencer/intern/sequencer.cc b/source/blender/sequencer/intern/sequencer.cc index f133a2e7b9a..00e7c94998f 100644 --- a/source/blender/sequencer/intern/sequencer.cc +++ b/source/blender/sequencer/intern/sequencer.cc @@ -155,7 +155,7 @@ Sequence *SEQ_sequence_alloc(ListBase *lb, int timeline_frame, int machine, int SEQ_channels_ensure(&seq->channels); } - SEQ_relations_session_uuid_generate(seq); + SEQ_relations_session_uid_generate(seq); return seq; } @@ -488,7 +488,7 @@ static Sequence *seq_dupli(const Scene *scene_src, Sequence *seqn = static_cast(MEM_dupallocN(seq)); if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { - SEQ_relations_session_uuid_generate(seqn); + SEQ_relations_session_uid_generate(seqn); } seq->tmp = seqn; @@ -788,8 +788,8 @@ static bool seq_read_data_cb(Sequence *seq, void *user_data) BLI_listbase_clear(&seq->anims); seq->flag &= ~SEQ_FLAG_SKIP_THUMBNAILS; - /* Do as early as possible, so that other parts of reading can rely on valid session UUID. */ - SEQ_relations_session_uuid_generate(seq); + /* Do as early as possible, so that other parts of reading can rely on valid session UID. */ + SEQ_relations_session_uid_generate(seq); BLO_read_data_address(reader, &seq->seq1); BLO_read_data_address(reader, &seq->seq2); diff --git a/source/blender/sequencer/intern/strip_relations.cc b/source/blender/sequencer/intern/strip_relations.cc index a9e7a633214..58d0c1d5415 100644 --- a/source/blender/sequencer/intern/strip_relations.cc +++ b/source/blender/sequencer/intern/strip_relations.cc @@ -14,7 +14,7 @@ #include "BLI_ghash.h" #include "BLI_listbase.h" #include "BLI_math_base.h" -#include "BLI_session_uuid.h" +#include "BLI_session_uid.h" #include "BKE_main.hh" #include "BKE_report.h" @@ -408,41 +408,41 @@ void SEQ_relations_sequence_free_anim(Sequence *seq) BLI_listbase_clear(&seq->anims); } -void SEQ_relations_session_uuid_generate(Sequence *sequence) +void SEQ_relations_session_uid_generate(Sequence *sequence) { - sequence->runtime.session_uuid = BLI_session_uuid_generate(); + sequence->runtime.session_uid = BLI_session_uid_generate(); } -static bool get_uuids_cb(Sequence *seq, void *user_data) +static bool get_uids_cb(Sequence *seq, void *user_data) { - GSet *used_uuids = (GSet *)user_data; - const SessionUUID *session_uuid = &seq->runtime.session_uuid; - if (!BLI_session_uuid_is_generated(session_uuid)) { - printf("Sequence %s does not have UUID generated.\n", seq->name); + GSet *used_uids = (GSet *)user_data; + const SessionUID *session_uid = &seq->runtime.session_uid; + if (!BLI_session_uid_is_generated(session_uid)) { + printf("Sequence %s does not have UID generated.\n", seq->name); return true; } - if (BLI_gset_lookup(used_uuids, session_uuid) != nullptr) { - printf("Sequence %s has duplicate UUID generated.\n", seq->name); + if (BLI_gset_lookup(used_uids, session_uid) != nullptr) { + printf("Sequence %s has duplicate UID generated.\n", seq->name); return true; } - BLI_gset_insert(used_uuids, (void *)session_uuid); + BLI_gset_insert(used_uids, (void *)session_uid); return true; } -void SEQ_relations_check_uuids_unique_and_report(const Scene *scene) +void SEQ_relations_check_uids_unique_and_report(const Scene *scene) { if (scene->ed == nullptr) { return; } - GSet *used_uuids = BLI_gset_new( - BLI_session_uuid_ghash_hash, BLI_session_uuid_ghash_compare, "sequencer used uuids"); + GSet *used_uids = BLI_gset_new( + BLI_session_uid_ghash_hash, BLI_session_uid_ghash_compare, "sequencer used uids"); - SEQ_for_each_callback(&scene->ed->seqbase, get_uuids_cb, used_uuids); + SEQ_for_each_callback(&scene->ed->seqbase, get_uids_cb, used_uids); - BLI_gset_free(used_uuids, nullptr); + BLI_gset_free(used_uids, nullptr); } Sequence *SEQ_find_metastrip_by_sequence(ListBase *seqbase, Sequence *meta, Sequence *seq) diff --git a/source/blender/windowmanager/WM_api.hh b/source/blender/windowmanager/WM_api.hh index eb3a0a902c4..c2df28cdea3 100644 --- a/source/blender/windowmanager/WM_api.hh +++ b/source/blender/windowmanager/WM_api.hh @@ -901,33 +901,33 @@ void WM_operator_properties_filesel(wmOperatorType *ot, short sort); /** - * Tries to pass \a id to an operator via either a "session_uuid" or a "name" property defined in + * Tries to pass \a id to an operator via either a "session_uid" or a "name" property defined in * the properties of \a ptr. The former is preferred, since it works properly with linking and * library overrides (which may both result in multiple IDs with the same name and type). * * Also see #WM_operator_properties_id_lookup() and - * #WM_operator_properties_id_lookup_from_name_or_session_uuid() + * #WM_operator_properties_id_lookup_from_name_or_session_uid() */ void WM_operator_properties_id_lookup_set_from_id(PointerRNA *ptr, const ID *id); /** - * Tries to find an ID in \a bmain. There needs to be either a "session_uuid" int or "name" string + * Tries to find an ID in \a bmain. There needs to be either a "session_uid" int or "name" string * property defined and set. The former has priority. See #WM_operator_properties_id_lookup() for a * helper to add the properties. */ -ID *WM_operator_properties_id_lookup_from_name_or_session_uuid(Main *bmain, - PointerRNA *ptr, - enum ID_Type type); +ID *WM_operator_properties_id_lookup_from_name_or_session_uid(Main *bmain, + PointerRNA *ptr, + enum ID_Type type); /** - * Check if either the "session_uuid" or "name" property is set inside \a ptr. If this is the case - * the ID can be looked up by #WM_operator_properties_id_lookup_from_name_or_session_uuid(). + * Check if either the "session_uid" or "name" property is set inside \a ptr. If this is the case + * the ID can be looked up by #WM_operator_properties_id_lookup_from_name_or_session_uid(). */ bool WM_operator_properties_id_lookup_is_set(PointerRNA *ptr); /** - * Adds "name" and "session_uuid" properties so the caller can tell the operator which ID to act - * on. See #WM_operator_properties_id_lookup_from_name_or_session_uuid(). Both properties will be + * Adds "name" and "session_uid" properties so the caller can tell the operator which ID to act + * on. See #WM_operator_properties_id_lookup_from_name_or_session_uid(). Both properties will be * hidden in the UI and not be saved over consecutive operator calls. * - * \note New operators should probably use "session_uuid" only (set \a add_name_prop to #false), + * \note New operators should probably use "session_uid" only (set \a add_name_prop to #false), * since this works properly with linked data and/or library overrides (in both cases, multiple IDs * with the same name and type may be present). The "name" property is only kept to not break * compatibility with old scripts using some previously existing operators. diff --git a/source/blender/windowmanager/intern/wm_dragdrop.cc b/source/blender/windowmanager/intern/wm_dragdrop.cc index e975498891d..2c6b3296862 100644 --- a/source/blender/windowmanager/intern/wm_dragdrop.cc +++ b/source/blender/windowmanager/intern/wm_dragdrop.cc @@ -782,9 +782,9 @@ void WM_drag_free_imported_drag_ID(Main *bmain, wmDrag *drag, wmDropBox *drop) } ID_Type asset_id_type = asset_drag->asset->get_id_type(); - /* Try to find the imported ID. For this to work either a "session_uuid" or "name" property must + /* Try to find the imported ID. For this to work either a "session_uid" or "name" property must * have been defined (see #WM_operator_properties_id_lookup()). */ - ID *id = WM_operator_properties_id_lookup_from_name_or_session_uuid( + ID *id = WM_operator_properties_id_lookup_from_name_or_session_uid( bmain, drop->ptr, asset_id_type); if (id != nullptr) { /* Do not delete the dragged ID if it has any user, otherwise if it is a 're-used' ID it will diff --git a/source/blender/windowmanager/intern/wm_operator_props.cc b/source/blender/windowmanager/intern/wm_operator_props.cc index 3f1faba68f9..f7096c7f697 100644 --- a/source/blender/windowmanager/intern/wm_operator_props.cc +++ b/source/blender/windowmanager/intern/wm_operator_props.cc @@ -228,11 +228,11 @@ void WM_operator_properties_filesel(wmOperatorType *ot, void WM_operator_properties_id_lookup_set_from_id(PointerRNA *ptr, const ID *id) { - PropertyRNA *prop_session_uuid = RNA_struct_find_property(ptr, "session_uuid"); + PropertyRNA *prop_session_uid = RNA_struct_find_property(ptr, "session_uid"); PropertyRNA *prop_name = RNA_struct_find_property(ptr, "name"); - if (prop_session_uuid) { - RNA_int_set(ptr, "session_uuid", int(id->session_uuid)); + if (prop_session_uid) { + RNA_int_set(ptr, "session_uid", int(id->session_uid)); } else if (prop_name) { RNA_string_set(ptr, "name", id->name + 2); @@ -242,14 +242,14 @@ void WM_operator_properties_id_lookup_set_from_id(PointerRNA *ptr, const ID *id) } } -ID *WM_operator_properties_id_lookup_from_name_or_session_uuid(Main *bmain, - PointerRNA *ptr, - const ID_Type type) +ID *WM_operator_properties_id_lookup_from_name_or_session_uid(Main *bmain, + PointerRNA *ptr, + const ID_Type type) { - PropertyRNA *prop_session_uuid = RNA_struct_find_property(ptr, "session_uuid"); - if (prop_session_uuid && RNA_property_is_set(ptr, prop_session_uuid)) { - const uint32_t session_uuid = uint32_t(RNA_property_int_get(ptr, prop_session_uuid)); - return BKE_libblock_find_session_uuid(bmain, type, session_uuid); + PropertyRNA *prop_session_uid = RNA_struct_find_property(ptr, "session_uid"); + if (prop_session_uid && RNA_property_is_set(ptr, prop_session_uid)) { + const uint32_t session_uid = uint32_t(RNA_property_int_get(ptr, prop_session_uid)); + return BKE_libblock_find_session_uid(bmain, type, session_uid); } PropertyRNA *prop_name = RNA_struct_find_property(ptr, "name"); @@ -264,8 +264,7 @@ ID *WM_operator_properties_id_lookup_from_name_or_session_uuid(Main *bmain, bool WM_operator_properties_id_lookup_is_set(PointerRNA *ptr) { - return RNA_struct_property_is_set(ptr, "session_uuid") || - RNA_struct_property_is_set(ptr, "name"); + return RNA_struct_property_is_set(ptr, "session_uid") || RNA_struct_property_is_set(ptr, "name"); } void WM_operator_properties_id_lookup(wmOperatorType *ot, const bool add_name_prop) @@ -283,12 +282,12 @@ void WM_operator_properties_id_lookup(wmOperatorType *ot, const bool add_name_pr } prop = RNA_def_int(ot->srna, - "session_uuid", + "session_uid", 0, INT32_MIN, INT32_MAX, - "Session UUID", - "Session UUID of the data-block to use by the operator", + "Session UID", + "Session UID of the data-block to use by the operator", INT32_MIN, INT32_MAX); RNA_def_property_flag(prop, (PropertyFlag)(PROP_SKIP_SAVE | PROP_HIDDEN)); diff --git a/source/blender/windowmanager/intern/wm_operators.cc b/source/blender/windowmanager/intern/wm_operators.cc index 3bfd88cdbcc..4d2e1d66dfc 100644 --- a/source/blender/windowmanager/intern/wm_operators.cc +++ b/source/blender/windowmanager/intern/wm_operators.cc @@ -1564,7 +1564,7 @@ ID *WM_operator_drop_load_path(bContext *C, wmOperator *op, const short idcode) } /* Lookup an already existing ID. */ - id = WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_Type(idcode)); + id = WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_Type(idcode)); if (!id) { /* Print error with the name if the name is available. */ diff --git a/source/creator/creator_args.cc b/source/creator/creator_args.cc index da26e3bc45c..43d89cdf32b 100644 --- a/source/creator/creator_args.cc +++ b/source/creator/creator_args.cc @@ -659,7 +659,7 @@ static void print_help(bArgs *ba, bool all) BLI_args_print_arg_doc(ba, "--debug-depsgraph-no-threads"); BLI_args_print_arg_doc(ba, "--debug-depsgraph-time"); BLI_args_print_arg_doc(ba, "--debug-depsgraph-pretty"); - BLI_args_print_arg_doc(ba, "--debug-depsgraph-uuid"); + BLI_args_print_arg_doc(ba, "--debug-depsgraph-uid"); BLI_args_print_arg_doc(ba, "--debug-ghost"); BLI_args_print_arg_doc(ba, "--debug-wintab"); BLI_args_print_arg_doc(ba, "--debug-gpu"); @@ -1107,7 +1107,7 @@ static const char arg_handle_debug_mode_generic_set_doc_depsgraph_no_threads[] = static const char arg_handle_debug_mode_generic_set_doc_depsgraph_pretty[] = "\n\t" "Enable colors for dependency graph debug messages."; -static const char arg_handle_debug_mode_generic_set_doc_depsgraph_uuid[] = +static const char arg_handle_debug_mode_generic_set_doc_depsgraph_uid[] = "\n\t" "Verify validness of session-wide identifiers assigned to ID datablocks."; static const char arg_handle_debug_mode_generic_set_doc_gpu_force_workarounds[] = @@ -2461,9 +2461,9 @@ void main_args_setup(bContext *C, bArgs *ba, bool all) (void *)G_DEBUG_DEPSGRAPH_PRETTY); BLI_args_add(ba, nullptr, - "--debug-depsgraph-uuid", - CB_EX(arg_handle_debug_mode_generic_set, depsgraph_uuid), - (void *)G_DEBUG_DEPSGRAPH_UUID); + "--debug-depsgraph-uid", + CB_EX(arg_handle_debug_mode_generic_set, depsgraph_uid), + (void *)G_DEBUG_DEPSGRAPH_UID); BLI_args_add(ba, nullptr, "--debug-gpu-force-workarounds",