blendfile_link_append.cc

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#include <algorithm>
#include <cstdlib>
#include <cstring>
 
#include "CLG_log.h"
 
#include "MEM_guardedalloc.h"
 
#include "DNA_ID.h"
#include "DNA_collection_types.h"
#include "DNA_gpencil_legacy_types.h"
#include "DNA_key_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_space_types.h"
#include "DNA_userdef_types.h"
 
#include "BLI_linklist.h"
#include "BLI_listbase.h"
#include "BLI_math_vector.h"
#include "BLI_set.hh"
#include "BLI_string.h"
#include "BLI_string_ref.hh"
#include "BLI_utildefines.h"
#include "BLI_vector.hh"
 
#include "BLT_translation.hh"
 
#include "RNA_access.hh"
#include "RNA_prototypes.hh"
 
#include "BKE_callbacks.hh"
#include "BKE_grease_pencil_legacy_convert.hh"
#include "BKE_idtype.hh"
#include "BKE_key.hh"
#include "BKE_layer.hh"
#include "BKE_lib_id.hh"
#include "BKE_lib_override.hh"
#include "BKE_lib_query.hh"
#include "BKE_lib_remap.hh"
#include "BKE_library.hh"
#include "BKE_main.hh"
#include "BKE_main_namemap.hh"
#include "BKE_material.hh"
#include "BKE_mesh_legacy_convert.hh"
#include "BKE_object.hh"
#include "BKE_report.hh"
#include "BKE_rigidbody.h"
#include "BKE_scene.hh"
 
#include "BKE_blendfile_link_append.hh"
 
#include "BLO_writefile.hh"
 
static CLG_LogRef LOG = {"bke.blendfile_link_append"};
 
using namespace blender::bke;
 
/* -------------------------------------------------------------------- */
 
struct BlendfileLinkAppendContextCallBack {
  BlendfileLinkAppendContext *lapp_context;
  BlendfileLinkAppendContextItem *item;
  ReportList *reports;

  bool is_liboverride_dependency;
  bool is_liboverride_dependency_only;
};
 
static BlendHandle *link_append_context_library_blohandle_ensure(
    BlendfileLinkAppendContext &lapp_context,
    BlendfileLinkAppendContextLibrary &lib_context,
    ReportList *reports)
{
  if (reports != nullptr) {
    lib_context.bf_reports.reports = reports;
  }
 
  const blender::StringRefNull libname = lib_context.path;
  BlendHandle *blo_handle = lib_context.blo_handle;
  if (blo_handle == nullptr) {
    if (libname == BLO_EMBEDDED_STARTUP_BLEND) {
      blo_handle = BLO_blendhandle_from_memory(lapp_context.blendfile_mem,
                                               int(lapp_context.blendfile_memsize),
                                               &lib_context.bf_reports);
    }
    else {
      blo_handle = BLO_blendhandle_from_file(libname.c_str(), &lib_context.bf_reports);
    }
    lib_context.blo_handle = blo_handle;
    lib_context.blo_handle_is_owned = true;
  }
 
  return blo_handle;
}
 
static void link_append_context_library_blohandle_release(
    BlendfileLinkAppendContext & /*lapp_context*/, BlendfileLinkAppendContextLibrary &lib_context)
{
  if (lib_context.blo_handle_is_owned && lib_context.blo_handle != nullptr) {
    BLO_blendhandle_close(lib_context.blo_handle);
    lib_context.blo_handle = nullptr;
  }
}
 
BlendfileLinkAppendContext *BKE_blendfile_link_append_context_new(LibraryLink_Params *params)
{
  BlendfileLinkAppendContext *lapp_context = MEM_new<BlendfileLinkAppendContext>(__func__);
  lapp_context->params = params;
  lapp_context->process_stage = BlendfileLinkAppendContext::ProcessStage::Init;
  return lapp_context;
}
 
void BKE_blendfile_link_append_context_free(BlendfileLinkAppendContext *lapp_context)
{
  for (BlendfileLinkAppendContextLibrary &lib_context : lapp_context->libraries) {
    link_append_context_library_blohandle_release(*lapp_context, lib_context);
  }
 
  BLI_assert(lapp_context->library_weak_reference_mapping == nullptr);
 
  MEM_delete(lapp_context);
}
 
void BKE_blendfile_link_append_context_flag_set(BlendfileLinkAppendContext *lapp_context,
                                                const int flag,
                                                const bool do_set)
{
  if (do_set) {
    lapp_context->params->flag |= flag;
  }
  else {
    lapp_context->params->flag &= ~flag;
  }
}
 
void BKE_blendfile_link_append_context_embedded_blendfile_set(
    BlendfileLinkAppendContext *lapp_context, const void *blendfile_mem, int blendfile_memsize)
{
  BLI_assert_msg(lapp_context->blendfile_mem == nullptr,
                 "Please explicitly clear reference to an embedded blender memfile before "
                 "setting a new one");
  lapp_context->blendfile_mem = blendfile_mem;
  lapp_context->blendfile_memsize = size_t(blendfile_memsize);
}
 
void BKE_blendfile_link_append_context_embedded_blendfile_clear(
    BlendfileLinkAppendContext *lapp_context)
{
  lapp_context->blendfile_mem = nullptr;
  lapp_context->blendfile_memsize = 0;
}
 
void BKE_blendfile_link_append_context_library_add(BlendfileLinkAppendContext *lapp_context,
                                                   const char *libname,
                                                   BlendHandle *blo_handle)
{
  BLI_assert(lapp_context->items.empty());
  BLI_assert(lapp_context->process_stage == BlendfileLinkAppendContext::ProcessStage::Init);
 
  BlendfileLinkAppendContextLibrary lib_context = {};
 
  lib_context.path = libname;
  lib_context.blo_handle = blo_handle;
  /* Always steal the ownership on the blendfile handle, as it may be freed by readfile code in
   * case of endianness conversion. */
  lib_context.blo_handle_is_owned = true;
 
  lapp_context->libraries.append(lib_context);
}
 
BlendfileLinkAppendContextItem *BKE_blendfile_link_append_context_item_add(
    BlendfileLinkAppendContext *lapp_context,
    const char *idname,
    const short idcode,
    void *userdata)
{
  BlendfileLinkAppendContextItem item = {};
 
  item.lapp_context = lapp_context;
 
  item.name = idname;
  item.idcode = idcode;
  item.libraries = blender::BitVector<>(lapp_context->libraries.size(), false);
 
  item.new_id = nullptr;
  item.action = LINK_APPEND_ACT_UNSET;
  item.userdata = userdata;
 
  lapp_context->items.push_back(item);
 
  return &lapp_context->items.back();
}
 
int BKE_blendfile_link_append_context_item_idtypes_from_library_add(
    BlendfileLinkAppendContext *lapp_context,
    ReportList *reports,
    const uint64_t id_types_filter,
    const int library_index)
{
  BLI_assert(lapp_context->process_stage == BlendfileLinkAppendContext::ProcessStage::Init);
 
  int id_num = 0;
  int id_code_iter = 0;
  short id_code;
 
  BlendfileLinkAppendContextLibrary &lib_context = lapp_context->libraries[library_index];
  BlendHandle *blo_handle = link_append_context_library_blohandle_ensure(
      *lapp_context, lib_context, reports);
 
  if (blo_handle == nullptr) {
    return BLENDFILE_LINK_APPEND_INVALID;
  }
 
  const bool use_assets_only = (lapp_context->params->flag & FILE_ASSETS_ONLY) != 0;
 
  while ((id_code = BKE_idtype_idcode_iter_step(&id_code_iter))) {
    if (!BKE_idtype_idcode_is_linkable(id_code) ||
        (id_types_filter != 0 && (BKE_idtype_idcode_to_idfilter(id_code) & id_types_filter) == 0))
    {
      continue;
    }
 
    int id_names_num;
    LinkNode *id_names_list = BLO_blendhandle_get_datablock_names(
        blo_handle, id_code, use_assets_only, &id_names_num);
 
    for (LinkNode *link_next = nullptr; id_names_list != nullptr; id_names_list = link_next) {
      link_next = id_names_list->next;
 
      char *id_name = static_cast<char *>(id_names_list->link);
      BlendfileLinkAppendContextItem *item = BKE_blendfile_link_append_context_item_add(
          lapp_context, id_name, id_code, nullptr);
      BKE_blendfile_link_append_context_item_library_index_enable(
          lapp_context, item, library_index);
 
      MEM_freeN(id_name);
      MEM_freeN(id_names_list);
    }
 
    id_num += id_names_num;
  }
 
  return id_num;
}
 
void BKE_blendfile_link_append_context_item_library_index_enable(
    BlendfileLinkAppendContext *lapp_context,
    BlendfileLinkAppendContextItem *item,
    const int library_index)
{
  BLI_assert(lapp_context->process_stage == BlendfileLinkAppendContext::ProcessStage::Init);
  UNUSED_VARS_NDEBUG(lapp_context);
  item->libraries[library_index].set();
}
 
bool BKE_blendfile_link_append_context_is_empty(BlendfileLinkAppendContext *lapp_context)
{
  return lapp_context->items.empty();
}
 
void *BKE_blendfile_link_append_context_item_userdata_get(
    BlendfileLinkAppendContext * /*lapp_context*/, BlendfileLinkAppendContextItem *item)
{
  return item->userdata;
}
 
ID *BKE_blendfile_link_append_context_item_newid_get(BlendfileLinkAppendContext *lapp_context,
                                                     BlendfileLinkAppendContextItem *item)
{
  BLI_assert(lapp_context->process_stage != BlendfileLinkAppendContext::ProcessStage::Init);
  UNUSED_VARS_NDEBUG(lapp_context);
  return item->new_id;
}
 
