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