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