void BKE_blendfile_link_append_context_item_newid_set(BlendfileLinkAppendContext *lapp_context,
                                                      BlendfileLinkAppendContextItem *item,
                                                      ID *new_id)
{
  BLI_assert(lapp_context->process_stage != BlendfileLinkAppendContext::ProcessStage::Init);
  BLI_assert(item->new_id);
  BLI_assert(!item->liboverride_id);
  BLI_assert(new_id->lib == item->new_id->lib);
  BLI_assert(!lapp_context->new_id_to_item.contains(new_id));
 
  lapp_context->new_id_to_item.remove(item->new_id);
  item->new_id = new_id;
  lapp_context->new_id_to_item.add(new_id, item);
}
 
ID *BKE_blendfile_link_append_context_item_liboverrideid_get(
    BlendfileLinkAppendContext *lapp_context, BlendfileLinkAppendContextItem *item)
{
  BLI_assert(lapp_context->process_stage != BlendfileLinkAppendContext::ProcessStage::Init);
  UNUSED_VARS_NDEBUG(lapp_context);
  return item->liboverride_id;
}
 
short BKE_blendfile_link_append_context_item_idcode_get(
    BlendfileLinkAppendContext * /*lapp_context*/, BlendfileLinkAppendContextItem *item)
{
  return item->idcode;
}
 
void BKE_blendfile_link_append_context_item_foreach(
    BlendfileLinkAppendContext *lapp_context,
    blender::FunctionRef<bool(BlendfileLinkAppendContext *lapp_context,
                              BlendfileLinkAppendContextItem *item)> callback_function,
    const eBlendfileLinkAppendForeachItemFlag flag)
{
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    if ((flag & BKE_BLENDFILE_LINK_APPEND_FOREACH_ITEM_FLAG_DO_DIRECT) == 0 &&
        (item.tag & LINK_APPEND_TAG_INDIRECT) == 0)
    {
      continue;
    }
    if ((flag & BKE_BLENDFILE_LINK_APPEND_FOREACH_ITEM_FLAG_DO_INDIRECT) == 0 &&
        (item.tag & LINK_APPEND_TAG_INDIRECT) != 0)
    {
      continue;
    }
 
    if (!callback_function(lapp_context, &item)) {
      break;
    }
  }
}
 
void BKE_blendfile_link_append_context_init_done(BlendfileLinkAppendContext *lapp_context)
{
  BLI_assert(lapp_context->process_stage == BlendfileLinkAppendContext::ProcessStage::Init);
 
  PointerRNA ctx_ptr = RNA_pointer_create_discrete(nullptr, &RNA_BlendImportContext, lapp_context);
  PointerRNA *pointers[1] = {&ctx_ptr};
  BKE_callback_exec(lapp_context->params->bmain, pointers, 1, BKE_CB_EVT_BLENDIMPORT_PRE);
}
 
void BKE_blendfile_link_append_context_finalize(BlendfileLinkAppendContext *lapp_context)
{
  BLI_assert(ELEM(lapp_context->process_stage,
                  BlendfileLinkAppendContext::ProcessStage::Linking,
                  BlendfileLinkAppendContext::ProcessStage::Appending,
                  BlendfileLinkAppendContext::ProcessStage::Instantiating));
  lapp_context->process_stage = BlendfileLinkAppendContext::ProcessStage::Done;
 
  PointerRNA ctx_ptr = RNA_pointer_create_discrete(nullptr, &RNA_BlendImportContext, lapp_context);
  PointerRNA *pointers[1] = {&ctx_ptr};
  BKE_callback_exec(lapp_context->params->bmain, pointers, 1, BKE_CB_EVT_BLENDIMPORT_POST);
}

 
/* -------------------------------------------------------------------- */
 
/* Struct gathering all required data to handle instantiation of loose data-blocks. */
struct LooseDataInstantiateContext {
  BlendfileLinkAppendContext *lapp_context;
 
  /* The collection in which to add loose collections/objects. */
  Collection *active_collection;
};
 
static bool object_in_any_scene(Main *bmain, Object *ob)
{
  LISTBASE_FOREACH (Scene *, sce, &bmain->scenes) {
    /* #BKE_scene_has_object checks bases cache of the scenes' view-layer, not actual content of
     * their collections. */
    if (BKE_collection_has_object_recursive(sce->master_collection, ob)) {
      return true;
    }
  }
 
  return false;
}
 
static bool object_in_any_collection(Main *bmain, Object *ob)
{
  LISTBASE_FOREACH (Collection *, collection, &bmain->collections) {
    if (BKE_collection_has_object(collection, ob)) {
      return true;
    }
  }
 
  LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
    if (scene->master_collection != nullptr &&
        BKE_collection_has_object(scene->master_collection, ob))
    {
      return true;
    }
  }
 
  return false;
}
 
static bool collection_instantiated_by_any_object(Main *bmain, Collection *collection)
{
  LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
    if (ob->type == OB_EMPTY && ob->instance_collection == collection) {
      return true;
    }
  }
  return false;
}
 
static ID *loose_data_instantiate_process_check(LooseDataInstantiateContext *instantiate_context,
                                                BlendfileLinkAppendContextItem *item)
{
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
  /* In linking case, we always want to handle instantiation. */
  if (lapp_context->params->flag & FILE_LINK) {
    return item->new_id;
  }
 
  /* We consider that if we either kept it linked, or re-used already local data, instantiation
   * status of those should not be modified. */
  if (!ELEM(item->action, LINK_APPEND_ACT_COPY_LOCAL, LINK_APPEND_ACT_MAKE_LOCAL)) {
    return nullptr;
  }
 
  ID *id = item->new_id;
  if (id == nullptr) {
    return nullptr;
  }
 
  BLI_assert(!ID_IS_LINKED(id));
  return id;
}
 
static void loose_data_instantiate_ensure_active_collection(
    LooseDataInstantiateContext *instantiate_context)
{
 
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
  Main *bmain = instantiate_context->lapp_context->params->bmain;
  Scene *scene = instantiate_context->lapp_context->params->context.scene;
  ViewLayer *view_layer = instantiate_context->lapp_context->params->context.view_layer;
 
  /* Find or add collection as needed. When `active_collection` is non-null, it is assumed to be
   * editable. */
  if (instantiate_context->active_collection == nullptr) {
    if (lapp_context->params->flag & FILE_ACTIVE_COLLECTION) {
      LayerCollection *lc = BKE_layer_collection_get_active(view_layer);
      instantiate_context->active_collection = BKE_collection_parent_editable_find_recursive(
          view_layer, lc->collection);
    }
    else {
      if (lapp_context->params->flag & FILE_LINK) {
        instantiate_context->active_collection = BKE_collection_add(
            bmain, scene->master_collection, DATA_("Linked Data"));
      }
      else {
        instantiate_context->active_collection = BKE_collection_add(
            bmain, scene->master_collection, DATA_("Appended Data"));
      }
    }
  }
}
 
static void loose_data_instantiate_object_base_instance_init(Main *bmain,
                                                             Collection *collection,
                                                             Object *ob,
                                                             const Scene *scene,
                                                             ViewLayer *view_layer,
                                                             const View3D *v3d,
                                                             const int flag,
                                                             bool set_active)
{
  /* Auto-select and appending. */
  if ((flag & FILE_AUTOSELECT) && ((flag & FILE_LINK) == 0)) {
    /* While in general the object should not be manipulated,
     * when the user requests the object to be selected, ensure it's visible and selectable. */
    ob->visibility_flag &= ~(OB_HIDE_VIEWPORT | OB_HIDE_SELECT);
  }
 
  BKE_collection_object_add(bmain, collection, ob);
  BKE_view_layer_synced_ensure(scene, view_layer);
  Base *base = BKE_view_layer_base_find(view_layer, ob);
 
  if (v3d != nullptr) {
    base->local_view_bits |= v3d->local_view_uid;
  }
 
  if (flag & FILE_AUTOSELECT) {
    /* All objects that use #FILE_AUTOSELECT must be selectable (unless linking data). */
    BLI_assert((base->flag & BASE_SELECTABLE) || (flag & FILE_LINK));
    if (base->flag & BASE_SELECTABLE) {
      base->flag |= BASE_SELECTED;
    }
  }
 
  if (set_active) {
    view_layer->basact = base;
  }
 
  BKE_scene_object_base_flag_sync_from_base(base);
}
 
/* Tag obdata that actually need to be instantiated (those referenced by an object do not, since
 * the object will be instantiated instead if needed. */
static void loose_data_instantiate_obdata_preprocess(
    LooseDataInstantiateContext *instantiate_context)
{
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
 
  /* First pass on obdata to enable their instantiation by default, then do a second pass on
   * objects to clear it for any obdata already in use. */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = loose_data_instantiate_process_check(instantiate_context, &item);
    if (id == nullptr) {
      continue;
    }
    const ID_Type idcode = GS(id->name);
    if (!OB_DATA_SUPPORT_ID(idcode)) {
      continue;
    }
    if (idcode == ID_GD_LEGACY) {
      const bGPdata *legacy_gpd = reinterpret_cast<bGPdata *>(id);
      if ((legacy_gpd->flag & GP_DATA_ANNOTATIONS) != 0) {
        continue;
      }
    }
 
    id->tag |= ID_TAG_DOIT;
  }
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = item.new_id;
    if (id == nullptr || GS(id->name) != ID_OB) {
      continue;
    }
 
    Object *ob = reinterpret_cast<Object *>(id);
    Object *new_ob = reinterpret_cast<Object *>(id->newid);
    if (ob->data != nullptr) {
      (static_cast<ID *>(ob->data))->tag &= ~ID_TAG_DOIT;
    }
    if (new_ob != nullptr && new_ob->data != nullptr) {
      (static_cast<ID *>(new_ob->data))->tag &= ~ID_TAG_DOIT;
    }
  }
}
 
/* Test whether some ancestor collection is also tagged for instantiation (return true) or not
 * (return false). */
static bool loose_data_instantiate_collection_parents_check_recursive(Collection *collection)
{
  for (CollectionParent *parent_collection =
           static_cast<CollectionParent *>(collection->runtime.parents.first);
       parent_collection != nullptr;
       parent_collection = parent_collection->next)
  {
    if ((parent_collection->collection->id.tag & ID_TAG_DOIT) != 0) {
      return true;
    }
    if (loose_data_instantiate_collection_parents_check_recursive(parent_collection->collection)) {
      return true;
    }
  }
  return false;
}
 
