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