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