static void loose_data_instantiate_collection_process(
    LooseDataInstantiateContext *instantiate_context)
{
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
  Main *bmain = lapp_context->params->bmain;
  Scene *scene = lapp_context->params->context.scene;
  ViewLayer *view_layer = lapp_context->params->context.view_layer;
  const View3D *v3d = lapp_context->params->context.v3d;
 
  const bool do_append = (lapp_context->params->flag & FILE_LINK) == 0;
  const bool do_instantiate_as_empty = (lapp_context->params->flag &
                                        BLO_LIBLINK_COLLECTION_INSTANCE) != 0;
 
  /* NOTE: For collections we only view_layer-instantiate duplicated collections that have
   * non-instantiated objects in them.
   * NOTE: Also avoid view-layer-instantiating of collections children of other instantiated
   * collections. This is why we need two passes here. */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = loose_data_instantiate_process_check(instantiate_context, &item);
    if (id == nullptr || GS(id->name) != ID_GR) {
      continue;
    }
 
    /* Forced instantiation of indirectly appended collections is not wanted. Users can now
     * easily instantiate collections (and their objects) as needed by themselves. See #67032. */
    /* We need to check that objects in that collections are already instantiated in a scene.
     * Otherwise, it's better to add the collection to the scene's active collection, than to
     * instantiate its objects in active scene's collection directly. See #61141.
     *
     * NOTE: We only check object directly into that collection, not recursively into its
     * children.
     */
    Collection *collection = (Collection *)id;
    /* The collection could be linked/appended together with an Empty object instantiating it,
     * better not instantiate the collection in the view-layer in that case.
     *
     * Can easily happen when copy/pasting such instantiating empty, see #93839. */
    const bool collection_is_instantiated = collection_instantiated_by_any_object(bmain,
                                                                                  collection);
    /* Always consider adding collections directly selected by the user. */
    bool do_add_collection = (item.tag & LINK_APPEND_TAG_INDIRECT) == 0 &&
                             !collection_is_instantiated;
    /* In linking case, do not enforce instantiating non-directly linked collections/objects.
     * This avoids cluttering the view-layers, user can instantiate themselves specific collections
     * or objects easily from the Outliner if needed. */
    if (!do_add_collection && do_append && !collection_is_instantiated) {
      LISTBASE_FOREACH (CollectionObject *, coll_ob, &collection->gobject) {
        Object *ob = coll_ob->ob;
        if (!object_in_any_scene(bmain, ob)) {
          do_add_collection = true;
          break;
        }
      }
    }
    if (do_add_collection) {
      collection->id.tag |= ID_TAG_DOIT;
    }
  }
 
  /* Second loop to actually instantiate collections tagged as such in first loop, unless some of
   * their ancestor is also instantiated in case this is not an empty-instantiation. */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = loose_data_instantiate_process_check(instantiate_context, &item);
    if (id == nullptr || GS(id->name) != ID_GR) {
      continue;
    }
 
    Collection *collection = reinterpret_cast<Collection *>(id);
    bool do_add_collection = (id->tag & ID_TAG_DOIT) != 0;
 
    if (!do_add_collection) {
      continue;
    }
    /* When instantiated into view-layer, do not add collections if one of their parents is also
     * instantiated. */
    if (!do_instantiate_as_empty &&
        loose_data_instantiate_collection_parents_check_recursive(collection))
    {
      continue;
    }
    /* When instantiated as empty, do not add indirectly linked (i.e. non-user-selected)
     * collections. */
    if (do_instantiate_as_empty && (item.tag & LINK_APPEND_TAG_INDIRECT) != 0) {
      continue;
    }
 
    loose_data_instantiate_ensure_active_collection(instantiate_context);
    Collection *active_collection = instantiate_context->active_collection;
 
    if (do_instantiate_as_empty) {
      /* BKE_object_add(...) messes with the selection. */
      Object *ob = BKE_object_add_only_object(bmain, OB_EMPTY, collection->id.name + 2);
      ob->type = OB_EMPTY;
      ob->empty_drawsize = U.collection_instance_empty_size;
 
      const bool set_selected = (lapp_context->params->flag & FILE_AUTOSELECT) != 0;
      /* TODO: why is it OK to make this active here but not in other situations?
       * See other callers of #object_base_instance_init */
      const bool set_active = set_selected;
      loose_data_instantiate_object_base_instance_init(bmain,
                                                       active_collection,
                                                       ob,
                                                       scene,
                                                       view_layer,
                                                       v3d,
                                                       lapp_context->params->flag,
                                                       set_active);
 
      /* Assign the collection. */
      ob->instance_collection = collection;
      id_us_plus(&collection->id);
      ob->transflag |= OB_DUPLICOLLECTION;
      copy_v3_v3(ob->loc, scene->cursor.location);
    }
    else {
      /* Add collection as child of active collection. */
      BKE_collection_child_add(bmain, active_collection, collection);
      BKE_view_layer_synced_ensure(scene, view_layer);
 
      if ((lapp_context->params->flag & FILE_AUTOSELECT) != 0) {
        /* All objects contained in this collection need to be processed, including the ones
         * belonging to children collections. */
        FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (collection, ob) {
          Base *base = BKE_view_layer_base_find(view_layer, ob);
          if (base) {
            base->flag |= BASE_SELECTED;
            BKE_scene_object_base_flag_sync_from_base(base);
          }
        }
        FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
      }
    }
  }
}
 
static void loose_data_instantiate_object_process(LooseDataInstantiateContext *instantiate_context)
{
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
  Main *bmain = lapp_context->params->bmain;
  const Scene *scene = lapp_context->params->context.scene;
  ViewLayer *view_layer = lapp_context->params->context.view_layer;
  const View3D *v3d = lapp_context->params->context.v3d;
 
  /* Do NOT make base active here! screws up GUI stuff,
   * if you want it do it at the editor level. */
  const bool object_set_active = false;
 
  const bool is_linking = (lapp_context->params->flag & FILE_LINK) != 0;
 
  /* NOTE: For objects we only view_layer-instantiate duplicated objects that are not yet used
   * anywhere. */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = loose_data_instantiate_process_check(instantiate_context, &item);
    if (id == nullptr || GS(id->name) != ID_OB) {
      continue;
    }
 
    /* In linking case, never instantiate stray objects that are not directly linked.
     *
     * While this is not ideal (in theory no object should remain un-owned), in case of indirectly
     * linked objects, the other solution would be to add them to a local collection, which would
     * make them directly linked. Think for now keeping them indirectly linked is more important.
     * Ref. #93757.
     */
    if (is_linking && (item.tag & LINK_APPEND_TAG_INDIRECT) != 0) {
      continue;
    }
 
    Object *ob = (Object *)id;
 
    if (object_in_any_collection(bmain, ob)) {
      continue;
    }
 
    loose_data_instantiate_ensure_active_collection(instantiate_context);
    Collection *active_collection = instantiate_context->active_collection;
 
    CLAMP_MIN(ob->id.us, 0);
    ob->mode = OB_MODE_OBJECT;
 
    loose_data_instantiate_object_base_instance_init(bmain,
                                                     active_collection,
                                                     ob,
                                                     scene,
                                                     view_layer,
                                                     v3d,
                                                     lapp_context->params->flag,
                                                     object_set_active);
  }
}
 
static void loose_data_instantiate_obdata_process(LooseDataInstantiateContext *instantiate_context)
{
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
  Main *bmain = lapp_context->params->bmain;
  Scene *scene = lapp_context->params->context.scene;
  ViewLayer *view_layer = lapp_context->params->context.view_layer;
  const View3D *v3d = lapp_context->params->context.v3d;
 
  /* Do NOT make base active here! screws up GUI stuff,
   * if you want it do it at the editor level. */
  const bool object_set_active = false;
 
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = loose_data_instantiate_process_check(instantiate_context, &item);
    if (id == nullptr) {
      continue;
    }
    const ID_Type idcode = GS(id->name);
    if (!OB_DATA_SUPPORT_ID(idcode)) {
      continue;
    }
    if ((id->tag & ID_TAG_DOIT) == 0) {
      continue;
    }
 
    loose_data_instantiate_ensure_active_collection(instantiate_context);
    Collection *active_collection = instantiate_context->active_collection;
 
    const int type = BKE_object_obdata_to_type(id);
    BLI_assert(type != -1);
    Object *ob = BKE_object_add_only_object(bmain, type, id->name + 2);
    ob->data = id;
    id_us_plus(id);
    BKE_object_materials_sync_length(bmain, ob, static_cast<ID *>(ob->data));
 
    loose_data_instantiate_object_base_instance_init(bmain,
                                                     active_collection,
                                                     ob,
                                                     scene,
                                                     view_layer,
                                                     v3d,
                                                     lapp_context->params->flag,
                                                     object_set_active);
 
    copy_v3_v3(ob->loc, scene->cursor.location);
 
    id->tag &= ~ID_TAG_DOIT;
  }
}
 
static void loose_data_instantiate_object_rigidbody_postprocess(
    LooseDataInstantiateContext *instantiate_context)
{
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
  Main *bmain = lapp_context->params->bmain;
 
  /* Add rigid body objects and constraints to current RB world(s). */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = loose_data_instantiate_process_check(instantiate_context, &item);
    if (id == nullptr || GS(id->name) != ID_OB) {
      continue;
    }
    BKE_rigidbody_ensure_local_object(bmain, reinterpret_cast<Object *>(id));
  }
}
 
