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