[Bf-blender-cvs] [ab324e8ea3f] asset-engine: Merge branch 'asset-uuid' into asset-engine

Bastien Montagne noreply at git.blender.org
Tue Nov 26 18:13:36 CET 2019


Commit: ab324e8ea3f6796f607f2ba8ff0498c33fc57172
Author: Bastien Montagne
Date:   Tue Nov 26 17:37:24 2019 +0100
Branches: asset-engine
https://developer.blender.org/rBab324e8ea3f6796f607f2ba8ff0498c33fc57172

Merge branch 'asset-uuid' into asset-engine

Conflicts:
	source/blender/blenloader/BLO_readfile.h
	source/blender/blenloader/intern/writefile.c

===================================================================



===================================================================

diff --cc source/blender/blenkernel/intern/asset_engine.c
index 82e85f9e137,60c27a44eff..872086e9043
--- a/source/blender/blenkernel/intern/asset_engine.c
+++ b/source/blender/blenkernel/intern/asset_engine.c
@@@ -63,401 -48,13 +63,407 @@@
  #  include "BPY_extern.h"
  #endif
  
 +/* Asset engine types (none intern!). */
 +
 +ListBase asset_engines = {NULL, NULL};
 +
 +void BKE_asset_engines_init(void)
 +{
 +  /* We just add a dummy engine, which 'is' our intern filelisting code from space_file! */
 +  AssetEngineType *aet = MEM_callocN(sizeof(*aet), __func__);
 +
 +  BLI_strncpy(aet->idname, AE_FAKE_ENGINE_ID, sizeof(aet->idname));
 +  BLI_strncpy(aet->name, "None", sizeof(aet->name));
 +
 +  BLI_addhead(&asset_engines, aet);
 +}
 +
 +void BKE_asset_engines_exit(void)
 +{
 +  AssetEngineType *type, *next;
 +
 +  for (type = asset_engines.first; type; type = next) {
 +    next = type->next;
 +
 +    BLI_remlink(&asset_engines, type);
 +
 +    if (type->ext.free) {
 +      type->ext.free(type->ext.data);
 +    }
 +
 +    MEM_freeN(type);
 +  }
 +}
 +
 +AssetEngineType *BKE_asset_engines_find(const char *idname)
 +{
 +  AssetEngineType *type;
 +
 +  type = BLI_findstring(&asset_engines, idname, offsetof(AssetEngineType, idname));
 +
 +  return type;
 +}
 +
 +AssetEngineType *BKE_asset_engines_get_default(char *r_idname, const size_t len)
 +{
 +  AssetEngineType *type = asset_engines.first;
 +
 +  BLI_assert(type);
 +
 +  if (r_idname) {
 +    BLI_strncpy(r_idname, type->idname, len);
 +  }
 +
 +  return type;
 +}
 +
 +/* Asset engine instances. */
 +
 +/* Create, Free */
 +
 +AssetEngine *BKE_asset_engine_create(AssetEngineType *type, ReportList *reports)
 +{
 +  AssetEngine *engine;
 +
 +  BLI_assert(type);
 +
 +  engine = MEM_callocN(sizeof(AssetEngine), __func__);
 +  engine->type = type;
 +  engine->refcount = 1;
 +
 +  /* initialize error reports */
 +  if (reports) {
 +    engine->reports = reports; /* must be initialized already */
 +  }
 +  else {
 +    engine->reports = MEM_mallocN(sizeof(ReportList), __func__);
 +    BKE_reports_init(engine->reports, RPT_STORE | RPT_FREE);
 +  }
 +
 +  return engine;
 +}
 +
 +/** Shalow copy only (i.e. memory is 100% shared, just increases refcount). */
 +AssetEngine *BKE_asset_engine_copy(AssetEngine *engine)
 +{
 +  engine->refcount++;
 +  return engine;
 +}
 +
 +void BKE_asset_engine_free(AssetEngine *engine)
 +{
 +  if (engine->refcount-- == 1) {
 +#ifdef WITH_PYTHON
 +    if (engine->py_instance) {
 +      BPY_DECREF_RNA_INVALIDATE(engine->py_instance);
 +    }
 +#endif
 +
 +    if (engine->properties) {
 +      IDP_FreeProperty(engine->properties);
 +    }
 +
 +    if (engine->reports && (engine->reports->flag & RPT_FREE)) {
 +      BKE_reports_clear(engine->reports);
 +      MEM_freeN(engine->reports);
 +    }
 +
 +    MEM_freeN(engine);
 +  }
 +}
 +
 +/* API helpers. */
 +
 +static void asset_engine_load_pre(AssetEngine *engine,
 +                                  AssetUUIDList *r_uuids,
 +                                  FileDirEntryArr *r_entries)
 +{
 +  FileDirEntry *en;
 +  AssetUUID *uuid;
 +  const int nbr_entries = r_entries->nbr_entries ? r_entries->nbr_entries : r_uuids->nbr_uuids;
 +
 +  if (r_entries->nbr_entries) {
 +    BLI_assert(r_uuids->uuids == NULL);
 +    r_uuids->uuids = MEM_callocN(sizeof(*r_uuids->uuids) * nbr_entries, __func__);
 +    r_uuids->nbr_uuids = nbr_entries;
 +    r_uuids->asset_engine_version = engine->type->version;
 +
 +    for (en = r_entries->entries.first, uuid = r_uuids->uuids; en; en = en->next, uuid++) {
 +      memcpy(uuid->uuid_repository, en->uuid_repository, sizeof(uuid->uuid_repository));
 +
 +      memcpy(uuid->uuid_asset, en->uuid, sizeof(uuid->uuid_asset));
 +
 +      FileDirEntryVariant *var = BLI_findlink(&en->variants, en->act_variant);
 +      BLI_assert(var);
 +      memcpy(uuid->uuid_variant, var->uuid, sizeof(uuid->uuid_variant));
 +
 +      FileDirEntryRevision *rev = BLI_findlink(&var->revisions, var->act_revision);
 +      BLI_assert(rev);
 +      memcpy(uuid->uuid_revision, rev->uuid, sizeof(uuid->uuid_revision));
 +
 +      memcpy(uuid->uuid_view, en->entry->uuid, sizeof(uuid->uuid_view));
 +    }
 +  }
 +
 +  BKE_filedir_entryarr_clear(r_entries);
 +
 +  if (!engine->type->load_pre(engine, r_uuids, r_entries)) {
 +    /* If load_pre returns false (i.e. fails), clear all paths! */
 +    /* TODO: report!!! */
 +    BKE_filedir_entryarr_clear(r_entries);
 +
 +    MEM_freeN(r_uuids->uuids);
 +    r_uuids->uuids = NULL;
 +    r_uuids->nbr_uuids = 0;
 +    return;
 +  }
 +
 +  /* load_pre may change things, we have to rebuild our uuids list from returned entries. */
 +  r_entries->nbr_entries = r_uuids->nbr_uuids = BLI_listbase_count(&r_entries->entries);
 +  r_uuids->uuids = MEM_reallocN(r_uuids->uuids, sizeof(*r_uuids->uuids) * r_uuids->nbr_uuids);
 +  for (en = r_entries->entries.first, uuid = r_uuids->uuids; en; en = en->next, uuid++) {
 +    FileDirEntryVariant *var;
 +    FileDirEntryRevision *rev;
 +    FileDirEntryView *view;
 +
 +    memcpy(uuid->uuid_repository, en->uuid_repository, sizeof(uuid->uuid_repository));
 +
 +    memcpy(uuid->uuid_asset, en->uuid, sizeof(uuid->uuid_asset));
 +
 +    var = BLI_findlink(&en->variants, en->act_variant);
 +    BLI_assert(var);
 +    memcpy(uuid->uuid_variant, var->uuid, sizeof(uuid->uuid_variant));
 +
 +    rev = BLI_findlink(&var->revisions, var->act_revision);
 +    BLI_assert(rev);
 +    memcpy(uuid->uuid_revision, rev->uuid, sizeof(uuid->uuid_revision));
 +
 +    view = BLI_findlink(&rev->views, rev->act_view);
 +    BLI_assert(view);
 +    memcpy(uuid->uuid_view, view->uuid, sizeof(uuid->uuid_view));
 +  }
 +}
 +
 +/** Call load_pre for given entries, and return new uuids/entries. */
 +AssetUUIDList *BKE_asset_engine_entries_load_pre(AssetEngine *engine, FileDirEntryArr *r_entries)
 +{
 +  AssetUUIDList *uuids = MEM_callocN(sizeof(*uuids), __func__);
 +
 +  asset_engine_load_pre(engine, uuids, r_entries);
 +
 +  return uuids;
 +}
 +
 +/** Call load_pre for given uuids, and return new uuids/entries. */
 +FileDirEntryArr *BKE_asset_engine_uuids_load_pre(AssetEngine *engine, AssetUUIDList *r_uuids)
 +{
 +  FileDirEntryArr *entries = MEM_callocN(sizeof(*entries), __func__);
 +
 +  asset_engine_load_pre(engine, r_uuids, entries);
 +
 +  return entries;
 +}
 +
 +/* FileDirxxx handling. */
 +
 +void BKE_filedir_view_free(FileDirEntryView *view)
 +{
 +  if (view->name) {
 +    MEM_freeN(view->name);
 +  }
 +  if (view->description) {
 +    MEM_freeN(view->description);
 +  }
 +  MEM_freeN(view);
 +}
 +
 +void BKE_filedir_revision_free(FileDirEntryRevision *rev)
 +{
 +  if (rev->comment) {
 +    MEM_freeN(rev->comment);
 +  }
 +
 +  if (!BLI_listbase_is_empty(&rev->views)) {
 +    FileDirEntryView *view, *view_next;
 +
 +    for (view = rev->views.first; view; view = view_next) {
 +      view_next = view->next;
 +      BKE_filedir_view_free(view);
 +    }
 +
 +    BLI_listbase_clear(&rev->views);
 +  }
 +  MEM_freeN(rev);
 +}
 +
 +void BKE_filedir_variant_free(FileDirEntryVariant *var)
 +{
 +  if (var->name) {
 +    MEM_freeN(var->name);
 +  }
 +  if (var->description) {
 +    MEM_freeN(var->description);
 +  }
 +
 +  if (!BLI_listbase_is_empty(&var->revisions)) {
 +    FileDirEntryRevision *rev, *rev_next;
 +
 +    for (rev = var->revisions.first; rev; rev = rev_next) {
 +      rev_next = rev->next;
 +      BKE_filedir_revision_free(rev);
 +    }
 +
 +    BLI_listbase_clear(&var->revisions);
 +  }
 +  MEM_freeN(var);
 +}
 +
 +void BKE_filedir_entry_clear(FileDirEntry *entry)
 +{
 +  if (entry->name) {
 +    MEM_freeN(entry->name);
 +  }
 +  if (entry->description) {
 +    MEM_freeN(entry->description);
 +  }
 +  if (entry->relpath) {
 +    MEM_freeN(entry->relpath);
 +  }
 +  if (entry->image) {
 +    IMB_freeImBuf(entry->image);
 +  }
 +  /* For now, consider FileDirEntryRevision::poin as not owned here, so no need to do anything
 +   * about it */
 +
 +  if (!BLI_listbase_is_empty(&entry->variants)) {
 +    FileDirEntryVariant *var, *var_next;
 +
 +    for (var = entry->variants.first; var; var = var_next) {
 +      var_next = var->next;
 +      BKE_filedir_variant_free(var);
 +    }
 +
 +    BLI_listbase_clear(&entry->variants);
 +  }
 +  else if (entry->entry) {
 +    MEM_freeN(entry->entry);
 +  }
 +
 +  memset(entry, 0, sizeof(*entry));
 +}
 +
 +void BKE_filedir_entry_free(FileDirEntry *entry)
 +{
 +  BKE_filedir_entry_clear(entry);
 +  MEM_freeN(entry);
 +}
 +
 +/** Perform and return a full (deep) duplicate of given entry. */
 +FileDirEntry *BKE_filedir_entry_copy(FileDirEntry *entry)
 +{
 +  FileDirEntry *entry_new = MEM_dupallocN(entry);
 +
 +  if (entry->name) {
 +    entry_new->name = MEM_dupallocN(entry->name);
 +  }
 +  if (entry->description) {
 +    entry_new->description = MEM_dupallocN(entry->description);
 +  }
 +  if (entry->relpath) {
 +    entry_new->relpath = MEM_dupallocN(entry->relpath);
 +  }
 +  if (entry->image) {
 +    entry_new->image = IMB_dupImBuf(entry->image);
 +  }
 +  /* For now, consider FileDirEntryRevision::poin as not owned here, so no need to do anything
 +   * about it */
 +
 +  entry_new->entry = NULL;
 +  if (!BLI_listbase_is_empty(&entry->variants)) {
 +    FileDirEntryVariant *var;
 +    int act_var;
 +
 +    BLI_listbase_clear(&entry_new->variants);
 +    for (act_var = 0, var = entry->variants.first; var; act_var++, var = var->next) {
 +      FileDirEntryVariant *var_new = MEM_dupallocN(var);
 +      const bool is_act_var = (act_var == entry->act_variant);
 +
 +      if (var->name) {
 +        var_new->name = MEM_dupallocN(var->name);
 +      }
 +      if (var->description) {
 +        var_new->description = MEM_dupallocN(var->description);
 +      }
 +
 +      BLI_listbase_clear(&var_new->revisions);
 +      FileDirEntryRevision *rev;
 +      int act_rev;
 +      for (act_rev = 0, rev = var->revisions.first; rev; act_rev++, rev = rev->next) {
 +        FileDirEntryRevision *rev_new = MEM_dupallocN(rev);
 +        const bool is_act_rev = (act_rev == var->act_revision);
 +
 +        if (rev->comment) {
 +          rev_new->comment = MEM_dupallocN(rev->comment);
 +        }
 +
 +        BLI_listbase_clear(&rev_new->views);
 +        FileDirEntryV

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list