static void loose_data_instantiate(LooseDataInstantiateContext *instantiate_context)
{
  if (instantiate_context->lapp_context->params->context.scene == nullptr) {
    /* In some cases, like the asset drag&drop e.g., the caller code manages instantiation itself.
     */
    return;
  }
 
  BlendfileLinkAppendContext *lapp_context = instantiate_context->lapp_context;
  const bool do_obdata = (lapp_context->params->flag & BLO_LIBLINK_OBDATA_INSTANCE) != 0;
 
  /* First pass on obdata to enable their instantiation by default, then do a second pass on
   * objects to clear it for any obdata already in use. */
  if (do_obdata) {
    loose_data_instantiate_obdata_preprocess(instantiate_context);
  }
 
  /* First do collections, then objects, then obdata. */
  loose_data_instantiate_collection_process(instantiate_context);
  loose_data_instantiate_object_process(instantiate_context);
  if (do_obdata) {
    loose_data_instantiate_obdata_process(instantiate_context);
  }
 
  loose_data_instantiate_object_rigidbody_postprocess(instantiate_context);
}
 
static void new_id_to_item_mapping_add(BlendfileLinkAppendContext &lapp_context,
                                       ID *id,
                                       BlendfileLinkAppendContextItem &item)
{
  lapp_context.new_id_to_item.add(id, &item);
}
 
/* Generate a mapping between newly linked IDs and their items, and tag linked IDs used as
 * liboverride references as already existing. */
static void new_id_to_item_mapping_create(BlendfileLinkAppendContext &lapp_context)
{
  for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
 
    new_id_to_item_mapping_add(lapp_context, id, item);
  }
}
 
/* All callbacks processing dependencies of an ID for link/append post-processing share a same
 * common logic to skip some cases. This is factorized in this helper function.
 *
 * Returns false if further processing should be skipped. */
static bool foreach_libblock_link_append_common_processing(
    LibraryIDLinkCallbackData *cb_data, blender::FunctionRef<LibraryIDLinkCallback> callback)
{
  if (cb_data->cb_flag & (IDWALK_CB_EMBEDDED | IDWALK_CB_EMBEDDED_NOT_OWNING | IDWALK_CB_INTERNAL |
                          IDWALK_CB_LOOPBACK))
  {
    return false;
  }
 
  ID *id = *cb_data->id_pointer;
  if (id == nullptr) {
    return false;
  }
  if (!ID_IS_LINKED(id)) {
    CLOG_ERROR(
        &LOG,
        "Local ID '%s' found as part of the linked data hierarchy, this should never happen",
        id->name);
    return false;
  }
 
  if (!BKE_idtype_idcode_is_linkable(GS(id->name))) {
    /* While we do not want to add non-linkable ID (shape keys...) to the list of linked items,
     * unfortunately they can use fully linkable valid IDs too, like actions. Those need to be
     * processed, so we need to recursively deal with them here. */
    /* NOTE: Since we are by-passing checks in `BKE_library_foreach_ID_link` by manually calling it
     * recursively, we need to take care of potential recursion cases ourselves (e.g.anim-data of
     * shape-key referencing the shape-key itself). */
    /* NOTE: in case both IDs (owner and 'used' ones) are non-linkable, we can assume we can break
     * the dependency here. Indeed, either they are both linked in another way (through their own
     * meshes for shape keys e.g.), or this is an unsupported case (two shape-keys depending on
     * each-other need to be also 'linked' in by their respective meshes, independent shape-keys
     * are not allowed). ref #96048. */
    if (id != cb_data->self_id && BKE_idtype_idcode_is_linkable(GS(cb_data->self_id->name))) {
      BKE_library_foreach_ID_link(cb_data->bmain, id, callback, cb_data->user_data, IDWALK_NOP);
    }
    return false;
  }
 
  return true;
}


 
static int foreach_libblock_append_add_dependencies_callback(LibraryIDLinkCallbackData *cb_data)
{
  if (!foreach_libblock_link_append_common_processing(
          cb_data, foreach_libblock_append_add_dependencies_callback))
  {
    return IDWALK_RET_NOP;
  }
  ID *id = *cb_data->id_pointer;
  const BlendfileLinkAppendContextCallBack *data =
      static_cast<BlendfileLinkAppendContextCallBack *>(cb_data->user_data);
 
  /* NOTE: In append case, all dependencies are needed in the items list, to cover potential
   * complex cases (e.g. linked data from another library referencing other IDs from the  */
 
  BlendfileLinkAppendContextItem *item = data->lapp_context->new_id_to_item.lookup_default(
      id, nullptr);
  if (item == nullptr) {
    item = BKE_blendfile_link_append_context_item_add(
        data->lapp_context, BKE_id_name(*id), GS(id->name), nullptr);
    item->new_id = id;
    item->source_library = id->lib;
    /* Since we did not have an item for that ID yet, we know user did not select it explicitly,
     * it was rather linked indirectly. This info is important for instantiation of collections.
     */
    item->tag |= LINK_APPEND_TAG_INDIRECT;
    item->action = LINK_APPEND_ACT_UNSET;
    new_id_to_item_mapping_add(*data->lapp_context, id, *item);
 
    if ((cb_data->cb_flag & IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE) != 0 ||
        data->is_liboverride_dependency_only)
    {
      /* New item, (currently) detected as only used as a liboverride linked dependency. */
      item->tag |= LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY;
    }
    else if (data->is_liboverride_dependency) {
      /* New item, (currently) detected as used as a liboverride linked dependency, among
       * others. */
      item->tag |= LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY;
    }
  }
  else {
    if ((cb_data->cb_flag & IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE) != 0 ||
        data->is_liboverride_dependency_only)
    {
      /* Existing item, here only used as a liboverride reference dependency. If it was not
       * tagged as such before, it is also used by non-liboverride reference data. */
      if ((item->tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) == 0) {
        item->tag |= LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY;
      }
    }
    else if ((item->tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) != 0) {
      /* Existing item, here used in a non-liboverride dependency context. If it was
       * tagged as a liboverride dependency only, its tag and action need to be updated. */
      item->tag &= ~LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY;
      item->tag |= LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY;
    }
  }
 
  return IDWALK_RET_NOP;
}
 
static int foreach_libblock_append_ensure_reusable_local_id_callback(
    LibraryIDLinkCallbackData *cb_data)
{
  if (!foreach_libblock_link_append_common_processing(
          cb_data, foreach_libblock_append_ensure_reusable_local_id_callback))
  {
    return IDWALK_RET_NOP;
  }
  ID *id = *cb_data->id_pointer;
  const BlendfileLinkAppendContextCallBack *data =
      static_cast<BlendfileLinkAppendContextCallBack *>(cb_data->user_data);
 
  if (!data->item->reusable_local_id) {
    return IDWALK_RET_NOP;
  }
 
  BlendfileLinkAppendContextItem *item = data->lapp_context->new_id_to_item.lookup(id);
  BLI_assert(item != nullptr);
 
  /* If the currently processed owner ID is not defined as being kept linked, and is using a
   * dependency that cannot be reused form local data, then the owner ID should not reuse its
   * local data either. */
  if (item->action != LINK_APPEND_ACT_KEEP_LINKED && item->reusable_local_id == nullptr) {
    BKE_main_library_weak_reference_remove_item(data->lapp_context->library_weak_reference_mapping,
                                                cb_data->owner_id->lib->filepath,
                                                cb_data->owner_id->name,
                                                data->item->reusable_local_id);
    data->item->reusable_local_id = nullptr;
  }
 
  return IDWALK_RET_NOP;
}
 
static int foreach_libblock_append_finalize_action_callback(LibraryIDLinkCallbackData *cb_data)
{
  if (!foreach_libblock_link_append_common_processing(
          cb_data, foreach_libblock_append_finalize_action_callback))
  {
    return IDWALK_RET_NOP;
  }
  ID *id = *cb_data->id_pointer;
  BlendfileLinkAppendContextCallBack *data = static_cast<BlendfileLinkAppendContextCallBack *>(
      cb_data->user_data);
 
  BlendfileLinkAppendContextItem *item = data->lapp_context->new_id_to_item.lookup(id);
  BLI_assert(item != nullptr);
  BLI_assert(data->item->action == LINK_APPEND_ACT_KEEP_LINKED);
 
  if (item->action == LINK_APPEND_ACT_MAKE_LOCAL) {
    CLOG_INFO(&LOG,
              3,
              "Appended ID '%s' was to be made directly local, but is also used by data that is "
              "kept linked, so duplicating it instead.",
              id->name);
    item->action = LINK_APPEND_ACT_COPY_LOCAL;
  }
  return IDWALK_RET_NOP;
}
 
