Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / library_override.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  * The Original Code is Copyright (C) 2016 by Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Bastien Montagne.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blenkernel/intern/library_override.c
27  *  \ingroup bke
28  */
29
30 #include <stdlib.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_ID.h"
35 #include "DNA_object_types.h"
36
37 #include "DEG_depsgraph.h"
38 #include "BKE_library.h"
39 #include "BKE_library_override.h"
40 #include "BKE_library_remap.h"
41 #include "BKE_main.h"
42
43 #include "BLI_utildefines.h"
44 #include "BLI_listbase.h"
45 #include "BLI_string.h"
46
47 #include "RNA_access.h"
48 #include "RNA_types.h"
49
50 #include "PIL_time.h"
51 #include "PIL_time_utildefines.h"
52
53 #define OVERRIDE_AUTO_CHECK_DELAY 0.2  /* 200ms between auto-override checks. */
54
55 static void bke_override_property_copy(IDOverrideStaticProperty *op_dst, IDOverrideStaticProperty *op_src);
56 static void bke_override_property_operation_copy(IDOverrideStaticPropertyOperation *opop_dst, IDOverrideStaticPropertyOperation *opop_src);
57
58 static void bke_override_property_clear(IDOverrideStaticProperty *op);
59 static void bke_override_property_operation_clear(IDOverrideStaticPropertyOperation *opop);
60
61 /** Initialize empty overriding of \a reference_id by \a local_id. */
62 IDOverrideStatic *BKE_override_static_init(ID *local_id, ID *reference_id)
63 {
64         /* If reference_id is NULL, we are creating an override template for purely local data.
65          * Else, reference *must* be linked data. */
66         BLI_assert(reference_id == NULL || reference_id->lib != NULL);
67         BLI_assert(local_id->override_static == NULL);
68
69         ID *ancestor_id;
70         for (ancestor_id = reference_id;
71              ancestor_id != NULL && ancestor_id->override_static != NULL && ancestor_id->override_static->reference != NULL;
72              ancestor_id = ancestor_id->override_static->reference);
73
74         if (ancestor_id != NULL && ancestor_id->override_static != NULL) {
75                 /* Original ID has a template, use it! */
76                 BKE_override_static_copy(local_id, ancestor_id);
77                 if (local_id->override_static->reference != reference_id) {
78                         id_us_min(local_id->override_static->reference);
79                         local_id->override_static->reference = reference_id;
80                         id_us_plus(local_id->override_static->reference);
81                 }
82                 return local_id->override_static;
83         }
84
85         /* Else, generate new empty override. */
86         local_id->override_static = MEM_callocN(sizeof(*local_id->override_static), __func__);
87         local_id->override_static->reference = reference_id;
88         id_us_plus(local_id->override_static->reference);
89         local_id->tag &= ~LIB_TAG_OVERRIDESTATIC_OK;
90         /* TODO do we want to add tag or flag to referee to mark it as such? */
91         return local_id->override_static;
92 }
93
94 /** Deep copy of a whole override from \a src_id to \a dst_id. */
95 void BKE_override_static_copy(ID *dst_id, const ID *src_id)
96 {
97         BLI_assert(src_id->override_static != NULL);
98
99         if (dst_id->override_static != NULL) {
100                 if (src_id->override_static == NULL) {
101                         BKE_override_static_free(&dst_id->override_static);
102                         return;
103                 }
104                 else {
105                         BKE_override_static_clear(dst_id->override_static);
106                 }
107         }
108         else if (src_id->override_static == NULL) {
109                 return;
110         }
111         else {
112                 BKE_override_static_init(dst_id, NULL);
113         }
114
115         /* Source is already overriding data, we copy it but reuse its reference for dest ID.
116          * otherwise, source is only an override template, it then becomes reference of dest ID. */
117         dst_id->override_static->reference = src_id->override_static->reference ? src_id->override_static->reference : (ID *)src_id;
118         id_us_plus(dst_id->override_static->reference);
119
120         BLI_duplicatelist(&dst_id->override_static->properties, &src_id->override_static->properties);
121         for (IDOverrideStaticProperty *op_dst = dst_id->override_static->properties.first, *op_src = src_id->override_static->properties.first;
122              op_dst;
123              op_dst = op_dst->next, op_src = op_src->next)
124         {
125                 bke_override_property_copy(op_dst, op_src);
126         }
127
128         dst_id->tag &= ~LIB_TAG_OVERRIDESTATIC_OK;
129 }
130
131 /** Clear any overriding data from given \a override. */
132 void BKE_override_static_clear(IDOverrideStatic *override)
133 {
134         BLI_assert(override != NULL);
135
136         for (IDOverrideStaticProperty *op = override->properties.first; op; op = op->next) {
137                 bke_override_property_clear(op);
138         }
139         BLI_freelistN(&override->properties);
140
141         id_us_min(override->reference);
142         /* override->storage should never be refcounted... */
143 }
144
145 /** Free given \a override. */
146 void BKE_override_static_free(struct IDOverrideStatic **override)
147 {
148         BLI_assert(*override != NULL);
149
150         BKE_override_static_clear(*override);
151         MEM_freeN(*override);
152         *override = NULL;
153 }
154
155 static ID *override_static_create_from(Main *bmain, ID *reference_id)
156 {
157         ID *local_id;
158
159         if (!id_copy(bmain, reference_id, (ID **)&local_id, false)) {
160                 return NULL;
161         }
162         id_us_min(local_id);
163
164         BKE_override_static_init(local_id, reference_id);
165         local_id->flag |= LIB_OVERRIDE_STATIC_AUTO;
166
167         return local_id;
168 }
169
170
171 /** Create an overriden local copy of linked reference. */
172 ID *BKE_override_static_create_from_id(Main *bmain, ID *reference_id)
173 {
174         BLI_assert(reference_id != NULL);
175         BLI_assert(reference_id->lib != NULL);
176
177         ID *local_id = override_static_create_from(bmain, reference_id);
178
179         /* Remapping, we obviously only want to affect local data (and not our own reference pointer to overriden ID). */
180         BKE_libblock_remap(bmain, reference_id, local_id, ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_STATIC_OVERRIDE);
181
182         return local_id;
183 }
184
185 /** Create overriden local copies of all tagged data-blocks in given Main.
186  *
187  * \note Set id->newid of overridden libs with newly created overrides, caller is responsible to clean those pointers
188  * before/after usage as needed.
189  *
190  * \return \a true on success, \a false otherwise.
191  */
192 bool BKE_override_static_create_from_tag(Main *bmain)
193 {
194         ListBase *lbarray[MAX_LIBARRAY];
195         int a;
196         bool ret = true;
197
198         const int num_types = a = set_listbasepointers(bmain, lbarray);
199         while (a--) {
200                 for (ID *reference_id = lbarray[a]->first; reference_id != NULL; reference_id = reference_id->next) {
201                         if ((reference_id->tag & LIB_TAG_DOIT) != 0 && reference_id->lib != NULL) {
202                                 if ((reference_id->newid = override_static_create_from(bmain, reference_id)) == NULL) {
203                                         ret = false;
204                                 }
205                         }
206                 }
207         }
208
209         /* Remapping, we obviously only want to affect local data (and not our own reference pointer to overriden ID). */
210         a = num_types;
211         while (a--) {
212                 for (ID *reference_id = lbarray[a]->first; reference_id != NULL; reference_id = reference_id->next) {
213                         if ((reference_id->tag & LIB_TAG_DOIT) != 0 && reference_id->lib != NULL && reference_id->newid != NULL) {
214                                 ID *local_id = reference_id->newid;
215                                 BKE_libblock_remap(bmain, reference_id, local_id,
216                                                    ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_STATIC_OVERRIDE);
217                         }
218                 }
219         }
220
221         return ret;
222 }
223
224 /**
225  * Find override property from given RNA path, if it exists.
226  */
227 IDOverrideStaticProperty *BKE_override_static_property_find(IDOverrideStatic *override, const char *rna_path)
228 {
229         /* XXX TODO we'll most likely want a runtime ghash to store that mapping at some point. */
230         return BLI_findstring_ptr(&override->properties, rna_path, offsetof(IDOverrideStaticProperty, rna_path));
231 }
232
233 /**
234  * Find override property from given RNA path, or create it if it does not exist.
235  */
236 IDOverrideStaticProperty *BKE_override_static_property_get(IDOverrideStatic *override, const char *rna_path, bool *r_created)
237 {
238         /* XXX TODO we'll most likely want a runtime ghash to store taht mapping at some point. */
239         IDOverrideStaticProperty *op = BKE_override_static_property_find(override, rna_path);
240
241         if (op == NULL) {
242                 op = MEM_callocN(sizeof(IDOverrideStaticProperty), __func__);
243                 op->rna_path = BLI_strdup(rna_path);
244                 BLI_addtail(&override->properties, op);
245
246                 if (r_created) {
247                         *r_created = true;
248                 }
249         }
250         else if (r_created) {
251                 *r_created = false;
252         }
253
254         return op;
255 }
256
257 void bke_override_property_copy(IDOverrideStaticProperty *op_dst, IDOverrideStaticProperty *op_src)
258 {
259         op_dst->rna_path = BLI_strdup(op_src->rna_path);
260         BLI_duplicatelist(&op_dst->operations, &op_src->operations);
261
262         for (IDOverrideStaticPropertyOperation *opop_dst = op_dst->operations.first, *opop_src = op_src->operations.first;
263              opop_dst;
264              opop_dst = opop_dst->next, opop_src = opop_src->next)
265         {
266                 bke_override_property_operation_copy(opop_dst, opop_src);
267         }
268 }
269
270 void bke_override_property_clear(IDOverrideStaticProperty *op)
271 {
272         BLI_assert(op->rna_path != NULL);
273
274         MEM_freeN(op->rna_path);
275
276         for (IDOverrideStaticPropertyOperation *opop = op->operations.first; opop; opop = opop->next) {
277                 bke_override_property_operation_clear(opop);
278         }
279         BLI_freelistN(&op->operations);
280 }
281
282 /**
283  * Remove and free given \a override_property from given ID \a override.
284  */
285 void BKE_override_static_property_delete(IDOverrideStatic *override, IDOverrideStaticProperty *override_property)
286 {
287         bke_override_property_clear(override_property);
288         BLI_freelinkN(&override->properties, override_property);
289 }
290
291 /**
292  * Find override property operation from given sub-item(s), if it exists.
293  */
294 IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_find(
295         IDOverrideStaticProperty *override_property,
296         const char *subitem_refname, const char *subitem_locname,
297         const int subitem_refindex, const int subitem_locindex, const bool strict, bool *r_strict)
298 {
299         IDOverrideStaticPropertyOperation *opop;
300         const int subitem_defindex = -1;
301
302         if (r_strict) {
303                 *r_strict = true;
304         }
305
306         if (subitem_locname &&
307             (opop = BLI_findstring_ptr(&override_property->operations, subitem_locname,
308                                        offsetof(IDOverrideStaticPropertyOperation, subitem_local_name))))
309         {
310                 return opop;
311         }
312
313         if (subitem_refname &&
314             (opop = BLI_findstring_ptr(&override_property->operations, subitem_refname,
315                                        offsetof(IDOverrideStaticPropertyOperation, subitem_reference_name))))
316         {
317                 return opop;
318         }
319
320         if ((opop = BLI_listbase_bytes_find(&override_property->operations, &subitem_locindex, sizeof(subitem_locindex),
321                                             offsetof(IDOverrideStaticPropertyOperation, subitem_local_index))))
322         {
323                 return opop;
324         }
325
326         if ((opop = BLI_listbase_bytes_find(&override_property->operations, &subitem_refindex, sizeof(subitem_refindex),
327                                             offsetof(IDOverrideStaticPropertyOperation, subitem_reference_index))))
328         {
329                 return opop;
330         }
331
332         /* index == -1 means all indices, that is valid fallback in case we requested specific index. */
333         if (!strict && (subitem_locindex != subitem_defindex) &&
334             (opop = BLI_listbase_bytes_find(&override_property->operations, &subitem_defindex, sizeof(subitem_defindex),
335                                             offsetof(IDOverrideStaticPropertyOperation, subitem_local_index))))
336         {
337                 if (r_strict) {
338                         *r_strict = false;
339                 }
340                 return opop;
341         }
342
343         return NULL;
344 }
345
346 /**
347  * Find override property operation from given sub-item(s), or create it if it does not exist.
348  */
349 IDOverrideStaticPropertyOperation *BKE_override_static_property_operation_get(
350         IDOverrideStaticProperty *override_property, const short operation,
351         const char *subitem_refname, const char *subitem_locname,
352         const int subitem_refindex, const int subitem_locindex,
353         const bool strict, bool *r_strict, bool *r_created)
354 {
355         IDOverrideStaticPropertyOperation *opop = BKE_override_static_property_operation_find(override_property,
356                                                                                  subitem_refname, subitem_locname,
357                                                                                  subitem_refindex, subitem_locindex,
358                                                                                  strict, r_strict);
359
360         if (opop == NULL) {
361                 opop = MEM_callocN(sizeof(IDOverrideStaticPropertyOperation), __func__);
362                 opop->operation = operation;
363                 if (subitem_locname) {
364                         opop->subitem_local_name = BLI_strdup(subitem_locname);
365                 }
366                 if (subitem_refname) {
367                         opop->subitem_reference_name = BLI_strdup(subitem_refname);
368                 }
369                 opop->subitem_local_index = subitem_locindex;
370                 opop->subitem_reference_index = subitem_refindex;
371
372                 BLI_addtail(&override_property->operations, opop);
373
374                 if (r_created) {
375                         *r_created = true;
376                 }
377         }
378         else if (r_created) {
379                 *r_created = false;
380         }
381
382         return opop;
383 }
384
385 void bke_override_property_operation_copy(IDOverrideStaticPropertyOperation *opop_dst, IDOverrideStaticPropertyOperation *opop_src)
386 {
387         if (opop_src->subitem_reference_name) {
388                 opop_dst->subitem_reference_name = BLI_strdup(opop_src->subitem_reference_name);
389         }
390         if (opop_src->subitem_local_name) {
391                 opop_dst->subitem_local_name = BLI_strdup(opop_src->subitem_local_name);
392         }
393 }
394
395 void bke_override_property_operation_clear(IDOverrideStaticPropertyOperation *opop)
396 {
397         if (opop->subitem_reference_name) {
398                 MEM_freeN(opop->subitem_reference_name);
399         }
400         if (opop->subitem_local_name) {
401                 MEM_freeN(opop->subitem_local_name);
402         }
403 }
404
405 /**
406  * Remove and free given \a override_property_operation from given ID \a override_property.
407  */
408 void BKE_override_static_property_operation_delete(
409         IDOverrideStaticProperty *override_property, IDOverrideStaticPropertyOperation *override_property_operation)
410 {
411         bke_override_property_operation_clear(override_property_operation);
412         BLI_freelinkN(&override_property->operations, override_property_operation);
413 }
414
415 /**
416  * Check that status of local data-block is still valid against current reference one.
417  *
418  * It means that all overridable, but not overridden, properties' local values must be equal to reference ones.
419  * Clears LIB_TAG_OVERRIDE_OK if they do not.
420  *
421  * This is typically used to detect whether some property has been changed in local and a new IDOverrideProperty
422  * (of IDOverridePropertyOperation) has to be added.
423  *
424  * \return true if status is OK, false otherwise. */
425 bool BKE_override_static_status_check_local(ID *local)
426 {
427         BLI_assert(local->override_static != NULL);
428
429         ID *reference = local->override_static->reference;
430
431         if (reference == NULL) {
432                 /* This is an override template, local status is always OK! */
433                 return true;
434         }
435
436         BLI_assert(GS(local->name) == GS(reference->name));
437
438         /* Note that reference is assumed always valid, caller has to ensure that itself. */
439
440         PointerRNA rnaptr_local, rnaptr_reference;
441         RNA_id_pointer_create(local, &rnaptr_local);
442         RNA_id_pointer_create(reference, &rnaptr_reference);
443
444         if (!RNA_struct_override_matches(
445                 &rnaptr_local, &rnaptr_reference, NULL, local->override_static,
446                 RNA_OVERRIDE_COMPARE_IGNORE_NON_OVERRIDABLE | RNA_OVERRIDE_COMPARE_IGNORE_OVERRIDDEN, NULL))
447         {
448                 local->tag &= ~LIB_TAG_OVERRIDESTATIC_OK;
449                 return false;
450         }
451
452         return true;
453 }
454
455 /**
456  * Check that status of reference data-block is still valid against current local one.
457  *
458  * It means that all non-overridden properties' local values must be equal to reference ones.
459  * Clears LIB_TAG_OVERRIDE_OK if they do not.
460  *
461  * This is typically used to detect whether some reference has changed and local needs to be updated against it.
462  *
463  * \return true if status is OK, false otherwise. */
464 bool BKE_override_static_status_check_reference(ID *local)
465 {
466         BLI_assert(local->override_static != NULL);
467
468         ID *reference = local->override_static->reference;
469
470         if (reference == NULL) {
471                 /* This is an override template, reference is virtual, so its status is always OK! */
472                 return true;
473         }
474
475         BLI_assert(GS(local->name) == GS(reference->name));
476
477         if (reference->override_static && (reference->tag & LIB_TAG_OVERRIDESTATIC_OK) == 0) {
478                 if (!BKE_override_static_status_check_reference(reference)) {
479                         /* If reference is also override of another data-block, and its status is not OK,
480                          * then this override is not OK either.
481                          * Note that this should only happen when reloading libraries... */
482                         local->tag &= ~LIB_TAG_OVERRIDESTATIC_OK;
483                         return false;
484                 }
485         }
486
487         PointerRNA rnaptr_local, rnaptr_reference;
488         RNA_id_pointer_create(local, &rnaptr_local);
489         RNA_id_pointer_create(reference, &rnaptr_reference);
490
491         if (!RNA_struct_override_matches(
492                 &rnaptr_local, &rnaptr_reference, NULL, local->override_static,
493                 RNA_OVERRIDE_COMPARE_IGNORE_OVERRIDDEN, NULL))
494         {
495                 local->tag &= ~LIB_TAG_OVERRIDESTATIC_OK;
496                 return false;
497         }
498
499         return true;
500 }
501
502 /**
503  * Compares local and reference data-blocks and create new override operations as needed,
504  * or reset to reference values if overriding is not allowed.
505  *
506  * \note Defining override operations is only mandatory before saving a .blend file on disk (not for undo!).
507  * Knowing that info at runtime is only useful for UI/UX feedback.
508  *
509  * \note This is by far the biggest operation (the more time-consuming) of the three so far, since it has to go over
510  * all properties in depth (all overridable ones at least). Generating diff values and applying overrides
511  * are much cheaper.
512  *
513  * \return true is new overriding op was created, or some local data was reset. */
514 bool BKE_override_static_operations_create(ID *local)
515 {
516         BLI_assert(local->override_static != NULL);
517         const bool is_template = (local->override_static->reference == NULL);
518         bool ret = false;
519
520         if (!is_template && local->flag & LIB_OVERRIDE_STATIC_AUTO) {
521                 PointerRNA rnaptr_local, rnaptr_reference;
522                 RNA_id_pointer_create(local, &rnaptr_local);
523                 RNA_id_pointer_create(local->override_static->reference, &rnaptr_reference);
524
525                 eRNAOverrideMatchResult report_flags = 0;
526                 RNA_struct_override_matches(
527                             &rnaptr_local, &rnaptr_reference, NULL, local->override_static,
528                             RNA_OVERRIDE_COMPARE_CREATE | RNA_OVERRIDE_COMPARE_RESTORE, &report_flags);
529                 if (report_flags & RNA_OVERRIDE_MATCH_RESULT_CREATED) {
530                         ret = true;
531                 }
532 #ifndef NDEBUG
533                 if (report_flags & RNA_OVERRIDE_MATCH_RESULT_RESTORED) {
534                         printf("We did restore some properties of %s from its reference.\n", local->name);
535                 }
536                 if (ret) {
537                         printf("We did generate static override rules for %s\n", local->name);
538                 }
539                 else {
540                         printf("No new static override rules for %s\n", local->name);
541                 }
542 #endif
543         }
544         return ret;
545 }
546
547 /** Check all overrides from given \a bmain and create/update overriding operations as needed. */
548 void BKE_main_override_static_operations_create(Main *bmain)
549 {
550         ListBase *lbarray[MAX_LIBARRAY];
551         int base_count, i;
552
553         base_count = set_listbasepointers(bmain, lbarray);
554
555         for (i = 0; i < base_count; i++) {
556                 ListBase *lb = lbarray[i];
557                 ID *id;
558
559                 for (id = lb->first; id; id = id->next) {
560                         /* TODO Maybe we could also add an 'override update' tag e.g. when tagging for DEG update? */
561                         if (id->lib == NULL && id->override_static != NULL && id->override_static->reference != NULL && (id->flag & LIB_OVERRIDE_STATIC_AUTO)) {
562                                 BKE_override_static_operations_create(id);
563                         }
564                 }
565         }
566 }
567
568 /** Update given override from its reference (re-applying overriden properties). */
569 void BKE_override_static_update(Main *bmain, ID *local)
570 {
571         if (local->override_static == NULL || local->override_static->reference == NULL) {
572                 return;
573         }
574
575         /* Recursively do 'ancestors' overrides first, if any. */
576         if (local->override_static->reference->override_static && (local->override_static->reference->tag & LIB_TAG_OVERRIDESTATIC_OK) == 0) {
577                 BKE_override_static_update(bmain, local->override_static->reference);
578         }
579
580         /* We want to avoid having to remap here, however creating up-to-date override is much simpler if based
581          * on reference than on current override.
582          * So we work on temp copy of reference, and 'swap' its content with local. */
583
584         /* XXX We need a way to get off-Main copies of IDs (similar to localized mats/texts/ etc.)!
585          *     However, this is whole bunch of code work in itself, so for now plain stupid ID copy will do,
586          *     as innefficient as it is. :/
587          *     Actually, maybe not! Since we are swapping with original ID's local content, we want to keep
588          *     usercount in correct state when freeing tmp_id (and that usercounts of IDs used by 'new' local data
589          *     also remain correct). */
590         /* This would imply change in handling of usercout all over RNA (and possibly all over Blender code).
591          * Not impossible to do, but would rather see first if extra useless usual user handling is actually
592          * a (performances) issue here. */
593
594         ID *tmp_id;
595         id_copy(bmain, local->override_static->reference, &tmp_id, false);
596
597         if (tmp_id == NULL) {
598                 return;
599         }
600
601         PointerRNA rnaptr_src, rnaptr_dst, rnaptr_storage_stack, *rnaptr_storage = NULL;
602         RNA_id_pointer_create(local, &rnaptr_src);
603         RNA_id_pointer_create(tmp_id, &rnaptr_dst);
604         if (local->override_static->storage) {
605                 rnaptr_storage = &rnaptr_storage_stack;
606                 RNA_id_pointer_create(local->override_static->storage, rnaptr_storage);
607         }
608
609         RNA_struct_override_apply(&rnaptr_dst, &rnaptr_src, rnaptr_storage, local->override_static);
610
611         /* This also transfers all pointers (memory) owned by local to tmp_id, and vice-versa. So when we'll free tmp_id,
612          * we'll actually free old, outdated data from local. */
613         BKE_id_swap(bmain, local, tmp_id);
614
615         /* Again, horribly innefficient in our case, we need something off-Main (aka moar generic nolib copy/free stuff)! */
616         /* XXX And crashing in complex cases (e.g. because depsgraph uses same data...). */
617         BKE_libblock_free_ex(bmain, tmp_id, true, false);
618
619         if (local->override_static->storage) {
620                 /* We know this datablock is not used anywhere besides local->override->storage. */
621                 /* XXX For until we get fully shadow copies, we still need to ensure storage releases
622                  *     its usage of any ID pointers it may have. */
623                 BKE_libblock_free_ex(bmain, local->override_static->storage, true, false);
624                 local->override_static->storage = NULL;
625         }
626
627         local->tag |= LIB_TAG_OVERRIDESTATIC_OK;
628
629         /* Full rebuild of Depsgraph! */
630         DEG_on_visible_update(bmain, true);  /* XXX Is this actual valid replacement for old DAG_relations_tag_update(bmain) ? */
631 }
632
633 /** Update all overrides from given \a bmain. */
634 void BKE_main_override_static_update(Main *bmain)
635 {
636         ListBase *lbarray[MAX_LIBARRAY];
637         int base_count, i;
638
639         base_count = set_listbasepointers(bmain, lbarray);
640
641         for (i = 0; i < base_count; i++) {
642                 ListBase *lb = lbarray[i];
643                 ID *id;
644
645                 for (id = lb->first; id; id = id->next) {
646                         if (id->override_static != NULL && id->lib == NULL) {
647                                 BKE_override_static_update(bmain, id);
648                         }
649                 }
650         }
651 }
652
653 /***********************************************************************************************************************
654  * Storage (how to wtore overriding data into .blend files).
655  *
656  * Basically:
657  * I) Only 'differential' storage needs special handling here. All others (replacing values or
658  *    inserting/removing items from a collection) can be handled with simply storing current content of local data-block.
659  * II) We store the differential value into a second 'ghost' data-block, which is an empty ID of same type as local one,
660  *     where we only define values that need differential data.
661  *
662  * This avoids us having to modify 'real' data-block at write time (and retoring it afterwards), which is inneficient,
663  * and potentially dangerous (in case of concurrent access...), while not using much extra memory in typical cases.
664  * It also ensures stored data-block always contains exact same data as "desired" ones (kind of "baked" data-blocks).
665  */
666
667 /** Initialize an override storage. */
668 OverrideStaticStorage *BKE_override_static_operations_store_initialize(void)
669 {
670         return BKE_main_new();
671 }
672
673 /**
674  * Generate suitable 'write' data (this only affects differential override operations).
675  *
676  * Note that \a local ID is no more modified by this call, all extra data are stored in its temp \a storage_id copy. */
677 ID *BKE_override_static_operations_store_start(OverrideStaticStorage *override_storage, ID *local)
678 {
679         BLI_assert(local->override_static != NULL);
680         BLI_assert(override_storage != NULL);
681         const bool is_template = (local->override_static->reference == NULL);
682
683         if (is_template) {
684                 /* This is actually purely local data with an override template, nothing to do here! */
685                 return NULL;
686         }
687
688         /* Forcefully ensure we know about all needed override operations. */
689         BKE_override_static_operations_create(local);
690
691         ID *storage_id;
692 #ifdef DEBUG_OVERRIDE_TIMEIT
693         TIMEIT_START_AVERAGED(BKE_override_operations_store_start);
694 #endif
695
696         /* XXX TODO We may also want a specialized handling of things here too, to avoid copying heavy never-overridable
697          *          data (like Mesh geometry etc.)? And also maybe avoid lib refcounting completely (shallow copy...). */
698         /* This would imply change in handling of usercout all over RNA (and possibly all over Blender code).
699          * Not impossible to do, but would rather see first is extra useless usual user handling is actually
700          * a (performances) issue here, before doing it. */
701         id_copy((Main *)override_storage, local, &storage_id, false);
702
703         if (storage_id != NULL) {
704                 PointerRNA rnaptr_reference, rnaptr_final, rnaptr_storage;
705                 RNA_id_pointer_create(local->override_static->reference, &rnaptr_reference);
706                 RNA_id_pointer_create(local, &rnaptr_final);
707                 RNA_id_pointer_create(storage_id, &rnaptr_storage);
708
709                 if (!RNA_struct_override_store(&rnaptr_final, &rnaptr_reference, &rnaptr_storage, local->override_static)) {
710                         BKE_libblock_free_ex(override_storage, storage_id, true, false);
711                         storage_id = NULL;
712                 }
713         }
714
715         local->override_static->storage = storage_id;
716
717 #ifdef DEBUG_OVERRIDE_TIMEIT
718         TIMEIT_END_AVERAGED(BKE_override_operations_store_start);
719 #endif
720         return storage_id;
721 }
722
723 /** Restore given ID modified by \a BKE_override_operations_store_start, to its original state. */
724 void BKE_override_static_operations_store_end(OverrideStaticStorage *UNUSED(override_storage), ID *local)
725 {
726         BLI_assert(local->override_static != NULL);
727
728         /* Nothing else to do here really, we need to keep all temp override storage data-blocks in memory until
729          * whole file is written anyway (otherwise we'd get mem pointers overlap...). */
730         local->override_static->storage = NULL;
731 }
732
733 void BKE_override_static_operations_store_finalize(OverrideStaticStorage *override_storage)
734 {
735         /* We cannot just call BKE_main_free(override_storage), not until we have option to make 'ghost' copies of IDs
736          * without increasing usercount of used data-blocks... */
737         ListBase *lbarray[MAX_LIBARRAY];
738         int base_count, i;
739
740         base_count = set_listbasepointers(override_storage, lbarray);
741
742         for (i = 0; i < base_count; i++) {
743                 ListBase *lb = lbarray[i];
744                 ID *id;
745
746                 while ((id = lb->first)) {
747                         BKE_libblock_free_ex(override_storage, id, true, false);
748                 }
749         }
750
751         BKE_main_free(override_storage);
752 }