[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