static void blendfile_append_define_actions(BlendfileLinkAppendContext &lapp_context,
                                            ReportList *reports)
{
  Main *bmain = lapp_context.params->bmain;
 
  const bool do_recursive = (lapp_context.params->flag & BLO_LIBLINK_APPEND_RECURSIVE) != 0;
  const bool do_reuse_local_id = (lapp_context.params->flag & BLO_LIBLINK_APPEND_LOCAL_ID_REUSE) !=
                                 0;
 
  /* In case of non-recursive appending, gather a set of all 'original' libraries (i.e. libraries
   * containing data that was explicitly selected by the user). */
  blender::Set<Library *> direct_libraries;
  if (!do_recursive) {
    for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
      ID *id = item.new_id;
      if (id == nullptr) {
        continue;
      }
      direct_libraries.add(id->lib);
    }
  }
 
  /* Add items for all not yet known IDs (i.e. implicitly linked indirect dependencies) to the
   * list.
   * NOTE: Since items are appended, this list will grow and these IDs will be processed later,
   * leading to a flatten recursive processing of all the linked dependencies.
   */
  for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
    BLI_assert(item.reusable_local_id == nullptr);
 
    /* NOTE: handling of reusable local ID info is needed, even if their usage is not requested
     * for that append operation:
     *  - Newly appended data need to get their weak reference, such that it can be reused later
     * if requested.
     *  - Existing appended data may need to get this 'reuse' weak reference cleared, e.g. if a
     * new version of it is made local. */
    item.reusable_local_id = BKE_idtype_idcode_append_is_reusable(GS(id->name)) ?
                                 BKE_main_library_weak_reference_search_item(
                                     lapp_context.library_weak_reference_mapping,
                                     id->lib->filepath,
                                     id->name) :
                                 nullptr;
 
    BlendfileLinkAppendContextCallBack cb_data{};
    cb_data.lapp_context = &lapp_context;
    cb_data.item = &item;
    cb_data.reports = reports;
    cb_data.is_liboverride_dependency = (item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY) != 0;
    cb_data.is_liboverride_dependency_only = (item.tag &
                                              LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) != 0;
    BKE_library_foreach_ID_link(
        bmain, id, foreach_libblock_append_add_dependencies_callback, &cb_data, IDWALK_NOP);
  }
 
  /* At this point, linked IDs that should remain linked can already be defined as such:
   *  - In case of non-recursive appending, IDs from other libraries.
   *  - IDs only used as liboverride references. */
  for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
    /* These tags should have been set in above loop, here they can be check for validity (they
     * are mutually exclusive). */
    BLI_assert(
        (item.tag &
         (LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY | LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY)) !=
        (LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY | LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY));
 
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
    /* IDs exclusively used as liboverride reference should not be made local at all. */
    if ((item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) != 0) {
      CLOG_INFO(
          &LOG,
          3,
          "Appended ID '%s' is only used as a liboverride linked dependency, keeping it linked.",
          id->name);
      item.action = LINK_APPEND_ACT_KEEP_LINKED;
      item.reusable_local_id = nullptr;
    }
    /* In non-recursive append case, only IDs from the same libraries as the directly appended
     * ones are made local. All dependencies from other libraries are kept linked. */
    if (!do_recursive && !direct_libraries.contains(id->lib)) {
      CLOG_INFO(&LOG,
                3,
                "Appended ID '%s' belongs to another library and recursive append is disabled, "
                "keeping it linked.",
                id->name);
      item.action = LINK_APPEND_ACT_KEEP_LINKED;
      item.reusable_local_id = nullptr;
    }
  }
 
  /* The reusable local IDs can cause severe issues in hierarchies of appended data. If an ID
   * user e.g. still has a local reusable ID found, but one of its dependencies does not (i.e.
   * either there were some changes in the library data, or the previously appended local
   * dependencies was modified in current file and therefore cannot be re-used anymore), then the
   * user ID should not be considered as usable either. */
  /* TODO: This process is currently fairly raw and inefficient. This is likely not a
   * (significant) issue currently anyway. But would be good to refactor this whole code to use
   * modern CPP containers (list of items could be an `std::deque` e.g., to be iterable in both
   * directions). Being able to loop backward here (i.e. typically process the dependencies
   * before the user IDs) could avoid a lot of iterations. */
  for (bool keep_looping = do_reuse_local_id; keep_looping;) {
    keep_looping = false;
    for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
      ID *id = item.new_id;
      if (id == nullptr) {
        continue;
      }
      if (!item.reusable_local_id) {
        continue;
      }
      BlendfileLinkAppendContextCallBack cb_data{};
      cb_data.lapp_context = &lapp_context;
      cb_data.item = &item;
      cb_data.reports = reports;
      cb_data.is_liboverride_dependency = (item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY) != 0;
      cb_data.is_liboverride_dependency_only = (item.tag &
                                                LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) != 0;
      BKE_library_foreach_ID_link(bmain,
                                  id,
                                  foreach_libblock_append_ensure_reusable_local_id_callback,
                                  &cb_data,
                                  IDWALK_NOP);
      if (!item.reusable_local_id) {
        /* If some reusable ID was cleared, another loop over all items is needed to potentially
         * propagate this change higher in the dependency hierarchy. */
        keep_looping = true;
      }
    }
  }
 
  for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
 
    if (item.action != LINK_APPEND_ACT_UNSET) {
      /* Already set, pass. */
      BLI_assert(item.action == LINK_APPEND_ACT_KEEP_LINKED);
      continue;
    }
    BLI_assert((item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) == 0);
 
    if (do_reuse_local_id && item.reusable_local_id != nullptr) {
      CLOG_INFO(&LOG, 3, "Appended ID '%s' as a matching local one, re-using it.", id->name);
      item.action = LINK_APPEND_ACT_REUSE_LOCAL;
    }
    else if (id->tag & ID_TAG_PRE_EXISTING) {
      CLOG_INFO(&LOG, 3, "Appended ID '%s' was already linked, duplicating it.", id->name);
      item.action = LINK_APPEND_ACT_COPY_LOCAL;
    }
    else if (item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY) {
      CLOG_INFO(
          &LOG,
          3,
          "Appended ID '%s' is also used as a liboverride linked dependency, duplicating it.",
          id->name);
      item.action = LINK_APPEND_ACT_COPY_LOCAL;
    }
    else if (ID_IS_LINKED(id) && ID_IS_OVERRIDE_LIBRARY(id)) {
      /* While in theory liboverrides can be directly made local, this causes complex potential
       * problems, e.g. because hierarchy roots can become temporarily invalid when the root is
       * made local, etc.
       *
       * So for now, simpler to always duplicate linked liboverrides. */
      CLOG_INFO(&LOG, 3, "Appended ID '%s' is a liboverride, duplicating it.", id->name);
      item.action = LINK_APPEND_ACT_COPY_LOCAL;
    }
    else {
      /* That last action, making linked data directly local, can still be changed to
       * #LINK_APPEND_ACT_COPY_LOCAL in the last checks below. This can happen in rare cases with
       * complex relationships involving IDs that are kept linked and IDs that are made local,
       * both using some same dependencies. */
      CLOG_INFO(&LOG, 3, "Appended ID '%s' will be made local.", id->name);
      item.action = LINK_APPEND_ACT_MAKE_LOCAL;
    }
  }
 
  /* Some linked IDs marked to be made directly local may also be used by other items
   * marked to be kept linked. in such case, they need to be copied for the local data, such that
   * a linked version of these remains available as dependency for other linked data. */
  for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
 
    /* Only IDs kept as linked need to be checked here. */
    if (item.action == LINK_APPEND_ACT_KEEP_LINKED) {
      BlendfileLinkAppendContextCallBack cb_data{};
      cb_data.lapp_context = &lapp_context;
      cb_data.item = &item;
      cb_data.reports = reports;
      cb_data.is_liboverride_dependency = (item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY) != 0;
      cb_data.is_liboverride_dependency_only = (item.tag &
                                                LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) != 0;
      BKE_library_foreach_ID_link(
          bmain, id, foreach_libblock_append_finalize_action_callback, &cb_data, IDWALK_NOP);
    }
 
    /* If we found a matching existing local id but are not re-using it, we need to properly
     * clear its weak reference to linked data. */
    if (item.reusable_local_id != nullptr &&
        !ELEM(item.action, LINK_APPEND_ACT_KEEP_LINKED, LINK_APPEND_ACT_REUSE_LOCAL))
    {
      BLI_assert_msg(!do_reuse_local_id,
                     "This code should only be reached when the current append operation does not "
                     "try to reuse local data.");
      BKE_main_library_weak_reference_remove_item(lapp_context.library_weak_reference_mapping,
                                                  id->lib->filepath,
                                                  id->name,
                                                  item.reusable_local_id);
      item.reusable_local_id = nullptr;
    }
  }
}
 
