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