Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / collection.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Dalai Felinto
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/blenkernel/intern/collection.c
24  *  \ingroup bke
25  */
26
27 #include <string.h>
28
29 #include "BLI_blenlib.h"
30 #include "BLI_ghash.h"
31 #include "BLI_iterator.h"
32 #include "BLI_listbase.h"
33 #include "BLT_translation.h"
34 #include "BLI_string_utils.h"
35
36 #include "BKE_collection.h"
37 #include "BKE_idprop.h"
38 #include "BKE_layer.h"
39 #include "BKE_library.h"
40 #include "BKE_main.h"
41 #include "BKE_scene.h"
42
43 #include "DNA_ID.h"
44 #include "DNA_layer_types.h"
45 #include "DNA_object_types.h"
46 #include "DNA_scene_types.h"
47
48 #include "MEM_guardedalloc.h"
49
50
51 /**
52  * Add a collection to a collection ListBase and syncronize all render layers
53  * The ListBase is NULL when the collection is to be added to the master collection
54  */
55 SceneCollection *BKE_collection_add(Scene *scene, SceneCollection *sc_parent, const char *name)
56 {
57         SceneCollection *sc_master = BKE_collection_master(scene);
58         SceneCollection *sc = MEM_callocN(sizeof(SceneCollection), "New Collection");
59
60         if (!name) {
61                 name = DATA_("New Collection");
62         }
63
64         if (!sc_parent) {
65                 sc_parent = sc_master;
66         }
67
68         BKE_collection_rename(scene, sc, name);
69         BLI_addtail(&sc_parent->scene_collections, sc);
70
71         BKE_layer_sync_new_scene_collection(scene, sc_parent, sc);
72         return sc;
73 }
74
75 /**
76  * Free the collection items recursively
77  */
78 static void collection_free(SceneCollection *sc, const bool do_id_user)
79 {
80         if (do_id_user) {
81                 for (LinkData *link = sc->objects.first; link; link = link->next) {
82                         id_us_min(link->data);
83                 }
84                 for (LinkData *link = sc->filter_objects.first; link; link = link->next) {
85                         id_us_min(link->data);
86                 }
87         }
88
89         BLI_freelistN(&sc->objects);
90         BLI_freelistN(&sc->filter_objects);
91
92         for (SceneCollection *nsc = sc->scene_collections.first; nsc; nsc = nsc->next) {
93                 collection_free(nsc, do_id_user);
94         }
95         BLI_freelistN(&sc->scene_collections);
96 }
97
98 /**
99  * Unlink the collection recursively
100  * \return true if unlinked.
101  */
102 static bool collection_remlink(SceneCollection *sc_parent, SceneCollection *sc_gone)
103 {
104         for (SceneCollection *sc = sc_parent->scene_collections.first; sc; sc = sc->next) {
105                 if (sc == sc_gone) {
106                         BLI_remlink(&sc_parent->scene_collections, sc_gone);
107                         return true;
108                 }
109
110                 if (collection_remlink(sc, sc_gone)) {
111                         return true;
112                 }
113         }
114         return false;
115 }
116
117 /**
118  * Recursively remove any instance of this SceneCollection
119  */
120 static void layer_collection_remove(SceneLayer *sl, ListBase *lb, const SceneCollection *sc)
121 {
122         LayerCollection *lc = lb->first;
123         while (lc) {
124                 if (lc->scene_collection == sc) {
125                         BKE_layer_collection_free(sl, lc);
126                         BLI_remlink(lb, lc);
127
128                         LayerCollection *lc_next = lc->next;
129                         MEM_freeN(lc);
130                         lc = lc_next;
131
132                         /* only the "top-level" layer collections may have the
133                          * same SceneCollection in a sibling tree.
134                          */
135                         if (lb != &sl->layer_collections) {
136                                 return;
137                         }
138                 }
139
140                 else {
141                         layer_collection_remove(sl, &lc->layer_collections, sc);
142                         lc = lc->next;
143                 }
144         }
145 }
146
147 /**
148  * Remove a collection from the scene, and syncronize all render layers
149  */
150 bool BKE_collection_remove(Scene *scene, SceneCollection *sc)
151 {
152         SceneCollection *sc_master = BKE_collection_master(scene);
153
154         /* the master collection cannot be removed */
155         if (sc == sc_master) {
156                 return false;
157         }
158
159         /* unlink from the respective collection tree */
160         if (!collection_remlink(sc_master, sc)) {
161                 BLI_assert(false);
162         }
163
164         /* clear the collection items */
165         collection_free(sc, true);
166
167         /* check all layers that use this collection and clear them */
168         for (SceneLayer *sl = scene->render_layers.first; sl; sl = sl->next) {
169                 layer_collection_remove(sl, &sl->layer_collections, sc);
170                 sl->active_collection = 0;
171         }
172
173         MEM_freeN(sc);
174         return true;
175 }
176
177 /**
178  * Returns the master collection
179  */
180 SceneCollection *BKE_collection_master(const Scene *scene)
181 {
182         return scene->collection;
183 }
184
185 struct UniqueNameCheckData {
186         ListBase *lb;
187         SceneCollection *lookup_sc;
188 };
189
190 static bool collection_unique_name_check(void *arg, const char *name)
191 {
192         struct UniqueNameCheckData *data = arg;
193
194         for (SceneCollection *sc = data->lb->first; sc; sc = sc->next) {
195                 struct UniqueNameCheckData child_data = {.lb = &sc->scene_collections, .lookup_sc = data->lookup_sc};
196
197                 if (sc != data->lookup_sc) {
198                         if (STREQ(sc->name, name)) {
199                                 return true;
200                         }
201                 }
202                 if (collection_unique_name_check(&child_data, name)) {
203                         return true;
204                 }
205         }
206
207         return false;
208 }
209
210 void BKE_collection_rename(const Scene *scene, SceneCollection *sc, const char *name)
211 {
212         SceneCollection *sc_master = BKE_collection_master(scene);
213         struct UniqueNameCheckData data = {.lb = &sc_master->scene_collections, .lookup_sc = sc};
214
215         BLI_strncpy(sc->name, name, sizeof(sc->name));
216         BLI_uniquename_cb(collection_unique_name_check, &data, DATA_("Collection"), '.', sc->name, sizeof(sc->name));
217 }
218
219 /**
220  * Free (or release) any data used by the master collection (does not free the master collection itself).
221  * Used only to clear the entire scene data since it's not doing re-syncing of the LayerCollection tree
222  */
223 void BKE_collection_master_free(Scene *scene, const bool do_id_user)
224 {
225         collection_free(BKE_collection_master(scene), do_id_user);
226 }
227
228 static void collection_object_add(const Scene *scene, SceneCollection *sc, Object *ob)
229 {
230         BLI_addtail(&sc->objects, BLI_genericNodeN(ob));
231         id_us_plus((ID *)ob);
232         BKE_layer_sync_object_link(scene, sc, ob);
233 }
234
235 /**
236  * Add object to collection
237  */
238 void BKE_collection_object_add(const Scene *scene, SceneCollection *sc, Object *ob)
239 {
240         if (BLI_findptr(&sc->objects, ob, offsetof(LinkData, data))) {
241                 /* don't add the same object twice */
242                 return;
243         }
244         collection_object_add(scene, sc, ob);
245 }
246
247 /**
248  * Add object to all collections that reference objects is in
249  * (used to copy objects)
250  */
251 void BKE_collection_object_add_from(Scene *scene, Object *ob_src, Object *ob_dst)
252 {
253         FOREACH_SCENE_COLLECTION(scene, sc)
254         {
255                 if (BLI_findptr(&sc->objects, ob_src, offsetof(LinkData, data))) {
256                         collection_object_add(scene, sc, ob_dst);
257                 }
258         }
259         FOREACH_SCENE_COLLECTION_END
260
261         for (SceneLayer *sl = scene->render_layers.first; sl; sl = sl->next) {
262                 Base *base_src = BKE_scene_layer_base_find(sl, ob_src);
263                 if (base_src != NULL) {
264                         if (base_src->collection_properties == NULL) {
265                                 continue;
266                         }
267                         Base *base_dst = BKE_scene_layer_base_find(sl, ob_dst);
268                         IDP_MergeGroup(base_dst->collection_properties, base_src->collection_properties, true);
269                 }
270         }
271 }
272
273 /**
274  * Remove object from collection.
275  * \param bmain: Can be NULL if free_us is false.
276  */
277 void BKE_collection_object_remove(Main *bmain, const Scene *scene, SceneCollection *sc, Object *ob, const bool free_us)
278 {
279
280         LinkData *link = BLI_findptr(&sc->objects, ob, offsetof(LinkData, data));
281
282         if (link == NULL) {
283                 return;
284         }
285
286         BLI_remlink(&sc->objects, link);
287         MEM_freeN(link);
288
289         TODO_LAYER_SYNC_FILTER; /* need to remove all instances of ob in scene collections -> filter_objects */
290         BKE_layer_sync_object_unlink(scene, sc, ob);
291
292         if (free_us) {
293                 BKE_libblock_free_us(bmain, ob);
294         }
295         else {
296                 id_us_min(&ob->id);
297         }
298 }
299
300 /**
301  * Move object from a collection into another
302  */
303 void BKE_collection_object_move(const Scene *scene, SceneCollection *sc_dst, SceneCollection *sc_src, Object *ob)
304 {
305         BKE_collection_object_add(scene, sc_dst, ob);
306         BKE_collection_object_remove(NULL, scene, sc_src, ob, false);
307 }
308
309 /**
310  * Remove object from all collections of scene
311  */
312 void BKE_collections_object_remove(Main *bmain, Scene *scene, Object *ob, const bool free_us)
313 {
314         BKE_scene_remove_rigidbody_object(scene, ob);
315
316         FOREACH_SCENE_COLLECTION(scene, sc)
317         {
318                 BKE_collection_object_remove(bmain, scene, sc, ob, free_us);
319         }
320         FOREACH_SCENE_COLLECTION_END
321 }
322
323 /* ---------------------------------------------------------------------- */
324 /* Outliner drag and drop */
325
326 /**
327  * Find and return the SceneCollection that has \a sc_child as one of its directly
328  * nested SceneCollection.
329  *
330  * \param sc_parent Initial SceneCollection to look into recursively, usually the master collection
331  */
332 static SceneCollection *find_collection_parent(const SceneCollection *sc_child, SceneCollection *sc_parent)
333 {
334         for (SceneCollection *sc_nested = sc_parent->scene_collections.first; sc_nested; sc_nested = sc_nested->next) {
335                 if (sc_nested == sc_child) {
336                         return sc_parent;
337                 }
338
339                 SceneCollection *found = find_collection_parent(sc_child, sc_nested);
340                 if (found) {
341                         return found;
342                 }
343         }
344
345         return NULL;
346 }
347
348 /**
349  * Check if \a sc_reference is nested to \a sc_parent SceneCollection
350  */
351 static bool is_collection_in_tree(const SceneCollection *sc_reference, SceneCollection *sc_parent)
352 {
353         return find_collection_parent(sc_reference, sc_parent) != NULL;
354 }
355
356 bool BKE_collection_move_above(const Scene *scene, SceneCollection *sc_dst, SceneCollection *sc_src)
357 {
358         /* Find the SceneCollection the sc_src belongs to */
359         SceneCollection *sc_master = BKE_collection_master(scene);
360
361         /* Master Layer can't be moved around*/
362         if (ELEM(sc_master, sc_src, sc_dst)) {
363                 return false;
364         }
365
366         /* collection is already where we wanted it to be */
367         if (sc_dst->prev == sc_src) {
368                 return false;
369         }
370
371         /* We can't move a collection fs the destiny collection
372          * is nested to the source collection */
373         if (is_collection_in_tree(sc_dst, sc_src)) {
374                 return false;
375         }
376
377         SceneCollection *sc_src_parent = find_collection_parent(sc_src, sc_master);
378         SceneCollection *sc_dst_parent = find_collection_parent(sc_dst, sc_master);
379         BLI_assert(sc_src_parent);
380         BLI_assert(sc_dst_parent);
381
382         /* Remove sc_src from its parent */
383         BLI_remlink(&sc_src_parent->scene_collections, sc_src);
384
385         /* Re-insert it where it belongs */
386         BLI_insertlinkbefore(&sc_dst_parent->scene_collections, sc_dst, sc_src);
387
388         /* Update the tree */
389         BKE_layer_collection_resync(scene, sc_src_parent);
390         BKE_layer_collection_resync(scene, sc_dst_parent);
391
392         return true;
393 }
394
395 bool BKE_collection_move_below(const Scene *scene, SceneCollection *sc_dst, SceneCollection *sc_src)
396 {
397         /* Find the SceneCollection the sc_src belongs to */
398         SceneCollection *sc_master = BKE_collection_master(scene);
399
400         /* Master Layer can't be moved around*/
401         if (ELEM(sc_master, sc_src, sc_dst)) {
402                 return false;
403         }
404
405         /* Collection is already where we wanted it to be */
406         if (sc_dst->next == sc_src) {
407                 return false;
408         }
409
410         /* We can't move a collection if the destiny collection
411          * is nested to the source collection */
412         if (is_collection_in_tree(sc_dst, sc_src)) {
413                 return false;
414         }
415
416         SceneCollection *sc_src_parent = find_collection_parent(sc_src, sc_master);
417         SceneCollection *sc_dst_parent = find_collection_parent(sc_dst, sc_master);
418         BLI_assert(sc_src_parent);
419         BLI_assert(sc_dst_parent);
420
421         /* Remove sc_src from its parent */
422         BLI_remlink(&sc_src_parent->scene_collections, sc_src);
423
424         /* Re-insert it where it belongs */
425         BLI_insertlinkafter(&sc_dst_parent->scene_collections, sc_dst, sc_src);
426
427         /* Update the tree */
428         BKE_layer_collection_resync(scene, sc_src_parent);
429         BKE_layer_collection_resync(scene, sc_dst_parent);
430
431         return true;
432 }
433
434 bool BKE_collection_move_into(const Scene *scene, SceneCollection *sc_dst, SceneCollection *sc_src)
435 {
436         /* Find the SceneCollection the sc_src belongs to */
437         SceneCollection *sc_master = BKE_collection_master(scene);
438         if (sc_src == sc_master) {
439                 return false;
440         }
441
442         /* We can't move a collection if the destiny collection
443          * is nested to the source collection */
444         if (is_collection_in_tree(sc_dst, sc_src)) {
445                 return false;
446         }
447
448         SceneCollection *sc_src_parent = find_collection_parent(sc_src, sc_master);
449         BLI_assert(sc_src_parent);
450
451         /* collection is already where we wanted it to be */
452         if (sc_dst->scene_collections.last == sc_src) {
453                 return false;
454         }
455
456         /* Remove sc_src from it */
457         BLI_remlink(&sc_src_parent->scene_collections, sc_src);
458
459         /* Insert sc_src into sc_dst */
460         BLI_addtail(&sc_dst->scene_collections, sc_src);
461
462         /* Update the tree */
463         BKE_layer_collection_resync(scene, sc_src_parent);
464         BKE_layer_collection_resync(scene, sc_dst);
465
466         return true;
467 }
468
469 /* ---------------------------------------------------------------------- */
470 /* Iteractors */
471 /* scene collection iteractor */
472
473 typedef struct SceneCollectionsIteratorData {
474         Scene *scene;
475         void **array;
476         int tot, cur;
477 } SceneCollectionsIteratorData;
478
479 static void scene_collection_callback(SceneCollection *sc, BKE_scene_collections_Cb callback, void *data)
480 {
481         callback(sc, data);
482
483         for (SceneCollection *nsc = sc->scene_collections.first; nsc; nsc = nsc->next) {
484                 scene_collection_callback(nsc, callback, data);
485         }
486 }
487
488 static void scene_collections_count(SceneCollection *UNUSED(sc), void *data)
489 {
490         int *tot = data;
491         (*tot)++;
492 }
493
494 static void scene_collections_build_array(SceneCollection *sc, void *data)
495 {
496         SceneCollection ***array = data;
497         **array = sc;
498         (*array)++;
499 }
500
501 static void scene_collections_array(Scene *scene, SceneCollection ***collections_array, int *tot)
502 {
503         SceneCollection *sc = BKE_collection_master(scene);
504         SceneCollection **array;
505
506         *collections_array = NULL;
507         *tot = 0;
508
509         if (scene == NULL)
510                 return;
511
512         scene_collection_callback(sc, scene_collections_count, tot);
513
514         if (*tot == 0)
515                 return;
516
517         *collections_array = array = MEM_mallocN(sizeof(SceneCollection *) * (*tot), "SceneCollectionArray");
518         scene_collection_callback(sc, scene_collections_build_array, &array);
519 }
520
521 /**
522  * Only use this in non-performance critical situations
523  * (it iterates over all scene collections twice)
524  */
525 void BKE_scene_collections_iterator_begin(BLI_Iterator *iter, void *data_in)
526 {
527         Scene *scene = data_in;
528         SceneCollectionsIteratorData *data = MEM_callocN(sizeof(SceneCollectionsIteratorData), __func__);
529
530         data->scene = scene;
531         iter->data = data;
532
533         scene_collections_array(scene, (SceneCollection ***)&data->array, &data->tot);
534         BLI_assert(data->tot != 0);
535
536         data->cur = 0;
537         iter->current = data->array[data->cur];
538 }
539
540 void BKE_scene_collections_iterator_next(struct BLI_Iterator *iter)
541 {
542         SceneCollectionsIteratorData *data = iter->data;
543
544         if (++data->cur < data->tot) {
545                 iter->current = data->array[data->cur];
546         }
547         else {
548                 iter->valid = false;
549         }
550 }
551
552 void BKE_scene_collections_iterator_end(struct BLI_Iterator *iter)
553 {
554         SceneCollectionsIteratorData *data = iter->data;
555
556         if (data) {
557                 if (data->array) {
558                         MEM_freeN(data->array);
559                 }
560                 MEM_freeN(data);
561         }
562         iter->valid = false;
563 }
564
565
566 /* scene objects iteractor */
567
568 typedef struct SceneObjectsIteratorData {
569         GSet *visited;
570         LinkData *link_next;
571         BLI_Iterator scene_collection_iter;
572 } SceneObjectsIteratorData;
573
574 void BKE_scene_objects_iterator_begin(BLI_Iterator *iter, void *data_in)
575 {
576         Scene *scene = data_in;
577         SceneObjectsIteratorData *data = MEM_callocN(sizeof(SceneObjectsIteratorData), __func__);
578         iter->data = data;
579
580         /* lookup list ot make sure each object is object called once */
581         data->visited = BLI_gset_ptr_new(__func__);
582
583         /* we wrap the scenecollection iterator here to go over the scene collections */
584         BKE_scene_collections_iterator_begin(&data->scene_collection_iter, scene);
585
586         SceneCollection *sc = data->scene_collection_iter.current;
587         if (sc->objects.first != NULL) {
588                 iter->current = ((LinkData *)sc->objects.first)->data;
589         }
590         else {
591                 BKE_scene_objects_iterator_next(iter);
592         }
593 }
594
595 /**
596  * Gets the first unique object in the sequence
597  */
598 static LinkData *object_base_unique(GSet *gs, LinkData *link)
599 {
600         for (; link != NULL; link = link->next) {
601                 Object *ob = link->data;
602                 void **ob_key_p;
603                 if (!BLI_gset_ensure_p_ex(gs, ob, &ob_key_p)) {
604                         *ob_key_p = ob;
605                         return link;
606                 }
607         }
608         return NULL;
609 }
610
611 void BKE_scene_objects_iterator_next(BLI_Iterator *iter)
612 {
613         SceneObjectsIteratorData *data = iter->data;
614         LinkData *link = data->link_next ? object_base_unique(data->visited, data->link_next) : NULL;
615
616         if (link) {
617                 data->link_next = link->next;
618                 iter->current = link->data;
619         }
620         else {
621                 /* if this is the last object of this ListBase look at the next SceneCollection */
622                 SceneCollection *sc;
623                 BKE_scene_collections_iterator_next(&data->scene_collection_iter);
624                 do {
625                         sc = data->scene_collection_iter.current;
626                         /* get the first unique object of this collection */
627                         LinkData *new_link = object_base_unique(data->visited, sc->objects.first);
628                         if (new_link) {
629                                 data->link_next = new_link->next;
630                                 iter->current = new_link->data;
631                                 return;
632                         }
633                         BKE_scene_collections_iterator_next(&data->scene_collection_iter);
634                 } while (data->scene_collection_iter.valid);
635
636                 if (!data->scene_collection_iter.valid) {
637                         iter->valid = false;
638                 }
639         }
640 }
641
642 void BKE_scene_objects_iterator_end(BLI_Iterator *iter)
643 {
644         SceneObjectsIteratorData *data = iter->data;
645         if (data) {
646                 BKE_scene_collections_iterator_end(&data->scene_collection_iter);
647                 BLI_gset_free(data->visited, NULL);
648                 MEM_freeN(data);
649         }
650 }