void BKE_blendfile_append(BlendfileLinkAppendContext *lapp_context, ReportList *reports)
{
  BLI_assert(lapp_context->process_stage == BlendfileLinkAppendContext::ProcessStage::Linking);
  lapp_context->process_stage = BlendfileLinkAppendContext::ProcessStage::Appending;
 
  if (lapp_context->items.empty()) {
    /* Nothing to append. */
    return;
  }
 
  Main *bmain = lapp_context->params->bmain;
 
  BLI_assert((lapp_context->params->flag & FILE_LINK) == 0);
 
  const bool set_fakeuser = (lapp_context->params->flag & BLO_LIBLINK_APPEND_SET_FAKEUSER) != 0;
 
  const int make_local_common_flags =
      LIB_ID_MAKELOCAL_FULL_LIBRARY |
      ((lapp_context->params->flag & BLO_LIBLINK_APPEND_ASSET_DATA_CLEAR) != 0 ?
           LIB_ID_MAKELOCAL_ASSET_DATA_CLEAR :
           0) |
      /* In recursive case (i.e. everything becomes local), clear liboverrides. Otherwise (i.e.
       * only data from immediately linked libraries is made local), preserve liboverrides. */
      ((lapp_context->params->flag & BLO_LIBLINK_APPEND_RECURSIVE) != 0 ?
           LIB_ID_MAKELOCAL_LIBOVERRIDE_CLEAR :
           0);
 
  new_id_to_item_mapping_create(*lapp_context);
  lapp_context->library_weak_reference_mapping = BKE_main_library_weak_reference_create(bmain);
 
  /* Add missing items (the indirectly linked ones), and carefully define which action should be
   * applied to each of them. */
  blendfile_append_define_actions(*lapp_context, reports);
 
  /* Effectively perform required operation on every linked ID. */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
 
    ID *local_appended_new_id = nullptr;
    char lib_filepath[FILE_MAX];
    STRNCPY(lib_filepath, id->lib->filepath);
    char lib_id_name[MAX_ID_NAME];
    STRNCPY(lib_id_name, id->name);
 
    switch (item.action) {
      case LINK_APPEND_ACT_COPY_LOCAL:
        BKE_lib_id_make_local(bmain, id, make_local_common_flags | LIB_ID_MAKELOCAL_FORCE_COPY);
        local_appended_new_id = id->newid;
        break;
      case LINK_APPEND_ACT_MAKE_LOCAL:
        BKE_lib_id_make_local(bmain, id, make_local_common_flags | LIB_ID_MAKELOCAL_FORCE_LOCAL);
        BLI_assert(id->newid == nullptr);
        local_appended_new_id = id;
        break;
      case LINK_APPEND_ACT_KEEP_LINKED:
        /* Nothing to do here. */
        break;
      case LINK_APPEND_ACT_REUSE_LOCAL:
        BLI_assert(item.reusable_local_id != nullptr);
        /* We only need to set `newid` to ID found in previous loop, for proper remapping. */
        ID_NEW_SET(id, item.reusable_local_id);
        /* This is not a 'new' local appended id, do not set `local_appended_new_id` here. */
        break;
      case LINK_APPEND_ACT_UNSET:
        CLOG_ERROR(
            &LOG, "Unexpected unset append action for '%s' ID, assuming 'keep link'", id->name);
        break;
      default:
        BLI_assert_unreachable();
    }
 
    if (local_appended_new_id != nullptr) {
      if (BKE_idtype_idcode_append_is_reusable(GS(local_appended_new_id->name))) {
        BKE_main_library_weak_reference_add_item(lapp_context->library_weak_reference_mapping,
                                                 lib_filepath,
                                                 lib_id_name,
                                                 local_appended_new_id);
      }
 
      if (set_fakeuser) {
        if (!ELEM(GS(local_appended_new_id->name), ID_OB, ID_GR)) {
          /* Do not set fake user on objects nor collections (instancing). */
          id_fake_user_set(local_appended_new_id);
        }
      }
    }
  }
 
  BKE_main_library_weak_reference_destroy(lapp_context->library_weak_reference_mapping);
  lapp_context->library_weak_reference_mapping = nullptr;
 
  /* Remap IDs as needed. */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    if (item.action == LINK_APPEND_ACT_KEEP_LINKED) {
      continue;
    }
 
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
    if (ELEM(item.action, LINK_APPEND_ACT_COPY_LOCAL, LINK_APPEND_ACT_REUSE_LOCAL)) {
      BLI_assert(ID_IS_LINKED(id));
      id = id->newid;
      if (id == nullptr) {
        continue;
      }
    }
 
    BLI_assert(!ID_IS_LINKED(id));
 
    BKE_libblock_relink_to_newid(bmain, id, 0);
  }
 
  /* Remove linked IDs when a local existing data has been reused instead. */
  BKE_main_id_tag_all(bmain, ID_TAG_DOIT, false);
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    if (!ELEM(item.action, LINK_APPEND_ACT_COPY_LOCAL, LINK_APPEND_ACT_REUSE_LOCAL)) {
      continue;
    }
 
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
    BLI_assert(ID_IS_LINKED(id));
    BLI_assert(id->newid != nullptr);
 
    /* Calling code may want to access newly appended IDs from the link/append context items. */
    item.new_id = id->newid;
 
    /* Only the 'reuse local' action should leave unused newly linked data behind. */
    if (item.action != LINK_APPEND_ACT_REUSE_LOCAL) {
      continue;
    }
    /* Do NOT delete a linked data that was already linked before this append. */
    if (id->tag & ID_TAG_PRE_EXISTING) {
      continue;
    }
    /* Do NOT delete a linked data that is (also) used a liboverride dependency. */
    BLI_assert((item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY_ONLY) == 0);
    if (item.tag & LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY) {
      continue;
    }
 
    id->tag |= ID_TAG_DOIT;
  }
  BKE_id_multi_tagged_delete(bmain);
 
  BKE_main_id_newptr_and_tag_clear(bmain);
 
  BlendFileReadReport bf_reports{};
  bf_reports.reports = reports;
  BLO_read_do_version_after_setup(bmain, lapp_context, &bf_reports);
 
  BLO_readfile_id_runtime_data_free_all(*bmain);
}


 
static int foreach_libblock_link_finalize_cb(LibraryIDLinkCallbackData *cb_data)
{
  if (!foreach_libblock_link_append_common_processing(cb_data, foreach_libblock_link_finalize_cb))
  {
    return IDWALK_RET_NOP;
  }
  ID *id = *cb_data->id_pointer;
  const BlendfileLinkAppendContextCallBack *data =
      static_cast<BlendfileLinkAppendContextCallBack *>(cb_data->user_data);
 
  if ((id->tag & ID_TAG_PRE_EXISTING) != 0) {
    /* About to re-use a linked data that was already there, and that will stay linked. This case
     * does not need any further processing of the child hierarchy (existing linked data
     * instantiation status should not be modified here). */
    return IDWALK_RET_NOP;
  }
 
  /* In linking case, all linked IDs are considered for instantiation, including from other
   * libraries. So all linked IDs that were not skipped so far need to be added to the items
   * list.
   */
  BlendfileLinkAppendContextItem *item = data->lapp_context->new_id_to_item.lookup_default(
      id, nullptr);
  /* NOTE: liboverride info (tags like #LINK_APPEND_TAG_LIBOVERRIDE_DEPENDENCY) can be
   * ignored/skipped here, since all data are kept linked anyway, they are not useful currently.
   */
  if (item == nullptr) {
    item = BKE_blendfile_link_append_context_item_add(
        data->lapp_context, BKE_id_name(*id), GS(id->name), nullptr);
    item->new_id = id;
    item->source_library = id->lib;
    /* Since there is no item for that ID yet, the user did not select it explicitly, it was
     * rather linked indirectly. This info is important for instantiation of collections. */
    item->tag |= LINK_APPEND_TAG_INDIRECT;
    /* In linking case we already know what we want to do with these items. */
    item->action = LINK_APPEND_ACT_KEEP_LINKED;
    new_id_to_item_mapping_add(*data->lapp_context, id, *item);
  }
  return IDWALK_RET_NOP;
}
 
void BKE_blendfile_link_append_instantiate_loose(BlendfileLinkAppendContext *lapp_context,
                                                 ReportList *reports)
{
  BLI_assert(ELEM(lapp_context->process_stage,
                  BlendfileLinkAppendContext::ProcessStage::Linking,
                  BlendfileLinkAppendContext::ProcessStage::Appending));
  lapp_context->process_stage = BlendfileLinkAppendContext::ProcessStage::Instantiating;
 
  if (!lapp_context->params->context.scene) {
    return;
  }
  if (lapp_context->params->flag & FILE_LINK) {
    new_id_to_item_mapping_create(*lapp_context);
    /* Add items for all not yet known IDs (i.e. implicitly linked indirect dependencies) to the
     * list.
     * NOTE: Since items are appended to the list, this list will grow and these IDs will be
     * processed later, leading to a flatten recursive processing of all the linked dependencies.
     */
    for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
      ID *id = item.new_id;
      if (id == nullptr) {
        continue;
      }
      BLI_assert(item.userdata == nullptr);
 
      BlendfileLinkAppendContextCallBack cb_data{};
      cb_data.lapp_context = lapp_context;
      cb_data.item = &item;
      cb_data.reports = reports;
      BKE_library_foreach_ID_link(lapp_context->params->bmain,
                                  id,
                                  foreach_libblock_link_finalize_cb,
                                  &cb_data,
                                  IDWALK_NOP);
    }
  }
 
  LooseDataInstantiateContext instantiate_context{};
  instantiate_context.lapp_context = lapp_context;
  instantiate_context.active_collection = nullptr;
  loose_data_instantiate(&instantiate_context);
}
 
void BKE_blendfile_link(BlendfileLinkAppendContext *lapp_context, ReportList *reports)
{
  BLI_assert(lapp_context->process_stage == BlendfileLinkAppendContext::ProcessStage::Init);
  lapp_context->process_stage = BlendfileLinkAppendContext::ProcessStage::Linking;
 
  if (lapp_context->items.empty()) {
    /* Nothing to be linked. */
    return;
  }
 
  BLI_assert(!lapp_context->libraries.is_empty());
 
  Main *mainl;
  Library *lib;
 
  for (const int lib_idx : lapp_context->libraries.index_range()) {
    BlendfileLinkAppendContextLibrary &lib_context = lapp_context->libraries[lib_idx];
    const char *libname = lib_context.path.c_str();
 
    if (!link_append_context_library_blohandle_ensure(*lapp_context, lib_context, reports)) {
      /* Unlikely since we just browsed it, but possible
       * Error reports will have been made by BLO_blendhandle_from_file() */
      continue;
    }
 
    /* here appending/linking starts */
 
    mainl = BLO_library_link_begin(&lib_context.blo_handle, libname, lapp_context->params);
    lib = mainl->curlib;
    BLI_assert(lib != nullptr);
    /* In case lib was already existing but not found originally, see #99820. */
    lib->id.tag &= ~ID_TAG_MISSING;
 
    if (mainl->versionfile < 250) {
      BKE_reportf(reports,
                  RPT_WARNING,
                  "Linking or appending from a very old .blend file format (%d.%d), no animation "
                  "conversion will "
                  "be done! You may want to re-save your lib file with current Blender",
                  mainl->versionfile,
                  mainl->subversionfile);
    }
 
    /* For each lib file, we try to link all items belonging to that lib,
     * and tag those successful to not try to load them again with the other libraries. */
    for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
      ID *new_id;
 
      if (!item.libraries[lib_idx]) {
        continue;
      }
 
      new_id = BLO_library_link_named_part(
          mainl, &lib_context.blo_handle, item.idcode, item.name.c_str(), lapp_context->params);
 
      if (new_id) {
        /* If the link is successful, clear item's libraries 'todo' flags.
         * This avoids trying to link same item with other libraries to come. */
        item.libraries.fill(false);
        item.new_id = new_id;
        item.source_library = new_id->lib;
      }
    }
 
    BLO_library_link_end(mainl, &lib_context.blo_handle, lapp_context->params, reports);
    link_append_context_library_blohandle_release(*lapp_context, lib_context);
  }
 
  /* In linking case finalizing process (ensuring all data is valid, instantiating loose
   * collections or objects, etc.) can be done here directly.
   *
   * In append case, the finalizing process is much more complex and requires and additional call
   * to #BKE_blendfile_append for caller code. */
  if (lapp_context->params->flag & FILE_LINK) {
    BlendFileReadReport bf_reports{};
    bf_reports.reports = reports;
    BLO_read_do_version_after_setup(lapp_context->params->bmain, lapp_context, &bf_reports);
 
    BLO_readfile_id_runtime_data_free_all(*lapp_context->params->bmain);
  }
}
 
