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