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