void BKE_blendfile_override(BlendfileLinkAppendContext *lapp_context,
                            const eBKELibLinkOverride flags,
                            ReportList * /*reports*/)
{
  if (lapp_context->items.empty()) {
    /* Nothing to override. */
    return;
  }
 
  Main *bmain = lapp_context->params->bmain;
 
  /* Liboverride only makes sense if data was linked, not appended. */
  BLI_assert((lapp_context->params->flag & FILE_LINK) != 0);
 
  const bool set_runtime = (flags & BKE_LIBLINK_OVERRIDE_CREATE_RUNTIME) != 0;
  const bool do_use_exisiting_liboverrides = (flags &
                                              BKE_LIBLINK_OVERRIDE_USE_EXISTING_LIBOVERRIDES) != 0;
 
  blender::Map<ID *, ID *> linked_ids_to_local_liboverrides;
  if (do_use_exisiting_liboverrides) {
    ID *id_iter;
    FOREACH_MAIN_ID_BEGIN (bmain, id_iter) {
      if (ID_IS_LINKED(id_iter)) {
        continue;
      }
      if (!ID_IS_OVERRIDE_LIBRARY_REAL(id_iter)) {
        continue;
      }
      /* Do not consider regular liboverrides if runtime ones are requested, and vice-versa. */
      if ((set_runtime && (id_iter->tag & ID_TAG_RUNTIME) == 0) ||
          (!set_runtime && (id_iter->tag & ID_TAG_RUNTIME) != 0))
      {
        continue;
      }
 
      /* In case several liboverrides exist of the same data, only consider the first found one, so
       * don't use `add_overwrite`. */
      linked_ids_to_local_liboverrides.add(id_iter->override_library->reference, id_iter);
    }
    FOREACH_MAIN_ID_END;
  }
 
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *id = item.new_id;
    if (id == nullptr) {
      continue;
    }
    BLI_assert(item.userdata == nullptr);
 
    if (do_use_exisiting_liboverrides) {
      item.liboverride_id = linked_ids_to_local_liboverrides.lookup_default(id, nullptr);
    }
    if (item.liboverride_id == nullptr) {
      item.liboverride_id = BKE_lib_override_library_create_from_id(bmain, id, false);
      if (set_runtime) {
        item.liboverride_id->tag |= ID_TAG_RUNTIME;
        if ((id->tag & ID_TAG_PRE_EXISTING) == 0) {
          /* If the linked ID is newly linked, in case its override is runtime-only, assume its
           * reference to be indirectly linked.
           *
           * This is more of an heuristic for 'as best as possible' user feedback in the UI
           * (Outliner), which is expected to be valid in almost all practical use-cases. Direct or
           * indirect linked status is properly checked before saving .blend file. */
          id->tag &= ~ID_TAG_EXTERN;
          id->tag |= ID_TAG_INDIRECT;
        }
      }
    }
  }
 
  BKE_main_namemap_clear(*bmain);
}


 
static void blendfile_library_relocate_id_remap_do(Main *bmain,
                                                   ID *old_id,
                                                   ID *new_id,
                                                   ReportList *reports,
                                                   const bool do_reload,
                                                   const int remap_flags)
{
  BLI_assert(old_id);
  if (do_reload) {
    /* Since we asked for placeholders in case of missing IDs,
     * we expect to always get a valid one. */
    BLI_assert(new_id);
  }
  if (new_id) {
    CLOG_INFO(&LOG,
              4,
              "Before remap of %s, old_id users: %d, new_id users: %d",
              old_id->name,
              old_id->us,
              new_id->us);
    BKE_libblock_remap_locked(bmain, old_id, new_id, remap_flags);
 
    if (old_id->flag & ID_FLAG_FAKEUSER) {
      id_fake_user_clear(old_id);
      id_fake_user_set(new_id);
    }
 
    CLOG_INFO(&LOG,
              4,
              "After remap of %s, old_id users: %d, new_id users: %d",
              old_id->name,
              old_id->us,
              new_id->us);
 
    /* In some cases, new_id might become direct link, remove parent of library in this case. */
    if (new_id->lib->runtime->parent && (new_id->tag & ID_TAG_INDIRECT) == 0) {
      if (do_reload) {
        BLI_assert_unreachable(); /* Should not happen in 'pure' reload case... */
      }
      new_id->lib->runtime->parent = nullptr;
    }
  }
 
  if (old_id->us > 0 && new_id && old_id->lib == new_id->lib) {
    /* Note that this *should* not happen - but better be safe than sorry in this area,
     * at least until we are 100% sure this cannot ever happen.
     * Also, we can safely assume names were unique so far,
     * so just replacing '.' by '~' should work,
     * but this does not totally rules out the possibility of name collision. */
    size_t len = strlen(old_id->name);
    size_t dot_pos;
    bool has_num = false;
 
    for (dot_pos = len; dot_pos--;) {
      char c = old_id->name[dot_pos];
      if (c == '.') {
        break;
      }
      if (c < '0' || c > '9') {
        has_num = false;
        break;
      }
      has_num = true;
    }
 
    if (has_num) {
      old_id->name[dot_pos] = '~';
    }
    else {
      len = std::min<size_t>(len, MAX_ID_NAME - 7);
      BLI_strncpy(&old_id->name[len], "~000", 7);
    }
 
    id_sort_by_name(which_libbase(bmain, GS(old_id->name)), old_id, nullptr);
 
    BKE_reportf(
        reports,
        RPT_WARNING,
        "Lib Reload: Replacing all references to old data-block '%s' by reloaded one failed, "
        "old one (%d remaining users) had to be kept and was renamed to '%s'",
        new_id->name,
        old_id->us,
        old_id->name);
  }
}
 
static void blendfile_library_relocate_id_remap(Main *bmain,
                                                ID *old_id,
                                                ID *new_id,
                                                ReportList *reports,
                                                const bool do_reload,
                                                const int remap_flags)
{
  blendfile_library_relocate_id_remap_do(bmain, old_id, new_id, reports, do_reload, remap_flags);
  if (new_id == nullptr) {
    return;
  }
  /* Usual special code for ShapeKeys snowflakes... */
  Key **old_key_p = BKE_key_from_id_p(old_id);
  if (old_key_p == nullptr) {
    return;
  }
  Key *old_key = *old_key_p;
  Key *new_key = BKE_key_from_id(new_id);
  if (old_key != nullptr) {
    *old_key_p = nullptr;
    id_us_min(&old_key->id);
    blendfile_library_relocate_id_remap_do(
        bmain, &old_key->id, &new_key->id, reports, do_reload, remap_flags);
    *old_key_p = old_key;
    id_us_plus_no_lib(&old_key->id);
  }
}

static void blendfile_relocate_postprocess_cleanup(BlendfileLinkAppendContext &lapp_context)
{
  Main &bmain = *lapp_context.params->bmain;
 
  blender::Set<ID *> ids_to_delete = {};
  ID *id_iter;
 
  /* Delete all no more used old IDs. */
  /* NOTE: While this looping over until we are sure we deleted everything is very far from
   * efficient, doing otherwise would require a much more complex handling of indirectly linked IDs
   * in steps above. Currently, in case of relocation, those are skipped in remapping phase, though
   * in some cases (essentially internal links between IDs from the same library) remapping should
   * happen. But getting this to work reliably would be very difficult, so since this is not a
   * performance-critical code, better to go with the (relatively) simpler, brute-force approach
   * here in 'removal of old IDs' step. */
  bool keep_looping = true;
  while (keep_looping) {
    keep_looping = false;
 
    for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
      ID *old_id = static_cast<ID *>(item.userdata);
 
      if (old_id == nullptr) {
        continue;
      }
 
      if (GS(old_id->name) == ID_KE) {
        /* Shape Keys are handled as part of their owning obdata (see below). This implies that
         * there is no way to know when the old pointer gets invalid, so just clear it immediately.
         */
        item.userdata = nullptr;
        continue;
      }
 
      /* In case the active scene was reloaded, the context pointers in
       * `lapp_context->params->context` need to be updated before the old Scene ID is freed. */
      if (old_id == &lapp_context.params->context.scene->id) {
        BLI_assert(GS(old_id->name) == ID_SCE);
        Scene *new_scene = reinterpret_cast<Scene *>(item.new_id);
        BLI_assert(new_scene != nullptr);
        lapp_context.params->context.scene = new_scene;
        if (lapp_context.params->context.view_layer != nullptr) {
          ViewLayer *new_view_layer = BKE_view_layer_find(
              new_scene, lapp_context.params->context.view_layer->name);
          lapp_context.params->context.view_layer = static_cast<ViewLayer *>(
              (new_view_layer != nullptr) ? new_view_layer : new_scene->view_layers.first);
        }
        /* lapp_context->params->context.v3d should never be made invalid by newly linked data
         * here, as it is UI data, ultimately owned by a #bScreen ID, which is not linkable. */
      }
 
      if (old_id->us == 0) {
        ids_to_delete.add(old_id);
        item.userdata = nullptr;
        keep_looping = true;
        Key *old_key = BKE_key_from_id(old_id);
        if (old_key != nullptr) {
          ids_to_delete.add(&old_key->id);
        }
      }
    }
    BKE_id_multi_delete(&bmain, ids_to_delete);
    ids_to_delete.clear();
  }
 
  /* Some datablocks can get reloaded/replaced 'silently' because they are not linkable
   * (shape keys e.g.), so we need another loop here to clear old ones if possible. */
  FOREACH_MAIN_ID_BEGIN (&bmain, id_iter) {
    /* XXX That check may be a bit to generic/permissive? */
    if (id_iter->lib && (id_iter->flag & ID_TAG_PRE_EXISTING) && id_iter->us == 0) {
      ids_to_delete.add(id_iter);
    }
  }
  FOREACH_MAIN_ID_END;
  BKE_id_multi_delete(&bmain, ids_to_delete);
  ids_to_delete.clear();
 
  /* Get rid of no more used libraries... */
  ListBase *libraries = which_libbase(&bmain, ID_LI);
  LISTBASE_FOREACH (ID *, id_iter, libraries) {
    ids_to_delete.add(id_iter);
  }
  FOREACH_MAIN_ID_BEGIN (&bmain, id_iter) {
    if (id_iter->lib) {
      ids_to_delete.remove(&id_iter->lib->id);
    }
  }
  FOREACH_MAIN_ID_END;
  BKE_id_multi_delete(&bmain, ids_to_delete);
}

