From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- source/blender/blenkernel/intern/collection.c | 1577 +++++++++++++------------ 1 file changed, 808 insertions(+), 769 deletions(-) (limited to 'source/blender/blenkernel/intern/collection.c') diff --git a/source/blender/blenkernel/intern/collection.c b/source/blender/blenkernel/intern/collection.c index eadf190c363..38094841e4a 100644 --- a/source/blender/blenkernel/intern/collection.c +++ b/source/blender/blenkernel/intern/collection.c @@ -52,10 +52,17 @@ /******************************** Prototypes ********************************/ -static bool collection_child_add(Collection *parent, Collection *collection, const int flag, const bool add_us); +static bool collection_child_add(Collection *parent, + Collection *collection, + const int flag, + const bool add_us); static bool collection_child_remove(Collection *parent, Collection *collection); -static bool collection_object_add(Main *bmain, Collection *collection, Object *ob, int flag, const bool add_us); -static bool collection_object_remove(Main *bmain, Collection *collection, Object *ob, const bool free_us); +static bool collection_object_add( + Main *bmain, Collection *collection, Object *ob, int flag, const bool add_us); +static bool collection_object_remove(Main *bmain, + Collection *collection, + Object *ob, + const bool free_us); static CollectionChild *collection_find_child(Collection *parent, Collection *collection); static CollectionParent *collection_find_parent(Collection *child, Collection *collection); @@ -65,30 +72,32 @@ static bool collection_find_child_recursive(Collection *parent, Collection *coll /***************************** Add Collection *******************************/ /* Add new collection, without view layer syncing. */ -static Collection *collection_add(Main *bmain, Collection *collection_parent, const char *name_custom) +static Collection *collection_add(Main *bmain, + Collection *collection_parent, + const char *name_custom) { - /* Determine new collection name. */ - char name[MAX_NAME]; + /* Determine new collection name. */ + char name[MAX_NAME]; - if (name_custom) { - STRNCPY(name, name_custom); - } - else { - BKE_collection_new_name_get(collection_parent, name); - } + if (name_custom) { + STRNCPY(name, name_custom); + } + else { + BKE_collection_new_name_get(collection_parent, name); + } - /* Create new collection. */ - Collection *collection = BKE_libblock_alloc(bmain, ID_GR, name, 0); + /* Create new collection. */ + Collection *collection = BKE_libblock_alloc(bmain, ID_GR, name, 0); - /* We increase collection user count when linking to Collections. */ - id_us_min(&collection->id); + /* We increase collection user count when linking to Collections. */ + id_us_min(&collection->id); - /* Optionally add to parent collection. */ - if (collection_parent) { - collection_child_add(collection_parent, collection, 0, true); - } + /* Optionally add to parent collection. */ + if (collection_parent) { + collection_child_add(collection_parent, collection, 0, true); + } - return collection; + return collection; } /** @@ -97,9 +106,9 @@ static Collection *collection_add(Main *bmain, Collection *collection_parent, co */ Collection *BKE_collection_add(Main *bmain, Collection *collection_parent, const char *name_custom) { - Collection *collection = collection_add(bmain, collection_parent, name_custom); - BKE_main_collection_sync(bmain); - return collection; + Collection *collection = collection_add(bmain, collection_parent, name_custom); + BKE_main_collection_sync(bmain); + return collection; } /*********************** Free and Delete Collection ****************************/ @@ -107,14 +116,14 @@ Collection *BKE_collection_add(Main *bmain, Collection *collection_parent, const /** Free (or release) any data used by this collection (does not free the collection itself). */ void BKE_collection_free(Collection *collection) { - /* No animdata here. */ - BKE_previewimg_free(&collection->preview); + /* No animdata here. */ + BKE_previewimg_free(&collection->preview); - BLI_freelistN(&collection->gobject); - BLI_freelistN(&collection->children); - BLI_freelistN(&collection->parents); + BLI_freelistN(&collection->gobject); + BLI_freelistN(&collection->children); + BLI_freelistN(&collection->parents); - BKE_collection_object_cache_free(collection); + BKE_collection_object_cache_free(collection); } /** @@ -123,55 +132,57 @@ void BKE_collection_free(Collection *collection) */ bool BKE_collection_delete(Main *bmain, Collection *collection, bool hierarchy) { - /* Master collection is not real datablock, can't be removed. */ - if (collection->flag & COLLECTION_IS_MASTER) { - BLI_assert(!"Scene master collection can't be deleted"); - return false; - } - - if (hierarchy) { - /* Remove child objects. */ - CollectionObject *cob = collection->gobject.first; - while (cob != NULL) { - collection_object_remove(bmain, collection, cob->ob, true); - cob = collection->gobject.first; - } - - /* Delete all child collections recursively. */ - CollectionChild *child = collection->children.first; - while (child != NULL) { - BKE_collection_delete(bmain, child->collection, hierarchy); - child = collection->children.first; - } - } - else { - /* Link child collections into parent collection. */ - for (CollectionChild *child = collection->children.first; child; child = child->next) { - for (CollectionParent *cparent = collection->parents.first; cparent; cparent = cparent->next) { - Collection *parent = cparent->collection; - collection_child_add(parent, child->collection, 0, true); - } - } - - CollectionObject *cob = collection->gobject.first; - while (cob != NULL) { - /* Link child object into parent collections. */ - for (CollectionParent *cparent = collection->parents.first; cparent; cparent = cparent->next) { - Collection *parent = cparent->collection; - collection_object_add(bmain, parent, cob->ob, 0, true); - } - - /* Remove child object. */ - collection_object_remove(bmain, collection, cob->ob, true); - cob = collection->gobject.first; - } - } - - BKE_id_delete(bmain, collection); - - BKE_main_collection_sync(bmain); - - return true; + /* Master collection is not real datablock, can't be removed. */ + if (collection->flag & COLLECTION_IS_MASTER) { + BLI_assert(!"Scene master collection can't be deleted"); + return false; + } + + if (hierarchy) { + /* Remove child objects. */ + CollectionObject *cob = collection->gobject.first; + while (cob != NULL) { + collection_object_remove(bmain, collection, cob->ob, true); + cob = collection->gobject.first; + } + + /* Delete all child collections recursively. */ + CollectionChild *child = collection->children.first; + while (child != NULL) { + BKE_collection_delete(bmain, child->collection, hierarchy); + child = collection->children.first; + } + } + else { + /* Link child collections into parent collection. */ + for (CollectionChild *child = collection->children.first; child; child = child->next) { + for (CollectionParent *cparent = collection->parents.first; cparent; + cparent = cparent->next) { + Collection *parent = cparent->collection; + collection_child_add(parent, child->collection, 0, true); + } + } + + CollectionObject *cob = collection->gobject.first; + while (cob != NULL) { + /* Link child object into parent collections. */ + for (CollectionParent *cparent = collection->parents.first; cparent; + cparent = cparent->next) { + Collection *parent = cparent->collection; + collection_object_add(bmain, parent, cob->ob, 0, true); + } + + /* Remove child object. */ + collection_object_remove(bmain, collection, cob->ob, true); + cob = collection->gobject.first; + } + } + + BKE_id_delete(bmain, collection); + + BKE_main_collection_sync(bmain); + + return true; } /***************************** Collection Copy *******************************/ @@ -184,100 +195,107 @@ bool BKE_collection_delete(Main *bmain, Collection *collection, bool hierarchy) * * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more). */ -void BKE_collection_copy_data( - Main *bmain, Collection *collection_dst, const Collection *collection_src, const int flag) -{ - /* Do not copy collection's preview (same behavior as for objects). */ - if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0 && false) { /* XXX TODO temp hack */ - BKE_previewimg_id_copy(&collection_dst->id, &collection_src->id); - } - else { - collection_dst->preview = NULL; - } - - collection_dst->flag &= ~COLLECTION_HAS_OBJECT_CACHE; - BLI_listbase_clear(&collection_dst->object_cache); - - BLI_listbase_clear(&collection_dst->gobject); - BLI_listbase_clear(&collection_dst->children); - BLI_listbase_clear(&collection_dst->parents); - - for (CollectionChild *child = collection_src->children.first; child; child = child->next) { - collection_child_add(collection_dst, child->collection, flag, false); - } - for (CollectionObject *cob = collection_src->gobject.first; cob; cob = cob->next) { - collection_object_add(bmain, collection_dst, cob->ob, flag, false); - } -} - -static Collection *collection_duplicate_recursive( - Main *bmain, Collection *parent, Collection *collection_old, - const bool do_hierarchy, const bool do_objects, const bool do_obdata) -{ - Collection *collection_new; - bool do_full_process = false; - const int object_dupflag = (do_obdata) ? U.dupflag : 0; - - if (!do_hierarchy || collection_old->id.newid == NULL) { - BKE_id_copy(bmain, &collection_old->id, (ID **)&collection_new); - id_us_min(&collection_new->id); /* Copying add one user by default, need to get rid of that one. */ - - if (do_hierarchy) { - ID_NEW_SET(collection_old, collection_new); - } - do_full_process = true; - } - else { - collection_new = (Collection *)collection_old->id.newid; - } - - /* Optionally add to parent (we always want to do that, even if collection_old had already been duplicated). */ - if (parent != NULL) { - if (collection_child_add(parent, collection_new, 0, true)) { - /* Put collection right after existing one. */ - CollectionChild *child = collection_find_child(parent, collection_old); - CollectionChild *child_new = collection_find_child(parent, collection_new); - - if (child && child_new) { - BLI_remlink(&parent->children, child_new); - BLI_insertlinkafter(&parent->children, child, child_new); - } - } - } - - /* If we are not doing any kind of deep-copy, we can return immediately. - * False do_full_process means collection_old had already been duplicated, no need to redo some deep-copy on it. */ - if (!do_hierarchy || !do_full_process) { - return collection_new; - } - - if (do_objects) { - /* We can loop on collection_old's objects, that list is currently identical the collection_new' objects, - * and won't be changed here. */ - for (CollectionObject *cob = collection_old->gobject.first; cob; cob = cob->next) { - Object *ob_old = cob->ob; - Object *ob_new = (Object *)ob_old->id.newid; - - if (ob_new == NULL) { - ob_new = BKE_object_duplicate(bmain, ob_old, object_dupflag); - ID_NEW_SET(ob_old, ob_new); - } - - collection_object_add(bmain, collection_new, ob_new, 0, true); - collection_object_remove(bmain, collection_new, ob_old, false); - } - } - - /* We can loop on collection_old's children, that list is currently identical the collection_new' children, - * and won't be changed here. */ - for (CollectionChild *child = collection_old->children.first; child; child = child->next) { - Collection *child_collection_old = child->collection; - - collection_duplicate_recursive(bmain, collection_new, child_collection_old, do_hierarchy, do_objects, do_obdata); - collection_child_remove(collection_new, child_collection_old); - } - - return collection_new; +void BKE_collection_copy_data(Main *bmain, + Collection *collection_dst, + const Collection *collection_src, + const int flag) +{ + /* Do not copy collection's preview (same behavior as for objects). */ + if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0 && false) { /* XXX TODO temp hack */ + BKE_previewimg_id_copy(&collection_dst->id, &collection_src->id); + } + else { + collection_dst->preview = NULL; + } + + collection_dst->flag &= ~COLLECTION_HAS_OBJECT_CACHE; + BLI_listbase_clear(&collection_dst->object_cache); + + BLI_listbase_clear(&collection_dst->gobject); + BLI_listbase_clear(&collection_dst->children); + BLI_listbase_clear(&collection_dst->parents); + + for (CollectionChild *child = collection_src->children.first; child; child = child->next) { + collection_child_add(collection_dst, child->collection, flag, false); + } + for (CollectionObject *cob = collection_src->gobject.first; cob; cob = cob->next) { + collection_object_add(bmain, collection_dst, cob->ob, flag, false); + } +} + +static Collection *collection_duplicate_recursive(Main *bmain, + Collection *parent, + Collection *collection_old, + const bool do_hierarchy, + const bool do_objects, + const bool do_obdata) +{ + Collection *collection_new; + bool do_full_process = false; + const int object_dupflag = (do_obdata) ? U.dupflag : 0; + + if (!do_hierarchy || collection_old->id.newid == NULL) { + BKE_id_copy(bmain, &collection_old->id, (ID **)&collection_new); + id_us_min( + &collection_new->id); /* Copying add one user by default, need to get rid of that one. */ + + if (do_hierarchy) { + ID_NEW_SET(collection_old, collection_new); + } + do_full_process = true; + } + else { + collection_new = (Collection *)collection_old->id.newid; + } + + /* Optionally add to parent (we always want to do that, even if collection_old had already been duplicated). */ + if (parent != NULL) { + if (collection_child_add(parent, collection_new, 0, true)) { + /* Put collection right after existing one. */ + CollectionChild *child = collection_find_child(parent, collection_old); + CollectionChild *child_new = collection_find_child(parent, collection_new); + + if (child && child_new) { + BLI_remlink(&parent->children, child_new); + BLI_insertlinkafter(&parent->children, child, child_new); + } + } + } + + /* If we are not doing any kind of deep-copy, we can return immediately. + * False do_full_process means collection_old had already been duplicated, no need to redo some deep-copy on it. */ + if (!do_hierarchy || !do_full_process) { + return collection_new; + } + + if (do_objects) { + /* We can loop on collection_old's objects, that list is currently identical the collection_new' objects, + * and won't be changed here. */ + for (CollectionObject *cob = collection_old->gobject.first; cob; cob = cob->next) { + Object *ob_old = cob->ob; + Object *ob_new = (Object *)ob_old->id.newid; + + if (ob_new == NULL) { + ob_new = BKE_object_duplicate(bmain, ob_old, object_dupflag); + ID_NEW_SET(ob_old, ob_new); + } + + collection_object_add(bmain, collection_new, ob_new, 0, true); + collection_object_remove(bmain, collection_new, ob_old, false); + } + } + + /* We can loop on collection_old's children, that list is currently identical the collection_new' children, + * and won't be changed here. */ + for (CollectionChild *child = collection_old->children.first; child; child = child->next) { + Collection *child_collection_old = child->collection; + + collection_duplicate_recursive( + bmain, collection_new, child_collection_old, do_hierarchy, do_objects, do_obdata); + collection_child_remove(collection_new, child_collection_old); + } + + return collection_new; } /** @@ -288,7 +306,7 @@ static Collection *collection_duplicate_recursive( */ Collection *BKE_collection_copy(Main *bmain, Collection *parent, Collection *collection) { - return BKE_collection_duplicate(bmain, parent, collection, false, false, false); + return BKE_collection_duplicate(bmain, parent, collection, false, false, false); } /** @@ -304,50 +322,53 @@ Collection *BKE_collection_copy(Main *bmain, Collection *parent, Collection *col * \param do_obdata If true, it will also make deep duplicates of objects, using behavior defined in user settings * (U.dupflag). This one does nothing if \a do_hierarchy and \a do_objects are not set. */ -Collection *BKE_collection_duplicate( - Main *bmain, Collection *parent, Collection *collection, - const bool do_hierarchy, const bool do_objects, const bool do_obdata) +Collection *BKE_collection_duplicate(Main *bmain, + Collection *parent, + Collection *collection, + const bool do_hierarchy, + const bool do_objects, + const bool do_obdata) { - /* It's not allowed to copy the master collection. */ - if (collection->flag & COLLECTION_IS_MASTER) { - BLI_assert("!Master collection can't be duplicated"); - return NULL; - } + /* It's not allowed to copy the master collection. */ + if (collection->flag & COLLECTION_IS_MASTER) { + BLI_assert("!Master collection can't be duplicated"); + return NULL; + } - if (do_hierarchy) { - BKE_main_id_tag_all(bmain, LIB_TAG_NEW, false); - BKE_main_id_clear_newpoins(bmain); - } + if (do_hierarchy) { + BKE_main_id_tag_all(bmain, LIB_TAG_NEW, false); + BKE_main_id_clear_newpoins(bmain); + } - Collection *collection_new = collection_duplicate_recursive( - bmain, parent, collection, do_hierarchy, do_objects, do_obdata); + Collection *collection_new = collection_duplicate_recursive( + bmain, parent, collection, do_hierarchy, do_objects, do_obdata); - /* This code will follows into all ID links using an ID tagged with LIB_TAG_NEW.*/ - BKE_libblock_relink_to_newid(&collection_new->id); + /* This code will follows into all ID links using an ID tagged with LIB_TAG_NEW.*/ + BKE_libblock_relink_to_newid(&collection_new->id); - if (do_hierarchy) { - /* Cleanup. */ - BKE_main_id_tag_all(bmain, LIB_TAG_NEW, false); - BKE_main_id_clear_newpoins(bmain); - } + if (do_hierarchy) { + /* Cleanup. */ + BKE_main_id_tag_all(bmain, LIB_TAG_NEW, false); + BKE_main_id_clear_newpoins(bmain); + } - BKE_main_collection_sync(bmain); + BKE_main_collection_sync(bmain); - return collection_new; + return collection_new; } Collection *BKE_collection_copy_master(Main *bmain, Collection *collection, const int flag) { - BLI_assert(collection->flag & COLLECTION_IS_MASTER); + BLI_assert(collection->flag & COLLECTION_IS_MASTER); - Collection *collection_dst = MEM_dupallocN(collection); - BKE_collection_copy_data(bmain, collection_dst, collection, flag); - return collection_dst; + Collection *collection_dst = MEM_dupallocN(collection); + BKE_collection_copy_data(bmain, collection_dst, collection, flag); + return collection_dst; } void BKE_collection_make_local(Main *bmain, Collection *collection, const bool lib_local) { - BKE_id_make_local_generic(bmain, &collection->id, true, lib_local); + BKE_id_make_local_generic(bmain, &collection->id, true, lib_local); } /********************************* Naming *******************************/ @@ -357,24 +378,24 @@ void BKE_collection_make_local(Main *bmain, Collection *collection, const bool l */ void BKE_collection_new_name_get(Collection *collection_parent, char *rname) { - char *name; + char *name; - if (!collection_parent) { - name = BLI_strdup("Collection"); - } - else if (collection_parent->flag & COLLECTION_IS_MASTER) { - name = BLI_sprintfN("Collection %d", BLI_listbase_count(&collection_parent->children) + 1); - } - else { - const int number = BLI_listbase_count(&collection_parent->children) + 1; - const int digits = integer_digits_i(number); - const int max_len = - sizeof(collection_parent->id.name) - 1 /* NULL terminator */ - (1 + digits) /* " %d" */ - 2 /* ID */; - name = BLI_sprintfN("%.*s %d", max_len, collection_parent->id.name + 2, number); - } + if (!collection_parent) { + name = BLI_strdup("Collection"); + } + else if (collection_parent->flag & COLLECTION_IS_MASTER) { + name = BLI_sprintfN("Collection %d", BLI_listbase_count(&collection_parent->children) + 1); + } + else { + const int number = BLI_listbase_count(&collection_parent->children) + 1; + const int digits = integer_digits_i(number); + const int max_len = sizeof(collection_parent->id.name) - 1 /* NULL terminator */ - + (1 + digits) /* " %d" */ - 2 /* ID */; + name = BLI_sprintfN("%.*s %d", max_len, collection_parent->id.name + 2, number); + } - BLI_strncpy(rname, name, MAX_NAME); - MEM_freeN(name); + BLI_strncpy(rname, name, MAX_NAME); + MEM_freeN(name); } /** @@ -382,273 +403,278 @@ void BKE_collection_new_name_get(Collection *collection_parent, char *rname) */ const char *BKE_collection_ui_name_get(struct Collection *collection) { - if (collection->flag & COLLECTION_IS_MASTER) { - return IFACE_("Scene Collection"); - } - else { - return collection->id.name + 2; - } + if (collection->flag & COLLECTION_IS_MASTER) { + return IFACE_("Scene Collection"); + } + else { + return collection->id.name + 2; + } } /* **************** Object List Cache *******************/ static void collection_object_cache_fill(ListBase *lb, Collection *collection, int parent_restrict) { - int child_restrict = collection->flag | parent_restrict; + int child_restrict = collection->flag | parent_restrict; - for (CollectionObject *cob = collection->gobject.first; cob; cob = cob->next) { - Base *base = BLI_findptr(lb, cob->ob, offsetof(Base, object)); + for (CollectionObject *cob = collection->gobject.first; cob; cob = cob->next) { + Base *base = BLI_findptr(lb, cob->ob, offsetof(Base, object)); - if (base == NULL) { - base = MEM_callocN(sizeof(Base), "Object Base"); - base->object = cob->ob; - BLI_addtail(lb, base); - } + if (base == NULL) { + base = MEM_callocN(sizeof(Base), "Object Base"); + base->object = cob->ob; + BLI_addtail(lb, base); + } - int object_restrict = base->object->restrictflag; + int object_restrict = base->object->restrictflag; - if (((child_restrict & COLLECTION_RESTRICT_VIEW) == 0) && - ((object_restrict & OB_RESTRICT_VIEW) == 0)) - { - base->flag |= BASE_ENABLED_VIEWPORT; - } + if (((child_restrict & COLLECTION_RESTRICT_VIEW) == 0) && + ((object_restrict & OB_RESTRICT_VIEW) == 0)) { + base->flag |= BASE_ENABLED_VIEWPORT; + } - if (((child_restrict & COLLECTION_RESTRICT_RENDER) == 0) && - ((object_restrict & OB_RESTRICT_RENDER) == 0)) - { - base->flag |= BASE_ENABLED_RENDER; - } - } + if (((child_restrict & COLLECTION_RESTRICT_RENDER) == 0) && + ((object_restrict & OB_RESTRICT_RENDER) == 0)) { + base->flag |= BASE_ENABLED_RENDER; + } + } - for (CollectionChild *child = collection->children.first; child; child = child->next) { - collection_object_cache_fill(lb, child->collection, child_restrict); - } + for (CollectionChild *child = collection->children.first; child; child = child->next) { + collection_object_cache_fill(lb, child->collection, child_restrict); + } } ListBase BKE_collection_object_cache_get(Collection *collection) { - if (!(collection->flag & COLLECTION_HAS_OBJECT_CACHE)) { - static ThreadMutex cache_lock = BLI_MUTEX_INITIALIZER; + if (!(collection->flag & COLLECTION_HAS_OBJECT_CACHE)) { + static ThreadMutex cache_lock = BLI_MUTEX_INITIALIZER; - BLI_mutex_lock(&cache_lock); - if (!(collection->flag & COLLECTION_HAS_OBJECT_CACHE)) { - collection_object_cache_fill(&collection->object_cache, collection, 0); - collection->flag |= COLLECTION_HAS_OBJECT_CACHE; - } - BLI_mutex_unlock(&cache_lock); - } + BLI_mutex_lock(&cache_lock); + if (!(collection->flag & COLLECTION_HAS_OBJECT_CACHE)) { + collection_object_cache_fill(&collection->object_cache, collection, 0); + collection->flag |= COLLECTION_HAS_OBJECT_CACHE; + } + BLI_mutex_unlock(&cache_lock); + } - return collection->object_cache; + return collection->object_cache; } static void collection_object_cache_free(Collection *collection) { - /* Clear own cache an for all parents, since those are affected by changes as well. */ - collection->flag &= ~COLLECTION_HAS_OBJECT_CACHE; - BLI_freelistN(&collection->object_cache); + /* Clear own cache an for all parents, since those are affected by changes as well. */ + collection->flag &= ~COLLECTION_HAS_OBJECT_CACHE; + BLI_freelistN(&collection->object_cache); - for (CollectionParent *parent = collection->parents.first; parent; parent = parent->next) { - collection_object_cache_free(parent->collection); - } + for (CollectionParent *parent = collection->parents.first; parent; parent = parent->next) { + collection_object_cache_free(parent->collection); + } } void BKE_collection_object_cache_free(Collection *collection) { - collection_object_cache_free(collection); + collection_object_cache_free(collection); } Base *BKE_collection_or_layer_objects(const ViewLayer *view_layer, Collection *collection) { - if (collection) { - return BKE_collection_object_cache_get(collection).first; - } - else { - return FIRSTBASE(view_layer); - } + if (collection) { + return BKE_collection_object_cache_get(collection).first; + } + else { + return FIRSTBASE(view_layer); + } } /*********************** Scene Master Collection ***************/ Collection *BKE_collection_master_add() { - /* Not an actual datablock, but owned by scene. */ - Collection *master_collection = MEM_callocN(sizeof(Collection), "Master Collection"); - STRNCPY(master_collection->id.name, "GRMaster Collection"); - master_collection->flag |= COLLECTION_IS_MASTER; - return master_collection; + /* Not an actual datablock, but owned by scene. */ + Collection *master_collection = MEM_callocN(sizeof(Collection), "Master Collection"); + STRNCPY(master_collection->id.name, "GRMaster Collection"); + master_collection->flag |= COLLECTION_IS_MASTER; + return master_collection; } Collection *BKE_collection_master(const Scene *scene) { - return scene->master_collection; + return scene->master_collection; } Scene *BKE_collection_master_scene_search(const Main *bmain, const Collection *master_collection) { - BLI_assert((master_collection->flag & COLLECTION_IS_MASTER) != 0); + BLI_assert((master_collection->flag & COLLECTION_IS_MASTER) != 0); - for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) { - if (scene->master_collection == master_collection) { - return scene; - } - } + for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) { + if (scene->master_collection == master_collection) { + return scene; + } + } - return NULL; + return NULL; } /*********************** Cyclic Checks ************************/ static bool collection_object_cyclic_check_internal(Object *object, Collection *collection) { - if (object->instance_collection) { - Collection *dup_collection = object->instance_collection; - if ((dup_collection->id.tag & LIB_TAG_DOIT) == 0) { - /* Cycle already exists in collections, let's prevent further crappyness */ - return true; - } - /* flag the object to identify cyclic dependencies in further dupli collections */ - dup_collection->id.tag &= ~LIB_TAG_DOIT; - - if (dup_collection == collection) { - return true; - } - else { - FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN(dup_collection, collection_object) - { - if (collection_object_cyclic_check_internal(collection_object, dup_collection)) { - return true; - } - } - FOREACH_COLLECTION_OBJECT_RECURSIVE_END; - } - - /* un-flag the object, it's allowed to have the same collection multiple times in parallel */ - dup_collection->id.tag |= LIB_TAG_DOIT; - } - - return false; + if (object->instance_collection) { + Collection *dup_collection = object->instance_collection; + if ((dup_collection->id.tag & LIB_TAG_DOIT) == 0) { + /* Cycle already exists in collections, let's prevent further crappyness */ + return true; + } + /* flag the object to identify cyclic dependencies in further dupli collections */ + dup_collection->id.tag &= ~LIB_TAG_DOIT; + + if (dup_collection == collection) { + return true; + } + else { + FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (dup_collection, collection_object) { + if (collection_object_cyclic_check_internal(collection_object, dup_collection)) { + return true; + } + } + FOREACH_COLLECTION_OBJECT_RECURSIVE_END; + } + + /* un-flag the object, it's allowed to have the same collection multiple times in parallel */ + dup_collection->id.tag |= LIB_TAG_DOIT; + } + + return false; } bool BKE_collection_object_cyclic_check(Main *bmain, Object *object, Collection *collection) { - /* first flag all collections */ - BKE_main_id_tag_listbase(&bmain->collections, LIB_TAG_DOIT, true); + /* first flag all collections */ + BKE_main_id_tag_listbase(&bmain->collections, LIB_TAG_DOIT, true); - return collection_object_cyclic_check_internal(object, collection); + return collection_object_cyclic_check_internal(object, collection); } /******************* Collection Object Membership *******************/ bool BKE_collection_has_object(Collection *collection, Object *ob) { - if (ELEM(NULL, collection, ob)) { - return false; - } + if (ELEM(NULL, collection, ob)) { + return false; + } - return (BLI_findptr(&collection->gobject, ob, offsetof(CollectionObject, ob))); + return (BLI_findptr(&collection->gobject, ob, offsetof(CollectionObject, ob))); } bool BKE_collection_has_object_recursive(Collection *collection, Object *ob) { - if (ELEM(NULL, collection, ob)) { - return false; - } + if (ELEM(NULL, collection, ob)) { + return false; + } - const ListBase objects = BKE_collection_object_cache_get(collection); - return (BLI_findptr(&objects, ob, offsetof(Base, object))); + const ListBase objects = BKE_collection_object_cache_get(collection); + return (BLI_findptr(&objects, ob, offsetof(Base, object))); } static Collection *collection_next_find(Main *bmain, Scene *scene, Collection *collection) { - if (scene && collection == BKE_collection_master(scene)) { - return bmain->collections.first; - } - else { - return collection->id.next; - } -} - -Collection *BKE_collection_object_find(Main *bmain, Scene *scene, Collection *collection, Object *ob) -{ - if (collection) { - collection = collection_next_find(bmain, scene, collection); - } - else if (scene) { - collection = BKE_collection_master(scene); - } - else { - collection = bmain->collections.first; - } - - while (collection) { - if (BKE_collection_has_object(collection, ob)) - return collection; - collection = collection_next_find(bmain, scene, collection); - } - return NULL; + if (scene && collection == BKE_collection_master(scene)) { + return bmain->collections.first; + } + else { + return collection->id.next; + } +} + +Collection *BKE_collection_object_find(Main *bmain, + Scene *scene, + Collection *collection, + Object *ob) +{ + if (collection) { + collection = collection_next_find(bmain, scene, collection); + } + else if (scene) { + collection = BKE_collection_master(scene); + } + else { + collection = bmain->collections.first; + } + + while (collection) { + if (BKE_collection_has_object(collection, ob)) + return collection; + collection = collection_next_find(bmain, scene, collection); + } + return NULL; } bool BKE_collection_is_empty(Collection *collection) { - return BLI_listbase_is_empty(&collection->gobject) && BLI_listbase_is_empty(&collection->children); + return BLI_listbase_is_empty(&collection->gobject) && + BLI_listbase_is_empty(&collection->children); } /********************** Collection Objects *********************/ -static bool collection_object_add(Main *bmain, Collection *collection, Object *ob, int flag, const bool add_us) +static bool collection_object_add( + Main *bmain, Collection *collection, Object *ob, int flag, const bool add_us) { - if (ob->instance_collection) { - /* Cyclic dependency check. */ - if (collection_find_child_recursive(ob->instance_collection, collection)) { - return false; - } - } + if (ob->instance_collection) { + /* Cyclic dependency check. */ + if (collection_find_child_recursive(ob->instance_collection, collection)) { + return false; + } + } - CollectionObject *cob = BLI_findptr(&collection->gobject, ob, offsetof(CollectionObject, ob)); - if (cob) { - return false; - } + CollectionObject *cob = BLI_findptr(&collection->gobject, ob, offsetof(CollectionObject, ob)); + if (cob) { + return false; + } - cob = MEM_callocN(sizeof(CollectionObject), __func__); - cob->ob = ob; - BLI_addtail(&collection->gobject, cob); - BKE_collection_object_cache_free(collection); + cob = MEM_callocN(sizeof(CollectionObject), __func__); + cob->ob = ob; + BLI_addtail(&collection->gobject, cob); + BKE_collection_object_cache_free(collection); - if (add_us && (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) { - id_us_plus(&ob->id); - } + if (add_us && (flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) { + id_us_plus(&ob->id); + } - if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { - DEG_id_tag_update_ex(bmain, &collection->id, ID_RECALC_COPY_ON_WRITE); - } + if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { + DEG_id_tag_update_ex(bmain, &collection->id, ID_RECALC_COPY_ON_WRITE); + } - if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { - BKE_rigidbody_main_collection_object_add(bmain, collection, ob); - } + if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { + BKE_rigidbody_main_collection_object_add(bmain, collection, ob); + } - return true; + return true; } -static bool collection_object_remove(Main *bmain, Collection *collection, Object *ob, const bool free_us) +static bool collection_object_remove(Main *bmain, + Collection *collection, + Object *ob, + const bool free_us) { - CollectionObject *cob = BLI_findptr(&collection->gobject, ob, offsetof(CollectionObject, ob)); - if (cob == NULL) { - return false; - } + CollectionObject *cob = BLI_findptr(&collection->gobject, ob, offsetof(CollectionObject, ob)); + if (cob == NULL) { + return false; + } - BLI_freelinkN(&collection->gobject, cob); - BKE_collection_object_cache_free(collection); + BLI_freelinkN(&collection->gobject, cob); + BKE_collection_object_cache_free(collection); - if (free_us) { - BKE_id_free_us(bmain, ob); - } - else { - id_us_min(&ob->id); - } + if (free_us) { + BKE_id_free_us(bmain, ob); + } + else { + id_us_min(&ob->id); + } - DEG_id_tag_update_ex(bmain, &collection->id, ID_RECALC_COPY_ON_WRITE); + DEG_id_tag_update_ex(bmain, &collection->id, ID_RECALC_COPY_ON_WRITE); - return true; + return true; } /** @@ -656,19 +682,19 @@ static bool collection_object_remove(Main *bmain, Collection *collection, Object */ bool BKE_collection_object_add(Main *bmain, Collection *collection, Object *ob) { - if (ELEM(NULL, collection, ob)) { - return false; - } + if (ELEM(NULL, collection, ob)) { + return false; + } - if (!collection_object_add(bmain, collection, ob, 0, true)) { - return false; - } + if (!collection_object_add(bmain, collection, ob, 0, true)) { + return false; + } - if (BKE_collection_is_in_scene(collection)) { - BKE_main_collection_sync(bmain); - } + if (BKE_collection_is_in_scene(collection)) { + BKE_main_collection_sync(bmain); + } - return true; + return true; } /** @@ -677,61 +703,62 @@ bool BKE_collection_object_add(Main *bmain, Collection *collection, Object *ob) */ void BKE_collection_object_add_from(Main *bmain, Scene *scene, Object *ob_src, Object *ob_dst) { - FOREACH_SCENE_COLLECTION_BEGIN(scene, collection) - { - if (BKE_collection_has_object(collection, ob_src)) { - collection_object_add(bmain, collection, ob_dst, 0, true); - } - } - FOREACH_SCENE_COLLECTION_END; + FOREACH_SCENE_COLLECTION_BEGIN (scene, collection) { + if (BKE_collection_has_object(collection, ob_src)) { + collection_object_add(bmain, collection, ob_dst, 0, true); + } + } + FOREACH_SCENE_COLLECTION_END; - BKE_main_collection_sync(bmain); + BKE_main_collection_sync(bmain); } /** * Remove object from collection. */ -bool BKE_collection_object_remove(Main *bmain, Collection *collection, Object *ob, const bool free_us) +bool BKE_collection_object_remove(Main *bmain, + Collection *collection, + Object *ob, + const bool free_us) { - if (ELEM(NULL, collection, ob)) { - return false; - } + if (ELEM(NULL, collection, ob)) { + return false; + } - if (!collection_object_remove(bmain, collection, ob, free_us)) { - return false; - } + if (!collection_object_remove(bmain, collection, ob, free_us)) { + return false; + } - if (BKE_collection_is_in_scene(collection)) { - BKE_main_collection_sync(bmain); - } + if (BKE_collection_is_in_scene(collection)) { + BKE_main_collection_sync(bmain); + } - return true; + return true; } /** * Remove object from all collections of scene * \param scene_collection_skip: Don't remove base from this collection. */ -static bool scene_collections_object_remove(Main *bmain, Scene *scene, Object *ob, const bool free_us, - Collection *collection_skip) +static bool scene_collections_object_remove( + Main *bmain, Scene *scene, Object *ob, const bool free_us, Collection *collection_skip) { - bool removed = false; + bool removed = false; - if (collection_skip == NULL) { - BKE_scene_remove_rigidbody_object(bmain, scene, ob); - } + if (collection_skip == NULL) { + BKE_scene_remove_rigidbody_object(bmain, scene, ob); + } - FOREACH_SCENE_COLLECTION_BEGIN(scene, collection) - { - if (collection != collection_skip) { - removed |= collection_object_remove(bmain, collection, ob, free_us); - } - } - FOREACH_SCENE_COLLECTION_END; + FOREACH_SCENE_COLLECTION_BEGIN (scene, collection) { + if (collection != collection_skip) { + removed |= collection_object_remove(bmain, collection, ob, free_us); + } + } + FOREACH_SCENE_COLLECTION_END; - BKE_main_collection_sync(bmain); + BKE_main_collection_sync(bmain); - return removed; + return removed; } /** @@ -739,7 +766,7 @@ static bool scene_collections_object_remove(Main *bmain, Scene *scene, Object *o */ bool BKE_scene_collections_object_remove(Main *bmain, Scene *scene, Object *ob, const bool free_us) { - return scene_collections_object_remove(bmain, scene, ob, free_us, NULL); + return scene_collections_object_remove(bmain, scene, ob, free_us, NULL); } /* @@ -749,54 +776,55 @@ bool BKE_scene_collections_object_remove(Main *bmain, Scene *scene, Object *ob, */ static void collection_object_remove_nulls(Collection *collection) { - bool changed = false; + bool changed = false; - for (CollectionObject *cob = collection->gobject.first, *cob_next = NULL; cob; cob = cob_next) { - cob_next = cob->next; + for (CollectionObject *cob = collection->gobject.first, *cob_next = NULL; cob; cob = cob_next) { + cob_next = cob->next; - if (cob->ob == NULL) { - BLI_freelinkN(&collection->gobject, cob); - changed = true; - } - } + if (cob->ob == NULL) { + BLI_freelinkN(&collection->gobject, cob); + changed = true; + } + } - if (changed) { - BKE_collection_object_cache_free(collection); - } + if (changed) { + BKE_collection_object_cache_free(collection); + } } void BKE_collections_object_remove_nulls(Main *bmain) { - for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) { - collection_object_remove_nulls(scene->master_collection); - } + for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) { + collection_object_remove_nulls(scene->master_collection); + } - for (Collection *collection = bmain->collections.first; collection; collection = collection->id.next) { - collection_object_remove_nulls(collection); - } + for (Collection *collection = bmain->collections.first; collection; + collection = collection->id.next) { + collection_object_remove_nulls(collection); + } } static void collection_null_children_remove(Collection *collection) { - for (CollectionChild *child = collection->children.first, *child_next = NULL; child; child = child_next) { - child_next = child->next; + for (CollectionChild *child = collection->children.first, *child_next = NULL; child; + child = child_next) { + child_next = child->next; - if (child->collection == NULL) { - BLI_freelinkN(&collection->children, child); - } - } + if (child->collection == NULL) { + BLI_freelinkN(&collection->children, child); + } + } } static void collection_missing_parents_remove(Collection *collection) { - for (CollectionParent *parent = collection->parents.first, *parent_next; parent != NULL; parent = parent_next) { - parent_next = parent->next; - if ((parent->collection == NULL) || - !collection_find_child(parent->collection, collection)) - { - BLI_freelinkN(&collection->parents, parent); - } - } + for (CollectionParent *parent = collection->parents.first, *parent_next; parent != NULL; + parent = parent_next) { + parent_next = parent->next; + if ((parent->collection == NULL) || !collection_find_child(parent->collection, collection)) { + BLI_freelinkN(&collection->parents, parent); + } + } } /** @@ -810,36 +838,39 @@ static void collection_missing_parents_remove(Collection *collection) */ void BKE_collections_child_remove_nulls(Main *bmain, Collection *collection) { - if (collection == NULL) { - /* We need to do the checks in two steps when more than one collection may be involved, - * otherwise we can miss some cases... - * Also, master collections are not in bmain, so we also need to loop over scenes. - */ - for (collection = bmain->collections.first; collection != NULL; collection = collection->id.next) { - collection_null_children_remove(collection); - } - for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) { - collection_null_children_remove(BKE_collection_master(scene)); - } - - for (collection = bmain->collections.first; collection != NULL; collection = collection->id.next) { - collection_missing_parents_remove(collection); - } - for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) { - collection_missing_parents_remove(BKE_collection_master(scene)); - } - } - else { - for (CollectionParent *parent = collection->parents.first, *parent_next; parent; parent = parent_next) { - parent_next = parent->next; - - collection_null_children_remove(parent->collection); - - if (!collection_find_child(parent->collection, collection)) { - BLI_freelinkN(&collection->parents, parent); - } - } - } + if (collection == NULL) { + /* We need to do the checks in two steps when more than one collection may be involved, + * otherwise we can miss some cases... + * Also, master collections are not in bmain, so we also need to loop over scenes. + */ + for (collection = bmain->collections.first; collection != NULL; + collection = collection->id.next) { + collection_null_children_remove(collection); + } + for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) { + collection_null_children_remove(BKE_collection_master(scene)); + } + + for (collection = bmain->collections.first; collection != NULL; + collection = collection->id.next) { + collection_missing_parents_remove(collection); + } + for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) { + collection_missing_parents_remove(BKE_collection_master(scene)); + } + } + else { + for (CollectionParent *parent = collection->parents.first, *parent_next; parent; + parent = parent_next) { + parent_next = parent->next; + + collection_null_children_remove(parent->collection); + + if (!collection_find_child(parent->collection, collection)) { + BLI_freelinkN(&collection->parents, parent); + } + } + } } /** @@ -848,175 +879,180 @@ void BKE_collections_child_remove_nulls(Main *bmain, Collection *collection) * If source collection is NULL move it from all the existing collections. */ void BKE_collection_object_move( - Main *bmain, Scene *scene, Collection *collection_dst, Collection *collection_src, Object *ob) -{ - /* In both cases we first add the object, then remove it from the other collections. - * Otherwise we lose the original base and whether it was active and selected. */ - if (collection_src != NULL) { - if (BKE_collection_object_add(bmain, collection_dst, ob)) { - BKE_collection_object_remove(bmain, collection_src, ob, false); - } - } - else { - /* Adding will fail if object is already in collection. - * However we still need to remove it from the other collections. */ - BKE_collection_object_add(bmain, collection_dst, ob); - scene_collections_object_remove(bmain, scene, ob, false, collection_dst); - } + Main *bmain, Scene *scene, Collection *collection_dst, Collection *collection_src, Object *ob) +{ + /* In both cases we first add the object, then remove it from the other collections. + * Otherwise we lose the original base and whether it was active and selected. */ + if (collection_src != NULL) { + if (BKE_collection_object_add(bmain, collection_dst, ob)) { + BKE_collection_object_remove(bmain, collection_src, ob, false); + } + } + else { + /* Adding will fail if object is already in collection. + * However we still need to remove it from the other collections. */ + BKE_collection_object_add(bmain, collection_dst, ob); + scene_collections_object_remove(bmain, scene, ob, false, collection_dst); + } } /***************** Collection Scene Membership ****************/ bool BKE_collection_is_in_scene(Collection *collection) { - if (collection->flag & COLLECTION_IS_MASTER) { - return true; - } + if (collection->flag & COLLECTION_IS_MASTER) { + return true; + } - for (CollectionParent *cparent = collection->parents.first; cparent; cparent = cparent->next) { - if (BKE_collection_is_in_scene(cparent->collection)) { - return true; - } - } + for (CollectionParent *cparent = collection->parents.first; cparent; cparent = cparent->next) { + if (BKE_collection_is_in_scene(cparent->collection)) { + return true; + } + } - return false; + return false; } void BKE_collections_after_lib_link(Main *bmain) { - /* Need to update layer collections because objects might have changed - * in linked files, and because undo push does not include updated base - * flags since those are refreshed after the operator completes. */ - BKE_main_collection_sync(bmain); + /* Need to update layer collections because objects might have changed + * in linked files, and because undo push does not include updated base + * flags since those are refreshed after the operator completes. */ + BKE_main_collection_sync(bmain); } /********************** Collection Children *******************/ bool BKE_collection_find_cycle(Collection *new_ancestor, Collection *collection) { - if (collection == new_ancestor) { - return true; - } + if (collection == new_ancestor) { + return true; + } - for (CollectionParent *parent = new_ancestor->parents.first; parent; parent = parent->next) { - if (BKE_collection_find_cycle(parent->collection, collection)) { - return true; - } - } + for (CollectionParent *parent = new_ancestor->parents.first; parent; parent = parent->next) { + if (BKE_collection_find_cycle(parent->collection, collection)) { + return true; + } + } - return false; + return false; } static CollectionChild *collection_find_child(Collection *parent, Collection *collection) { - return BLI_findptr(&parent->children, collection, offsetof(CollectionChild, collection)); + return BLI_findptr(&parent->children, collection, offsetof(CollectionChild, collection)); } static bool collection_find_child_recursive(Collection *parent, Collection *collection) { - for (CollectionChild *child = parent->children.first; child; child = child->next) { - if (child->collection == collection) { - return true; - } + for (CollectionChild *child = parent->children.first; child; child = child->next) { + if (child->collection == collection) { + return true; + } - if (collection_find_child_recursive(child->collection, collection)) { - return true; - } - } + if (collection_find_child_recursive(child->collection, collection)) { + return true; + } + } - return false; + return false; } static CollectionParent *collection_find_parent(Collection *child, Collection *collection) { - return BLI_findptr(&child->parents, collection, offsetof(CollectionParent, collection)); + return BLI_findptr(&child->parents, collection, offsetof(CollectionParent, collection)); } -static bool collection_child_add(Collection *parent, Collection *collection, const int flag, const bool add_us) +static bool collection_child_add(Collection *parent, + Collection *collection, + const int flag, + const bool add_us) { - CollectionChild *child = collection_find_child(parent, collection); - if (child) { - return false; - } - if (BKE_collection_find_cycle(parent, collection)) { - return false; - } + CollectionChild *child = collection_find_child(parent, collection); + if (child) { + return false; + } + if (BKE_collection_find_cycle(parent, collection)) { + return false; + } - child = MEM_callocN(sizeof(CollectionChild), "CollectionChild"); - child->collection = collection; - BLI_addtail(&parent->children, child); + child = MEM_callocN(sizeof(CollectionChild), "CollectionChild"); + child->collection = collection; + BLI_addtail(&parent->children, child); - /* Don't add parent links for depsgraph datablocks, these are not kept in sync. */ - if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { - CollectionParent *cparent = MEM_callocN(sizeof(CollectionParent), "CollectionParent"); - cparent->collection = parent; - BLI_addtail(&collection->parents, cparent); - } + /* Don't add parent links for depsgraph datablocks, these are not kept in sync. */ + if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) { + CollectionParent *cparent = MEM_callocN(sizeof(CollectionParent), "CollectionParent"); + cparent->collection = parent; + BLI_addtail(&collection->parents, cparent); + } - if (add_us) { - id_us_plus(&collection->id); - } + if (add_us) { + id_us_plus(&collection->id); + } - BKE_collection_object_cache_free(parent); + BKE_collection_object_cache_free(parent); - return true; + return true; } static bool collection_child_remove(Collection *parent, Collection *collection) { - CollectionChild *child = collection_find_child(parent, collection); - if (child == NULL) { - return false; - } + CollectionChild *child = collection_find_child(parent, collection); + if (child == NULL) { + return false; + } - CollectionParent *cparent = collection_find_parent(collection, parent); - BLI_freelinkN(&collection->parents, cparent); - BLI_freelinkN(&parent->children, child); + CollectionParent *cparent = collection_find_parent(collection, parent); + BLI_freelinkN(&collection->parents, cparent); + BLI_freelinkN(&parent->children, child); - id_us_min(&collection->id); + id_us_min(&collection->id); - BKE_collection_object_cache_free(parent); + BKE_collection_object_cache_free(parent); - return true; + return true; } bool BKE_collection_child_add(Main *bmain, Collection *parent, Collection *child) { - if (!collection_child_add(parent, child, 0, true)) { - return false; - } + if (!collection_child_add(parent, child, 0, true)) { + return false; + } - BKE_main_collection_sync(bmain); - return true; + BKE_main_collection_sync(bmain); + return true; } bool BKE_collection_child_remove(Main *bmain, Collection *parent, Collection *child) { - if (!collection_child_remove(parent, child)) { - return false; - } + if (!collection_child_remove(parent, child)) { + return false; + } - BKE_main_collection_sync(bmain); - return true; + BKE_main_collection_sync(bmain); + return true; } /********************** Collection index *********************/ -static Collection *collection_from_index_recursive(Collection *collection, const int index, int *index_current) +static Collection *collection_from_index_recursive(Collection *collection, + const int index, + int *index_current) { - if (index == (*index_current)) { - return collection; - } + if (index == (*index_current)) { + return collection; + } - (*index_current)++; + (*index_current)++; - for (CollectionChild *child = collection->children.first; child; child = child->next) { - Collection *nested = collection_from_index_recursive(child->collection, index, index_current); - if (nested != NULL) { - return nested; - } - } - return NULL; + for (CollectionChild *child = collection->children.first; child; child = child->next) { + Collection *nested = collection_from_index_recursive(child->collection, index, index_current); + if (nested != NULL) { + return nested; + } + } + return NULL; } /** @@ -1026,45 +1062,45 @@ static Collection *collection_from_index_recursive(Collection *collection, const */ Collection *BKE_collection_from_index(Scene *scene, const int index) { - int index_current = 0; - Collection *master_collection = BKE_collection_master(scene); - return collection_from_index_recursive(master_collection, index, &index_current); + int index_current = 0; + Collection *master_collection = BKE_collection_master(scene); + return collection_from_index_recursive(master_collection, index, &index_current); } static bool collection_objects_select(ViewLayer *view_layer, Collection *collection, bool deselect) { - bool changed = false; + bool changed = false; - if (collection->flag & COLLECTION_RESTRICT_SELECT) { - return false; - } + if (collection->flag & COLLECTION_RESTRICT_SELECT) { + return false; + } - for (CollectionObject *cob = collection->gobject.first; cob; cob = cob->next) { - Base *base = BKE_view_layer_base_find(view_layer, cob->ob); + for (CollectionObject *cob = collection->gobject.first; cob; cob = cob->next) { + Base *base = BKE_view_layer_base_find(view_layer, cob->ob); - if (base) { - if (deselect) { - if (base->flag & BASE_SELECTED) { - base->flag &= ~BASE_SELECTED; - changed = true; - } - } - else { - if ((base->flag & BASE_SELECTABLE) && !(base->flag & BASE_SELECTED)) { - base->flag |= BASE_SELECTED; - changed = true; - } - } - } - } + if (base) { + if (deselect) { + if (base->flag & BASE_SELECTED) { + base->flag &= ~BASE_SELECTED; + changed = true; + } + } + else { + if ((base->flag & BASE_SELECTABLE) && !(base->flag & BASE_SELECTED)) { + base->flag |= BASE_SELECTED; + changed = true; + } + } + } + } - for (CollectionChild *child = collection->children.first; child; child = child->next) { - if (collection_objects_select(view_layer, collection, deselect)) { - changed = true; - } - } + for (CollectionChild *child = collection->children.first; child; child = child->next) { + if (collection_objects_select(view_layer, collection, deselect)) { + changed = true; + } + } - return changed; + return changed; } /** @@ -1073,14 +1109,15 @@ static bool collection_objects_select(ViewLayer *view_layer, Collection *collect */ bool BKE_collection_objects_select(ViewLayer *view_layer, Collection *collection, bool deselect) { - LayerCollection *layer_collection = BKE_layer_collection_first_from_scene_collection(view_layer, collection); + LayerCollection *layer_collection = BKE_layer_collection_first_from_scene_collection(view_layer, + collection); - if (layer_collection != NULL) { - return BKE_layer_collection_objects_select(view_layer, layer_collection, deselect); - } - else { - return collection_objects_select(view_layer, collection, deselect); - } + if (layer_collection != NULL) { + return BKE_layer_collection_objects_select(view_layer, layer_collection, deselect); + } + else { + return collection_objects_select(view_layer, collection, deselect); + } } /***************** Collection move (outliner drag & drop) *********************/ @@ -1092,42 +1129,42 @@ bool BKE_collection_move(Main *bmain, bool relative_after, Collection *collection) { - if (collection->flag & COLLECTION_IS_MASTER) { - return false; - } - if (BKE_collection_find_cycle(to_parent, collection)) { - return false; - } + if (collection->flag & COLLECTION_IS_MASTER) { + return false; + } + if (BKE_collection_find_cycle(to_parent, collection)) { + return false; + } - /* Move to new parent collection */ - if (from_parent) { - collection_child_remove(from_parent, collection); - } + /* Move to new parent collection */ + if (from_parent) { + collection_child_remove(from_parent, collection); + } - collection_child_add(to_parent, collection, 0, true); + collection_child_add(to_parent, collection, 0, true); - /* Move to specified location under parent. */ - if (relative) { - CollectionChild *child = collection_find_child(to_parent, collection); - CollectionChild *relative_child = collection_find_child(to_parent, relative); + /* Move to specified location under parent. */ + if (relative) { + CollectionChild *child = collection_find_child(to_parent, collection); + CollectionChild *relative_child = collection_find_child(to_parent, relative); - if (relative_child) { - BLI_remlink(&to_parent->children, child); + if (relative_child) { + BLI_remlink(&to_parent->children, child); - if (relative_after) { - BLI_insertlinkafter(&to_parent->children, relative_child, child); - } - else { - BLI_insertlinkbefore(&to_parent->children, relative_child, child); - } + if (relative_after) { + BLI_insertlinkafter(&to_parent->children, relative_child, child); + } + else { + BLI_insertlinkbefore(&to_parent->children, relative_child, child); + } - BKE_collection_object_cache_free(to_parent); - } - } + BKE_collection_object_cache_free(to_parent); + } + } - BKE_main_collection_sync(bmain); + BKE_main_collection_sync(bmain); - return true; + return true; } /**************************** Iterators ******************************/ @@ -1135,54 +1172,56 @@ bool BKE_collection_move(Main *bmain, /* scene collection iteractor */ typedef struct CollectionsIteratorData { - Scene *scene; - void **array; - int tot, cur; + Scene *scene; + void **array; + int tot, cur; } CollectionsIteratorData; -static void scene_collection_callback(Collection *collection, BKE_scene_collections_Cb callback, void *data) +static void scene_collection_callback(Collection *collection, + BKE_scene_collections_Cb callback, + void *data) { - callback(collection, data); + callback(collection, data); - for (CollectionChild *child = collection->children.first; child; child = child->next) { - scene_collection_callback(child->collection, callback, data); - } + for (CollectionChild *child = collection->children.first; child; child = child->next) { + scene_collection_callback(child->collection, callback, data); + } } static void scene_collections_count(Collection *UNUSED(collection), void *data) { - int *tot = data; - (*tot)++; + int *tot = data; + (*tot)++; } static void scene_collections_build_array(Collection *collection, void *data) { - Collection ***array = data; - **array = collection; - (*array)++; + Collection ***array = data; + **array = collection; + (*array)++; } static void scene_collections_array(Scene *scene, Collection ***collections_array, int *tot) { - Collection *collection; - Collection **array; + Collection *collection; + Collection **array; - *collections_array = NULL; - *tot = 0; + *collections_array = NULL; + *tot = 0; - if (scene == NULL) { - return; - } + if (scene == NULL) { + return; + } - collection = BKE_collection_master(scene); - BLI_assert(collection != NULL); - scene_collection_callback(collection, scene_collections_count, tot); + collection = BKE_collection_master(scene); + BLI_assert(collection != NULL); + scene_collection_callback(collection, scene_collections_count, tot); - if (*tot == 0) - return; + if (*tot == 0) + return; - *collections_array = array = MEM_mallocN(sizeof(Collection *) * (*tot), "CollectionArray"); - scene_collection_callback(collection, scene_collections_build_array, &array); + *collections_array = array = MEM_mallocN(sizeof(Collection *) * (*tot), "CollectionArray"); + scene_collection_callback(collection, scene_collections_build_array, &array); } /** @@ -1191,70 +1230,69 @@ static void scene_collections_array(Scene *scene, Collection ***collections_arra */ void BKE_scene_collections_iterator_begin(BLI_Iterator *iter, void *data_in) { - Scene *scene = data_in; - CollectionsIteratorData *data = MEM_callocN(sizeof(CollectionsIteratorData), __func__); + Scene *scene = data_in; + CollectionsIteratorData *data = MEM_callocN(sizeof(CollectionsIteratorData), __func__); - data->scene = scene; - iter->data = data; - iter->valid = true; + data->scene = scene; + iter->data = data; + iter->valid = true; - scene_collections_array(scene, (Collection ***)&data->array, &data->tot); - BLI_assert(data->tot != 0); + scene_collections_array(scene, (Collection ***)&data->array, &data->tot); + BLI_assert(data->tot != 0); - data->cur = 0; - iter->current = data->array[data->cur]; + data->cur = 0; + iter->current = data->array[data->cur]; } void BKE_scene_collections_iterator_next(struct BLI_Iterator *iter) { - CollectionsIteratorData *data = iter->data; + CollectionsIteratorData *data = iter->data; - if (++data->cur < data->tot) { - iter->current = data->array[data->cur]; - } - else { - iter->valid = false; - } + if (++data->cur < data->tot) { + iter->current = data->array[data->cur]; + } + else { + iter->valid = false; + } } void BKE_scene_collections_iterator_end(struct BLI_Iterator *iter) { - CollectionsIteratorData *data = iter->data; + CollectionsIteratorData *data = iter->data; - if (data) { - if (data->array) { - MEM_freeN(data->array); - } - MEM_freeN(data); - } - iter->valid = false; + if (data) { + if (data->array) { + MEM_freeN(data->array); + } + MEM_freeN(data); + } + iter->valid = false; } - /* scene objects iterator */ typedef struct SceneObjectsIteratorData { - GSet *visited; - CollectionObject *cob_next; - BLI_Iterator scene_collection_iter; + GSet *visited; + CollectionObject *cob_next; + BLI_Iterator scene_collection_iter; } SceneObjectsIteratorData; void BKE_scene_objects_iterator_begin(BLI_Iterator *iter, void *data_in) { - Scene *scene = data_in; - SceneObjectsIteratorData *data = MEM_callocN(sizeof(SceneObjectsIteratorData), __func__); - iter->data = data; + Scene *scene = data_in; + SceneObjectsIteratorData *data = MEM_callocN(sizeof(SceneObjectsIteratorData), __func__); + iter->data = data; - /* lookup list ot make sure each object is object called once */ - data->visited = BLI_gset_ptr_new(__func__); + /* lookup list ot make sure each object is object called once */ + data->visited = BLI_gset_ptr_new(__func__); - /* we wrap the scenecollection iterator here to go over the scene collections */ - BKE_scene_collections_iterator_begin(&data->scene_collection_iter, scene); + /* we wrap the scenecollection iterator here to go over the scene collections */ + BKE_scene_collections_iterator_begin(&data->scene_collection_iter, scene); - Collection *collection = data->scene_collection_iter.current; - data->cob_next = collection->gobject.first; + Collection *collection = data->scene_collection_iter.current; + data->cob_next = collection->gobject.first; - BKE_scene_objects_iterator_next(iter); + BKE_scene_objects_iterator_next(iter); } /** @@ -1262,54 +1300,55 @@ void BKE_scene_objects_iterator_begin(BLI_Iterator *iter, void *data_in) */ static CollectionObject *object_base_unique(GSet *gs, CollectionObject *cob) { - for (; cob != NULL; cob = cob->next) { - Object *ob = cob->ob; - void **ob_key_p; - if (!BLI_gset_ensure_p_ex(gs, ob, &ob_key_p)) { - *ob_key_p = ob; - return cob; - } - } - return NULL; + for (; cob != NULL; cob = cob->next) { + Object *ob = cob->ob; + void **ob_key_p; + if (!BLI_gset_ensure_p_ex(gs, ob, &ob_key_p)) { + *ob_key_p = ob; + return cob; + } + } + return NULL; } void BKE_scene_objects_iterator_next(BLI_Iterator *iter) { - SceneObjectsIteratorData *data = iter->data; - CollectionObject *cob = data->cob_next ? object_base_unique(data->visited, data->cob_next) : NULL; - - if (cob) { - data->cob_next = cob->next; - iter->current = cob->ob; - } - else { - /* if this is the last object of this ListBase look at the next Collection */ - Collection *collection; - BKE_scene_collections_iterator_next(&data->scene_collection_iter); - do { - collection = data->scene_collection_iter.current; - /* get the first unique object of this collection */ - CollectionObject *new_cob = object_base_unique(data->visited, collection->gobject.first); - if (new_cob) { - data->cob_next = new_cob->next; - iter->current = new_cob->ob; - return; - } - BKE_scene_collections_iterator_next(&data->scene_collection_iter); - } while (data->scene_collection_iter.valid); - - if (!data->scene_collection_iter.valid) { - iter->valid = false; - } - } + SceneObjectsIteratorData *data = iter->data; + CollectionObject *cob = data->cob_next ? object_base_unique(data->visited, data->cob_next) : + NULL; + + if (cob) { + data->cob_next = cob->next; + iter->current = cob->ob; + } + else { + /* if this is the last object of this ListBase look at the next Collection */ + Collection *collection; + BKE_scene_collections_iterator_next(&data->scene_collection_iter); + do { + collection = data->scene_collection_iter.current; + /* get the first unique object of this collection */ + CollectionObject *new_cob = object_base_unique(data->visited, collection->gobject.first); + if (new_cob) { + data->cob_next = new_cob->next; + iter->current = new_cob->ob; + return; + } + BKE_scene_collections_iterator_next(&data->scene_collection_iter); + } while (data->scene_collection_iter.valid); + + if (!data->scene_collection_iter.valid) { + iter->valid = false; + } + } } void BKE_scene_objects_iterator_end(BLI_Iterator *iter) { - SceneObjectsIteratorData *data = iter->data; - if (data) { - BKE_scene_collections_iterator_end(&data->scene_collection_iter); - BLI_gset_free(data->visited, NULL); - MEM_freeN(data); - } + SceneObjectsIteratorData *data = iter->data; + if (data) { + BKE_scene_collections_iterator_end(&data->scene_collection_iter); + BLI_gset_free(data->visited, NULL); + MEM_freeN(data); + } } -- cgit v1.2.3