static void blendfile_relocate_postprocess_liboverrides(
    BlendfileLinkAppendContext &lapp_context,
    const blender::Map<Library *, Library *> &new_to_old_libraries_map,
    ReportList *reports)
{
  Main &bmain = *lapp_context.params->bmain;
 
  ID *id_iter;
  FOREACH_MAIN_ID_BEGIN (&bmain, id_iter) {
    if (ID_IS_LINKED(id_iter) || !ID_IS_OVERRIDE_LIBRARY_REAL(id_iter) ||
        (id_iter->tag & ID_TAG_PRE_EXISTING) == 0)
    {
      continue;
    }
    if ((id_iter->override_library->reference->tag & ID_TAG_MISSING) == 0) {
      id_iter->tag &= ~ID_TAG_MISSING;
    }
    if ((id_iter->override_library->reference->tag & ID_TAG_PRE_EXISTING) == 0) {
      BKE_lib_override_library_update(&bmain, id_iter);
    }
  }
  FOREACH_MAIN_ID_END;
 
  BKE_library_main_rebuild_hierarchy(&bmain);
 
  /* Resync overrides if needed. */
  if (liboverride::is_auto_resync_enabled() && lapp_context.params->context.scene != nullptr) {
    BlendFileReadReport report{};
    report.reports = reports;
    BKE_lib_override_library_main_resync(&bmain,
                                         &new_to_old_libraries_map,
                                         lapp_context.params->context.scene,
                                         lapp_context.params->context.view_layer,
                                         &report);
    /* We need to rebuild some of the deleted override rules (for UI feedback purpose). */
    BKE_lib_override_library_main_operations_create(&bmain, true, nullptr);
  }
}
 
void BKE_blendfile_library_relocate(BlendfileLinkAppendContext *lapp_context,
                                    ReportList *reports,
                                    Library *library,
                                    const bool do_reload)
{
  Main *bmain = lapp_context->params->bmain;
 
  /* All override rules need to be up to date, since there will be no do_version here, otherwise
   * older, now-invalid rules might be applied and likely fail, or some changes might be missing,
   * etc. See #93353. */
  BKE_lib_override_library_main_operations_create(bmain, true, nullptr);
 
  /* Remove all IDs to be reloaded from Main. */
  MainListsArray lbarray = BKE_main_lists_get(*bmain);
  int lba_idx = lbarray.size();
  while (lba_idx--) {
    ID *id = static_cast<ID *>(lbarray[lba_idx]->first);
    const short idcode = id ? GS(id->name) : 0;
 
    if (!id || !BKE_idtype_idcode_is_linkable(idcode)) {
      /* No need to reload non-linkable data-types,
       * those will get relinked with their 'users ID'. */
      continue;
    }
 
    for (; id; id = static_cast<ID *>(id->next)) {
      if (id->lib == library) {
        BlendfileLinkAppendContextItem *item;
 
        /* We remove it from current Main, and add it to items to link... */
        /* Note that non-linkable IDs (like e.g. shape-keys) are also explicitly linked here... */
        BLI_remlink(lbarray[lba_idx], id);
        /* Usual special code for ShapeKeys snowflakes... */
        Key *old_key = BKE_key_from_id(id);
        if (old_key != nullptr) {
          BLI_remlink(which_libbase(bmain, GS(old_key->id.name)), &old_key->id);
        }
 
        item = BKE_blendfile_link_append_context_item_add(
            lapp_context, BKE_id_name(*id), idcode, id);
        item->libraries.fill(true);
 
        CLOG_INFO(&LOG, 4, "Datablock to seek for: %s", id->name);
      }
    }
  }
 
  if (lapp_context->items.empty()) {
    /* Early out in case there is nothing to do. */
    return;
  }
 
  BKE_main_id_tag_all(bmain, ID_TAG_PRE_EXISTING, true);
 
  /* Since some IDs have been removed from Main, trying to rebuild collections hierarchy should not
   * happen. It has to be done manually below once removed IDs have been added back to Main. Also
   * see #136432. */
  lapp_context->params->flag |= BLO_LIBLINK_COLLECTION_NO_HIERARCHY_REBUILD;
 
  BKE_blendfile_link_append_context_init_done(lapp_context);
 
  /* We do not want any instantiation here! */
  BKE_blendfile_link(lapp_context, reports);
 
  BKE_main_lock(bmain);
 
  /* We add back old id to bmain.
   * We need to do this in a first, separated loop, otherwise some of those may not be handled by
   * ID remapping, which means they would still reference old data to be deleted... */
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *old_id = static_cast<ID *>(item.userdata);
 
    BLI_assert(old_id);
    BLI_addtail(which_libbase(bmain, GS(old_id->name)), old_id);
 
    /* Usual special code for ShapeKeys snowflakes... */
    Key *old_key = BKE_key_from_id(old_id);
    if (old_key != nullptr) {
      BLI_addtail(which_libbase(bmain, GS(old_key->id.name)), &old_key->id);
    }
  }
 
  /* FIXME Temporary 'fix' to a problem in how temp ID are copied in
   * `BKE_lib_override_library_main_update`, see #103062.
   * Proper fix involves first addressing #90610. */
  BKE_main_collections_parent_relations_rebuild(bmain);
 
  /* Since our (old) reloaded IDs were removed from main, the user count done for them in linking
   * code is wrong, we need to redo it here after adding them back to main. */
  BKE_main_id_refcount_recompute(bmain, false);
 
  /* Mapping from old to new libraries, needed to allow liboverride resync to map properly old and
   * new data. */
  blender::Map<Library *, Library *> new_to_old_libraries_map;
 
  BKE_layer_collection_resync_forbid();
  /* Note that in reload case, we also want to replace indirect usages. */
  const int remap_flags = ID_REMAP_SKIP_NEVER_NULL_USAGE |
                          (do_reload ? 0 : ID_REMAP_SKIP_INDIRECT_USAGE);
  for (BlendfileLinkAppendContextItem &item : lapp_context->items) {
    ID *old_id = static_cast<ID *>(item.userdata);
    ID *new_id = item.new_id;
    if (new_id) {
      new_to_old_libraries_map.add(new_id->lib, old_id->lib);
    }
    blendfile_library_relocate_id_remap(bmain, old_id, new_id, reports, do_reload, remap_flags);
  }
  BKE_layer_collection_resync_allow();
  BKE_main_collection_sync_remap(bmain);
 
  BKE_main_unlock(bmain);
 
  /* Delete all no more used old IDs. */
  blendfile_relocate_postprocess_cleanup(*lapp_context);
 
  /* Update and resync liboverrides of reloaded linked data-blocks. */
  blendfile_relocate_postprocess_liboverrides(*lapp_context, new_to_old_libraries_map, reports);
 
  BKE_main_collection_sync(bmain);
}
 
void BKE_blendfile_id_relocate(BlendfileLinkAppendContext &lapp_context, ReportList *reports)
{
  if (lapp_context.items.empty()) {
    /* Nothing to relocate. */
    return;
  }
  /* Only support relocating one ID at a time currently. */
  BLI_assert(lapp_context.items.size() == 1);
 
  Main *bmain = lapp_context.params->bmain;
 
  /* Relocate only works on linked data currently. */
  BLI_assert((lapp_context.params->flag & FILE_LINK) != 0);
 
  /* Tag everything, its generally useful to know what is new.
   *
   * Take extra care `BKE_main_id_flag_all(bmain, ID_TAG_PRE_EXISTING, false)` is called after! */
  BKE_main_id_tag_all(bmain, ID_TAG_PRE_EXISTING, true);
 
  /* XXX We'd need re-entrant locking on Main for this to work... */
  // BKE_main_lock(bmain);
 
  BKE_blendfile_link(&lapp_context, reports);
 
  // BKE_main_unlock(bmain);
 
  /* Finalize relocation (remap ID usages, rebuild LibOverrides if needed, etc.). */
 
  /* Mapping from old to new libraries, needed to allow liboverride resync to map properly old and
   * new data. */
  blender::Map<Library *, Library *> new_to_old_libraries_map{};
 
  /* The first item should be the root of the relocation, and the only one containing a non-null
   * `userdata`. */
  BlendfileLinkAppendContextItem &root_item = lapp_context.items.front();
  BLI_assert(root_item.userdata);
  ID *old_id = static_cast<ID *>(root_item.userdata);
  ID *new_id = root_item.new_id;
  new_to_old_libraries_map.add(new_id->lib, old_id->lib);
  BLI_assert(GS(old_id->name) == GS(new_id->name));
#ifndef NDEBUG
  for (BlendfileLinkAppendContextItem &item : lapp_context.items) {
    BLI_assert(&item == &root_item || item.userdata == nullptr);
  }
#endif
 
  BKE_main_lock(bmain);
  BKE_layer_collection_resync_forbid();
 
  /* Do not affect indirect usages. */
  const int remap_flags = ID_REMAP_SKIP_NEVER_NULL_USAGE | ID_REMAP_SKIP_INDIRECT_USAGE;
  blendfile_library_relocate_id_remap(bmain, old_id, new_id, reports, false, remap_flags);
 
  BKE_layer_collection_resync_allow();
  BKE_main_collection_sync_remap(bmain);
  BKE_main_unlock(bmain);
 
  /* Delete all no more used old IDs. */
  blendfile_relocate_postprocess_cleanup(lapp_context);
 
  /* Update and resync liboverrides of reloaded linked data-blocks. */
  blendfile_relocate_postprocess_liboverrides(lapp_context, new_to_old_libraries_map, reports);
 
  BKE_main_collection_sync(bmain);
 
  /* Important we unset, otherwise these object won't
   * link into other scenes from this blend file. */
  BKE_main_id_tag_all(bmain, ID_TAG_PRE_EXISTING, false);
}