GPencil: Change Trace tooltips
[blender.git] / source / blender / editors / object / object_relations.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edobj
22  */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "DNA_anim_types.h"
31 #include "DNA_armature_types.h"
32 #include "DNA_camera_types.h"
33 #include "DNA_collection_types.h"
34 #include "DNA_constraint_types.h"
35 #include "DNA_gpencil_types.h"
36 #include "DNA_key_types.h"
37 #include "DNA_lattice_types.h"
38 #include "DNA_light_types.h"
39 #include "DNA_material_types.h"
40 #include "DNA_mesh_types.h"
41 #include "DNA_meta_types.h"
42 #include "DNA_object_types.h"
43 #include "DNA_particle_types.h"
44 #include "DNA_scene_types.h"
45 #include "DNA_vfont_types.h"
46 #include "DNA_world_types.h"
47
48 #include "BLI_kdtree.h"
49 #include "BLI_linklist.h"
50 #include "BLI_listbase.h"
51 #include "BLI_math.h"
52 #include "BLI_string.h"
53 #include "BLI_utildefines.h"
54
55 #include "BLT_translation.h"
56
57 #include "BKE_DerivedMesh.h"
58 #include "BKE_action.h"
59 #include "BKE_anim_data.h"
60 #include "BKE_armature.h"
61 #include "BKE_camera.h"
62 #include "BKE_collection.h"
63 #include "BKE_constraint.h"
64 #include "BKE_context.h"
65 #include "BKE_curve.h"
66 #include "BKE_displist.h"
67 #include "BKE_editmesh.h"
68 #include "BKE_fcurve.h"
69 #include "BKE_gpencil.h"
70 #include "BKE_hair.h"
71 #include "BKE_idprop.h"
72 #include "BKE_idtype.h"
73 #include "BKE_lattice.h"
74 #include "BKE_layer.h"
75 #include "BKE_lib_id.h"
76 #include "BKE_lib_override.h"
77 #include "BKE_lib_query.h"
78 #include "BKE_lib_remap.h"
79 #include "BKE_light.h"
80 #include "BKE_lightprobe.h"
81 #include "BKE_main.h"
82 #include "BKE_material.h"
83 #include "BKE_mball.h"
84 #include "BKE_mesh.h"
85 #include "BKE_modifier.h"
86 #include "BKE_node.h"
87 #include "BKE_object.h"
88 #include "BKE_pointcloud.h"
89 #include "BKE_report.h"
90 #include "BKE_scene.h"
91 #include "BKE_speaker.h"
92 #include "BKE_texture.h"
93 #include "BKE_volume.h"
94
95 #include "DEG_depsgraph.h"
96 #include "DEG_depsgraph_build.h"
97 #include "DEG_depsgraph_query.h"
98
99 #include "WM_api.h"
100 #include "WM_types.h"
101
102 #include "UI_interface.h"
103 #include "UI_resources.h"
104
105 #include "RNA_access.h"
106 #include "RNA_define.h"
107 #include "RNA_enum_types.h"
108
109 #include "ED_armature.h"
110 #include "ED_curve.h"
111 #include "ED_gpencil.h"
112 #include "ED_keyframing.h"
113 #include "ED_mesh.h"
114 #include "ED_object.h"
115 #include "ED_screen.h"
116 #include "ED_view3d.h"
117
118 #include "object_intern.h"
119
120 /* ------------------------------------------------------------------- */
121 /** \name Make Vertex Parent Operator
122  * \{ */
123
124 static bool vertex_parent_set_poll(bContext *C)
125 {
126   return ED_operator_editmesh(C) || ED_operator_editsurfcurve(C) || ED_operator_editlattice(C);
127 }
128
129 static int vertex_parent_set_exec(bContext *C, wmOperator *op)
130 {
131   Main *bmain = CTX_data_main(C);
132   Scene *scene = CTX_data_scene(C);
133   View3D *v3d = CTX_wm_view3d(C);
134   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
135   ViewLayer *view_layer = CTX_data_view_layer(C);
136   Object *obedit = CTX_data_edit_object(C);
137   Object *par;
138
139 #define INDEX_UNSET -1
140   int par1, par2, par3, par4;
141   par1 = par2 = par3 = par4 = INDEX_UNSET;
142
143   /* we need 1 to 3 selected vertices */
144
145   if (obedit->type == OB_MESH) {
146     Mesh *me = obedit->data;
147     BMEditMesh *em;
148
149     EDBM_mesh_load(bmain, obedit);
150     EDBM_mesh_make(obedit, scene->toolsettings->selectmode, true);
151
152     DEG_id_tag_update(obedit->data, 0);
153
154     em = me->edit_mesh;
155
156     EDBM_mesh_normals_update(em);
157     BKE_editmesh_looptri_calc(em);
158
159     /* Make sure the evaluated mesh is updated.
160      *
161      * Most reliable way is to update the tagged objects, which will ensure
162      * proper copy-on-write update, but also will make sure all dependent
163      * objects are also up to date. */
164     BKE_scene_graph_update_tagged(depsgraph, bmain);
165
166     BMVert *eve;
167     BMIter iter;
168     int curr_index;
169     BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, curr_index) {
170       if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
171         if (par1 == INDEX_UNSET) {
172           par1 = curr_index;
173         }
174         else if (par2 == INDEX_UNSET) {
175           par2 = curr_index;
176         }
177         else if (par3 == INDEX_UNSET) {
178           par3 = curr_index;
179         }
180         else if (par4 == INDEX_UNSET) {
181           par4 = curr_index;
182         }
183         else {
184           break;
185         }
186       }
187     }
188   }
189   else if (ELEM(obedit->type, OB_SURF, OB_CURVE)) {
190     ListBase *editnurb = object_editcurve_get(obedit);
191
192     for (Nurb *nu = editnurb->first; nu != NULL; nu = nu->next) {
193       if (nu->type == CU_BEZIER) {
194         BezTriple *bezt = nu->bezt;
195         for (int curr_index = 0; curr_index < nu->pntsu; curr_index++, bezt++) {
196           if (BEZT_ISSEL_ANY_HIDDENHANDLES(v3d, bezt)) {
197             if (par1 == INDEX_UNSET) {
198               par1 = curr_index;
199             }
200             else if (par2 == INDEX_UNSET) {
201               par2 = curr_index;
202             }
203             else if (par3 == INDEX_UNSET) {
204               par3 = curr_index;
205             }
206             else if (par4 == INDEX_UNSET) {
207               par4 = curr_index;
208             }
209             else {
210               break;
211             }
212           }
213         }
214       }
215       else {
216         BPoint *bp = nu->bp;
217         const int num_points = nu->pntsu * nu->pntsv;
218         for (int curr_index = 0; curr_index < num_points; curr_index++, bp++) {
219           if (bp->f1 & SELECT) {
220             if (par1 == INDEX_UNSET) {
221               par1 = curr_index;
222             }
223             else if (par2 == INDEX_UNSET) {
224               par2 = curr_index;
225             }
226             else if (par3 == INDEX_UNSET) {
227               par3 = curr_index;
228             }
229             else if (par4 == INDEX_UNSET) {
230               par4 = curr_index;
231             }
232             else {
233               break;
234             }
235           }
236         }
237       }
238     }
239   }
240   else if (obedit->type == OB_LATTICE) {
241     Lattice *lt = obedit->data;
242
243     const int num_points = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv *
244                            lt->editlatt->latt->pntsw;
245     BPoint *bp = lt->editlatt->latt->def;
246     for (int curr_index = 0; curr_index < num_points; curr_index++, bp++) {
247       if (bp->f1 & SELECT) {
248         if (par1 == INDEX_UNSET) {
249           par1 = curr_index;
250         }
251         else if (par2 == INDEX_UNSET) {
252           par2 = curr_index;
253         }
254         else if (par3 == INDEX_UNSET) {
255           par3 = curr_index;
256         }
257         else if (par4 == INDEX_UNSET) {
258           par4 = curr_index;
259         }
260         else {
261           break;
262         }
263       }
264     }
265   }
266
267   if (par4 != INDEX_UNSET || par1 == INDEX_UNSET || (par2 != INDEX_UNSET && par3 == INDEX_UNSET)) {
268     BKE_report(op->reports, RPT_ERROR, "Select either 1 or 3 vertices to parent to");
269     return OPERATOR_CANCELLED;
270   }
271
272   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
273     if (ob != obedit) {
274       DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
275       par = obedit->parent;
276
277       if (BKE_object_parent_loop_check(par, ob)) {
278         BKE_report(op->reports, RPT_ERROR, "Loop in parents");
279       }
280       else {
281         Object workob;
282
283         ob->parent = BASACT(view_layer)->object;
284         if (par3 != INDEX_UNSET) {
285           ob->partype = PARVERT3;
286           ob->par1 = par1;
287           ob->par2 = par2;
288           ob->par3 = par3;
289
290           /* inverse parent matrix */
291           BKE_object_workob_calc_parent(depsgraph, scene, ob, &workob);
292           invert_m4_m4(ob->parentinv, workob.obmat);
293         }
294         else {
295           ob->partype = PARVERT1;
296           ob->par1 = par1;
297
298           /* inverse parent matrix */
299           BKE_object_workob_calc_parent(depsgraph, scene, ob, &workob);
300           invert_m4_m4(ob->parentinv, workob.obmat);
301         }
302       }
303     }
304   }
305   CTX_DATA_END;
306
307   DEG_relations_tag_update(bmain);
308
309   WM_event_add_notifier(C, NC_OBJECT, NULL);
310
311   return OPERATOR_FINISHED;
312
313 #undef INDEX_UNSET
314 }
315
316 void OBJECT_OT_vertex_parent_set(wmOperatorType *ot)
317 {
318   /* identifiers */
319   ot->name = "Make Vertex Parent";
320   ot->description = "Parent selected objects to the selected vertices";
321   ot->idname = "OBJECT_OT_vertex_parent_set";
322
323   /* api callbacks */
324   ot->invoke = WM_operator_confirm;
325   ot->poll = vertex_parent_set_poll;
326   ot->exec = vertex_parent_set_exec;
327
328   /* flags */
329   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
330 }
331
332 /** \} */
333
334 /* ------------------------------------------------------------------- */
335 /** \name Make Proxy Operator
336  * \{ */
337
338 /* set the object to proxify */
339 static int make_proxy_invoke(bContext *C, wmOperator *op, const wmEvent *event)
340 {
341   Scene *scene = CTX_data_scene(C);
342   Object *ob = ED_object_active_context(C);
343
344   /* sanity checks */
345   if (!scene || ID_IS_LINKED(scene) || !ob) {
346     return OPERATOR_CANCELLED;
347   }
348
349   /* Get object to work on - use a menu if we need to... */
350   if (ob->instance_collection && ID_IS_LINKED(ob->instance_collection)) {
351     /* gives menu with list of objects in group */
352     /* proxy_group_objects_menu(C, op, ob, ob->instance_collection); */
353     WM_enum_search_invoke(C, op, event);
354     return OPERATOR_CANCELLED;
355   }
356   if (ID_IS_LINKED(ob)) {
357     uiPopupMenu *pup = UI_popup_menu_begin(C, IFACE_("OK?"), ICON_QUESTION);
358     uiLayout *layout = UI_popup_menu_layout(pup);
359
360     /* create operator menu item with relevant properties filled in */
361     PointerRNA opptr_dummy;
362     uiItemFullO_ptr(
363         layout, op->type, op->type->name, ICON_NONE, NULL, WM_OP_EXEC_REGION_WIN, 0, &opptr_dummy);
364
365     /* present the menu and be done... */
366     UI_popup_menu_end(C, pup);
367
368     /* this invoke just calls another instance of this operator... */
369     return OPERATOR_INTERFACE;
370   }
371
372   /* error.. cannot continue */
373   BKE_report(op->reports, RPT_ERROR, "Can only make proxy for a referenced object or collection");
374   return OPERATOR_CANCELLED;
375 }
376
377 static int make_proxy_exec(bContext *C, wmOperator *op)
378 {
379   Main *bmain = CTX_data_main(C);
380   Object *ob, *gob = ED_object_active_context(C);
381   Scene *scene = CTX_data_scene(C);
382   ViewLayer *view_layer = CTX_data_view_layer(C);
383
384   if (gob->instance_collection != NULL) {
385     const ListBase instance_collection_objects = BKE_collection_object_cache_get(
386         gob->instance_collection);
387     Base *base = BLI_findlink(&instance_collection_objects, RNA_enum_get(op->ptr, "object"));
388     ob = base->object;
389   }
390   else {
391     ob = gob;
392     gob = NULL;
393   }
394
395   if (ob) {
396     Object *newob;
397     char name[MAX_ID_NAME + 4];
398
399     BLI_snprintf(name, sizeof(name), "%s_proxy", ((ID *)(gob ? gob : ob))->name + 2);
400
401     /* Add new object for the proxy */
402     newob = BKE_object_add_from(bmain, scene, view_layer, OB_EMPTY, name, gob ? gob : ob);
403
404     /* set layers OK */
405     BKE_object_make_proxy(bmain, newob, ob, gob);
406
407     /* Set back pointer immediately so dependency graph knows that this is
408      * is a proxy and will act accordingly. Otherwise correctness of graph
409      * will depend on order of bases.
410      *
411      * TODO(sergey): We really need to get rid of this bi-directional links
412      * in proxies with something like library overrides.
413      */
414     if (newob->proxy != NULL) {
415       newob->proxy->proxy_from = newob;
416     }
417     else {
418       BKE_report(op->reports, RPT_ERROR, "Unable to assign proxy");
419     }
420
421     /* depsgraph flushes are needed for the new data */
422     DEG_relations_tag_update(bmain);
423     DEG_id_tag_update(&newob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
424     WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, newob);
425   }
426   else {
427     BKE_report(op->reports, RPT_ERROR, "No object to make proxy for");
428     return OPERATOR_CANCELLED;
429   }
430
431   return OPERATOR_FINISHED;
432 }
433
434 /* Generic itemf's for operators that take library args */
435 static const EnumPropertyItem *proxy_collection_object_itemf(bContext *C,
436                                                              PointerRNA *UNUSED(ptr),
437                                                              PropertyRNA *UNUSED(prop),
438                                                              bool *r_free)
439 {
440   EnumPropertyItem item_tmp = {0}, *item = NULL;
441   int totitem = 0;
442   int i = 0;
443   Object *ob = ED_object_active_context(C);
444
445   if (!ob || !ob->instance_collection) {
446     return DummyRNA_DEFAULT_items;
447   }
448
449   /* find the object to affect */
450   FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (ob->instance_collection, object) {
451     item_tmp.identifier = item_tmp.name = object->id.name + 2;
452     item_tmp.value = i++;
453     RNA_enum_item_add(&item, &totitem, &item_tmp);
454   }
455   FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
456
457   RNA_enum_item_end(&item, &totitem);
458   *r_free = true;
459
460   return item;
461 }
462
463 void OBJECT_OT_proxy_make(wmOperatorType *ot)
464 {
465   PropertyRNA *prop;
466
467   /* identifiers */
468   ot->name = "Make Proxy";
469   ot->idname = "OBJECT_OT_proxy_make";
470   ot->description = "Add empty object to become local replacement data of a library-linked object";
471
472   /* callbacks */
473   ot->invoke = make_proxy_invoke;
474   ot->exec = make_proxy_exec;
475   ot->poll = ED_operator_object_active;
476
477   /* flags */
478   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
479
480   /* properties */
481   /* XXX, relies on hard coded ID at the moment */
482   prop = RNA_def_enum(ot->srna,
483                       "object",
484                       DummyRNA_DEFAULT_items,
485                       0,
486                       "Proxy Object",
487                       "Name of lib-linked/collection object to make a proxy for");
488   RNA_def_enum_funcs(prop, proxy_collection_object_itemf);
489   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
490   ot->prop = prop;
491 }
492
493 /** \} */
494
495 /* ------------------------------------------------------------------- */
496 /** \name Clear Parent Operator
497  * \{ */
498
499 EnumPropertyItem prop_clear_parent_types[] = {
500     {CLEAR_PARENT_ALL,
501      "CLEAR",
502      0,
503      "Clear Parent",
504      "Completely clear the parenting relationship, including involved modifiers if any"},
505     {CLEAR_PARENT_KEEP_TRANSFORM,
506      "CLEAR_KEEP_TRANSFORM",
507      0,
508      "Clear and Keep Transformation",
509      "As 'Clear Parent', but keep the current visual transformations of the object"},
510     {CLEAR_PARENT_INVERSE,
511      "CLEAR_INVERSE",
512      0,
513      "Clear Parent Inverse",
514      "Reset the transform corrections applied to the parenting relationship, does not remove "
515      "parenting itself"},
516     {0, NULL, 0, NULL, NULL},
517 };
518
519 /* Helper for ED_object_parent_clear() - Remove deform-modifiers associated with parent */
520 static void object_remove_parent_deform_modifiers(Object *ob, const Object *par)
521 {
522   if (ELEM(par->type, OB_ARMATURE, OB_LATTICE, OB_CURVE)) {
523     ModifierData *md, *mdn;
524
525     /* assume that we only need to remove the first instance of matching deform modifier here */
526     for (md = ob->modifiers.first; md; md = mdn) {
527       bool free = false;
528
529       mdn = md->next;
530
531       /* need to match types (modifier + parent) and references */
532       if ((md->type == eModifierType_Armature) && (par->type == OB_ARMATURE)) {
533         ArmatureModifierData *amd = (ArmatureModifierData *)md;
534         if (amd->object == par) {
535           free = true;
536         }
537       }
538       else if ((md->type == eModifierType_Lattice) && (par->type == OB_LATTICE)) {
539         LatticeModifierData *lmd = (LatticeModifierData *)md;
540         if (lmd->object == par) {
541           free = true;
542         }
543       }
544       else if ((md->type == eModifierType_Curve) && (par->type == OB_CURVE)) {
545         CurveModifierData *cmd = (CurveModifierData *)md;
546         if (cmd->object == par) {
547           free = true;
548         }
549       }
550
551       /* free modifier if match */
552       if (free) {
553         BLI_remlink(&ob->modifiers, md);
554         BKE_modifier_free(md);
555       }
556     }
557   }
558 }
559
560 void ED_object_parent_clear(Object *ob, const int type)
561 {
562   if (ob->parent == NULL) {
563     return;
564   }
565
566   switch (type) {
567     case CLEAR_PARENT_ALL: {
568       /* for deformers, remove corresponding modifiers to prevent
569        * a large number of modifiers building up */
570       object_remove_parent_deform_modifiers(ob, ob->parent);
571
572       /* clear parenting relationship completely */
573       ob->parent = NULL;
574       break;
575     }
576     case CLEAR_PARENT_KEEP_TRANSFORM: {
577       /* remove parent, and apply the parented transform
578        * result as object's local transforms */
579       ob->parent = NULL;
580       BKE_object_apply_mat4(ob, ob->obmat, true, false);
581       break;
582     }
583     case CLEAR_PARENT_INVERSE: {
584       /* object stays parented, but the parent inverse
585        * (i.e. offset from parent to retain binding state)
586        * is cleared. In other words: nothing to do here! */
587       break;
588     }
589   }
590
591   /* Always clear parentinv matrix for sake of consistency, see T41950. */
592   unit_m4(ob->parentinv);
593
594   DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
595 }
596
597 /* note, poll should check for editable scene */
598 static int parent_clear_exec(bContext *C, wmOperator *op)
599 {
600   Main *bmain = CTX_data_main(C);
601   const int type = RNA_enum_get(op->ptr, "type");
602
603   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
604     ED_object_parent_clear(ob, type);
605   }
606   CTX_DATA_END;
607
608   DEG_relations_tag_update(bmain);
609   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
610   WM_event_add_notifier(C, NC_OBJECT | ND_PARENT, NULL);
611   return OPERATOR_FINISHED;
612 }
613
614 void OBJECT_OT_parent_clear(wmOperatorType *ot)
615 {
616   /* identifiers */
617   ot->name = "Clear Parent";
618   ot->description = "Clear the object's parenting";
619   ot->idname = "OBJECT_OT_parent_clear";
620
621   /* api callbacks */
622   ot->invoke = WM_menu_invoke;
623   ot->exec = parent_clear_exec;
624
625   /* flags */
626   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
627
628   ot->prop = RNA_def_enum(ot->srna, "type", prop_clear_parent_types, CLEAR_PARENT_ALL, "Type", "");
629 }
630
631 /** \} */
632
633 /* ------------------------------------------------------------------- */
634 /** \name Make Parent Operator
635  * \{ */
636
637 void ED_object_parent(Object *ob, Object *par, const int type, const char *substr)
638 {
639   /* Always clear parentinv matrix for sake of consistency, see T41950. */
640   unit_m4(ob->parentinv);
641
642   if (!par || BKE_object_parent_loop_check(par, ob)) {
643     ob->parent = NULL;
644     ob->partype = PAROBJECT;
645     ob->parsubstr[0] = 0;
646     return;
647   }
648
649   /* Other partypes are deprecated, do not use here! */
650   BLI_assert(ELEM(type & PARTYPE, PAROBJECT, PARSKEL, PARVERT1, PARVERT3, PARBONE));
651
652   /* this could use some more checks */
653
654   ob->parent = par;
655   ob->partype &= ~PARTYPE;
656   ob->partype |= type;
657   BLI_strncpy(ob->parsubstr, substr, sizeof(ob->parsubstr));
658 }
659
660 /* Operator Property */
661 EnumPropertyItem prop_make_parent_types[] = {
662     {PAR_OBJECT, "OBJECT", 0, "Object", ""},
663     {PAR_ARMATURE, "ARMATURE", 0, "Armature Deform", ""},
664     {PAR_ARMATURE_NAME, "ARMATURE_NAME", 0, "   With Empty Groups", ""},
665     {PAR_ARMATURE_AUTO, "ARMATURE_AUTO", 0, "   With Automatic Weights", ""},
666     {PAR_ARMATURE_ENVELOPE, "ARMATURE_ENVELOPE", 0, "   With Envelope Weights", ""},
667     {PAR_BONE, "BONE", 0, "Bone", ""},
668     {PAR_BONE_RELATIVE, "BONE_RELATIVE", 0, "Bone Relative", ""},
669     {PAR_CURVE, "CURVE", 0, "Curve Deform", ""},
670     {PAR_FOLLOW, "FOLLOW", 0, "Follow Path", ""},
671     {PAR_PATH_CONST, "PATH_CONST", 0, "Path Constraint", ""},
672     {PAR_LATTICE, "LATTICE", 0, "Lattice Deform", ""},
673     {PAR_VERTEX, "VERTEX", 0, "Vertex", ""},
674     {PAR_VERTEX_TRI, "VERTEX_TRI", 0, "Vertex (Triangle)", ""},
675     {0, NULL, 0, NULL, NULL},
676 };
677
678 bool ED_object_parent_set(ReportList *reports,
679                           const bContext *C,
680                           Scene *scene,
681                           Object *const ob,
682                           Object *const par,
683                           int partype,
684                           const bool xmirror,
685                           const bool keep_transform,
686                           const int vert_par[3])
687 {
688   Main *bmain = CTX_data_main(C);
689   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
690   bPoseChannel *pchan = NULL;
691   bPoseChannel *pchan_eval = NULL;
692   Object *parent_eval = DEG_get_evaluated_object(depsgraph, par);
693
694   DEG_id_tag_update(&par->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
695
696   /* Preconditions. */
697   if (ob == par) {
698     /* Parenting an object to itself is impossible. */
699     return true;
700   }
701
702   if (BKE_object_parent_loop_check(par, ob)) {
703     BKE_report(reports, RPT_ERROR, "Loop in parents");
704     return false;
705   }
706
707   switch (partype) {
708     case PAR_FOLLOW:
709     case PAR_PATH_CONST: {
710       if (par->type != OB_CURVE) {
711         return false;
712       }
713       Curve *cu = par->data;
714       Curve *cu_eval = parent_eval->data;
715       if ((cu->flag & CU_PATH) == 0) {
716         cu->flag |= CU_PATH | CU_FOLLOW;
717         cu_eval->flag |= CU_PATH | CU_FOLLOW;
718         /* force creation of path data */
719         BKE_displist_make_curveTypes(depsgraph, scene, par, false, false);
720       }
721       else {
722         cu->flag |= CU_FOLLOW;
723         cu_eval->flag |= CU_FOLLOW;
724       }
725
726       /* if follow, add F-Curve for ctime (i.e. "eval_time") so that path-follow works */
727       if (partype == PAR_FOLLOW) {
728         /* get or create F-Curve */
729         bAction *act = ED_id_action_ensure(bmain, &cu->id);
730         FCurve *fcu = ED_action_fcurve_ensure(bmain, act, NULL, NULL, "eval_time", 0);
731
732         /* setup dummy 'generator' modifier here to get 1-1 correspondence still working */
733         if (!fcu->bezt && !fcu->fpt && !fcu->modifiers.first) {
734           add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_GENERATOR, fcu);
735         }
736       }
737
738       /* fall back on regular parenting now (for follow only) */
739       if (partype == PAR_FOLLOW) {
740         partype = PAR_OBJECT;
741       }
742       break;
743     }
744     case PAR_BONE:
745     case PAR_BONE_RELATIVE:
746       pchan = BKE_pose_channel_active(par);
747       pchan_eval = BKE_pose_channel_active(parent_eval);
748
749       if (pchan == NULL) {
750         BKE_report(reports, RPT_ERROR, "No active bone");
751         return false;
752       }
753   }
754
755   Object workob;
756
757   /* Apply transformation of previous parenting. */
758   if (keep_transform) {
759     /* Was removed because of bug T23577,
760      * but this can be handy in some cases too T32616, so make optional. */
761     BKE_object_apply_mat4(ob, ob->obmat, false, false);
762   }
763
764   /* Set the parent (except for follow-path constraint option). */
765   if (partype != PAR_PATH_CONST) {
766     ob->parent = par;
767     /* Always clear parentinv matrix for sake of consistency, see T41950. */
768     unit_m4(ob->parentinv);
769     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
770   }
771
772   /* Handle types. */
773   if (pchan) {
774     BLI_strncpy(ob->parsubstr, pchan->name, sizeof(ob->parsubstr));
775   }
776   else {
777     ob->parsubstr[0] = 0;
778   }
779
780   switch (partype) {
781     case PAR_PATH_CONST:
782       /* Don't do anything here, since this is not technically "parenting". */
783       break;
784     case PAR_CURVE:
785     case PAR_LATTICE:
786     case PAR_ARMATURE:
787     case PAR_ARMATURE_NAME:
788     case PAR_ARMATURE_ENVELOPE:
789     case PAR_ARMATURE_AUTO:
790       /* partype is now set to PAROBJECT so that invisible 'virtual'
791        * modifiers don't need to be created.
792        * NOTE: the old (2.4x) method was to set ob->partype = PARSKEL,
793        * creating the virtual modifiers.
794        */
795       ob->partype = PAROBJECT;     /* Note: DNA define, not operator property. */
796       /* ob->partype = PARSKEL; */ /* Note: DNA define, not operator property. */
797
798       /* BUT, to keep the deforms, we need a modifier,
799        * and then we need to set the object that it uses
800        * - We need to ensure that the modifier we're adding doesn't already exist,
801        *   so we check this by assuming that the parent is selected too.
802        */
803       /* XXX currently this should only happen for meshes, curves, surfaces,
804        * and lattices - this stuff isn't available for metas yet */
805       if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_LATTICE)) {
806         ModifierData *md;
807
808         switch (partype) {
809           case PAR_CURVE: /* curve deform */
810             if (BKE_modifiers_is_deformed_by_curve(ob) != par) {
811               md = ED_object_modifier_add(reports, bmain, scene, ob, NULL, eModifierType_Curve);
812               if (md) {
813                 ((CurveModifierData *)md)->object = par;
814               }
815               if (par->runtime.curve_cache && par->runtime.curve_cache->path == NULL) {
816                 DEG_id_tag_update(&par->id, ID_RECALC_GEOMETRY);
817               }
818             }
819             break;
820           case PAR_LATTICE: /* lattice deform */
821             if (BKE_modifiers_is_deformed_by_lattice(ob) != par) {
822               md = ED_object_modifier_add(reports, bmain, scene, ob, NULL, eModifierType_Lattice);
823               if (md) {
824                 ((LatticeModifierData *)md)->object = par;
825               }
826             }
827             break;
828           default: /* armature deform */
829             if (BKE_modifiers_is_deformed_by_armature(ob) != par) {
830               md = ED_object_modifier_add(reports, bmain, scene, ob, NULL, eModifierType_Armature);
831               if (md) {
832                 ((ArmatureModifierData *)md)->object = par;
833               }
834             }
835             break;
836         }
837       }
838       break;
839     case PAR_BONE:
840       ob->partype = PARBONE; /* Note: DNA define, not operator property. */
841       if (pchan->bone) {
842         pchan->bone->flag &= ~BONE_RELATIVE_PARENTING;
843         pchan_eval->bone->flag &= ~BONE_RELATIVE_PARENTING;
844       }
845       break;
846     case PAR_BONE_RELATIVE:
847       ob->partype = PARBONE; /* Note: DNA define, not operator property. */
848       if (pchan->bone) {
849         pchan->bone->flag |= BONE_RELATIVE_PARENTING;
850         pchan_eval->bone->flag |= BONE_RELATIVE_PARENTING;
851       }
852       break;
853     case PAR_VERTEX:
854       ob->partype = PARVERT1;
855       ob->par1 = vert_par[0];
856       break;
857     case PAR_VERTEX_TRI:
858       ob->partype = PARVERT3;
859       copy_v3_v3_int(&ob->par1, vert_par);
860       break;
861     case PAR_OBJECT:
862     case PAR_FOLLOW:
863       ob->partype = PAROBJECT; /* Note: DNA define, not operator property. */
864       break;
865   }
866
867   /* Constraint and set parent inverse. */
868   const bool is_armature_parent = ELEM(
869       partype, PAR_ARMATURE, PAR_ARMATURE_NAME, PAR_ARMATURE_ENVELOPE, PAR_ARMATURE_AUTO);
870   if (partype == PAR_PATH_CONST) {
871     bConstraint *con;
872     bFollowPathConstraint *data;
873     float cmat[4][4], vec[3];
874
875     con = BKE_constraint_add_for_object(ob, "AutoPath", CONSTRAINT_TYPE_FOLLOWPATH);
876
877     data = con->data;
878     data->tar = par;
879
880     BKE_constraint_target_matrix_get(
881         depsgraph, scene, con, 0, CONSTRAINT_OBTYPE_OBJECT, NULL, cmat, scene->r.cfra);
882     sub_v3_v3v3(vec, ob->obmat[3], cmat[3]);
883
884     copy_v3_v3(ob->loc, vec);
885   }
886   else if (is_armature_parent && (ob->type == OB_MESH) && (par->type == OB_ARMATURE)) {
887     if (partype == PAR_ARMATURE_NAME) {
888       ED_object_vgroup_calc_from_armature(
889           reports, depsgraph, scene, ob, par, ARM_GROUPS_NAME, false);
890     }
891     else if (partype == PAR_ARMATURE_ENVELOPE) {
892       ED_object_vgroup_calc_from_armature(
893           reports, depsgraph, scene, ob, par, ARM_GROUPS_ENVELOPE, xmirror);
894     }
895     else if (partype == PAR_ARMATURE_AUTO) {
896       WM_cursor_wait(1);
897       ED_object_vgroup_calc_from_armature(
898           reports, depsgraph, scene, ob, par, ARM_GROUPS_AUTO, xmirror);
899       WM_cursor_wait(0);
900     }
901     /* get corrected inverse */
902     ob->partype = PAROBJECT;
903     BKE_object_workob_calc_parent(depsgraph, scene, ob, &workob);
904
905     invert_m4_m4(ob->parentinv, workob.obmat);
906   }
907   else if (is_armature_parent && (ob->type == OB_GPENCIL) && (par->type == OB_ARMATURE)) {
908     if (partype == PAR_ARMATURE) {
909       ED_gpencil_add_armature(C, reports, ob, par);
910     }
911     else if (partype == PAR_ARMATURE_NAME) {
912       ED_gpencil_add_armature_weights(C, reports, ob, par, GP_PAR_ARMATURE_NAME);
913     }
914     else if ((partype == PAR_ARMATURE_AUTO) || (partype == PAR_ARMATURE_ENVELOPE)) {
915       WM_cursor_wait(1);
916       ED_gpencil_add_armature_weights(C, reports, ob, par, GP_PAR_ARMATURE_AUTO);
917       WM_cursor_wait(0);
918     }
919     /* get corrected inverse */
920     ob->partype = PAROBJECT;
921     BKE_object_workob_calc_parent(depsgraph, scene, ob, &workob);
922
923     invert_m4_m4(ob->parentinv, workob.obmat);
924   }
925   else if ((ob->type == OB_GPENCIL) && (par->type == OB_LATTICE)) {
926     /* Add Lattice modifier */
927     if (partype == PAR_LATTICE) {
928       ED_gpencil_add_lattice_modifier(C, reports, ob, par);
929     }
930     /* get corrected inverse */
931     ob->partype = PAROBJECT;
932     BKE_object_workob_calc_parent(depsgraph, scene, ob, &workob);
933
934     invert_m4_m4(ob->parentinv, workob.obmat);
935   }
936   else {
937     /* calculate inverse parent matrix */
938     BKE_object_workob_calc_parent(depsgraph, scene, ob, &workob);
939     invert_m4_m4(ob->parentinv, workob.obmat);
940   }
941
942   DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
943   return true;
944 }
945
946 static void parent_set_vert_find(KDTree_3d *tree, Object *child, int vert_par[3], bool is_tri)
947 {
948   const float *co_find = child->obmat[3];
949   if (is_tri) {
950     KDTreeNearest_3d nearest[3];
951     int tot;
952
953     tot = BLI_kdtree_3d_find_nearest_n(tree, co_find, nearest, 3);
954     BLI_assert(tot == 3);
955     UNUSED_VARS(tot);
956
957     vert_par[0] = nearest[0].index;
958     vert_par[1] = nearest[1].index;
959     vert_par[2] = nearest[2].index;
960
961     BLI_assert(min_iii(UNPACK3(vert_par)) >= 0);
962   }
963   else {
964     vert_par[0] = BLI_kdtree_3d_find_nearest(tree, co_find, NULL);
965     BLI_assert(vert_par[0] >= 0);
966     vert_par[1] = 0;
967     vert_par[2] = 0;
968   }
969 }
970
971 struct ParentingContext {
972   ReportList *reports;
973   Scene *scene;
974   Object *par;
975   int partype;
976   bool is_vertex_tri;
977   bool xmirror;
978   bool keep_transform;
979 };
980
981 static bool parent_set_nonvertex_parent(bContext *C, struct ParentingContext *parenting_context)
982 {
983   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
984     if (!ED_object_parent_set(parenting_context->reports,
985                               C,
986                               parenting_context->scene,
987                               ob,
988                               parenting_context->par,
989                               parenting_context->partype,
990                               parenting_context->xmirror,
991                               parenting_context->keep_transform,
992                               NULL)) {
993       return false;
994     }
995   }
996   CTX_DATA_END;
997
998   return true;
999 }
1000
1001 static bool parent_set_vertex_parent_with_kdtree(bContext *C,
1002                                                  struct ParentingContext *parenting_context,
1003                                                  struct KDTree_3d *tree)
1004 {
1005   int vert_par[3] = {0, 0, 0};
1006
1007   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1008     parent_set_vert_find(tree, ob, vert_par, parenting_context->is_vertex_tri);
1009     if (!ED_object_parent_set(parenting_context->reports,
1010                               C,
1011                               parenting_context->scene,
1012                               ob,
1013                               parenting_context->par,
1014                               parenting_context->partype,
1015                               parenting_context->xmirror,
1016                               parenting_context->keep_transform,
1017                               vert_par)) {
1018       return false;
1019     }
1020   }
1021   CTX_DATA_END;
1022   return true;
1023 }
1024
1025 static bool parent_set_vertex_parent(bContext *C, struct ParentingContext *parenting_context)
1026 {
1027   struct KDTree_3d *tree = NULL;
1028   int tree_tot;
1029
1030   tree = BKE_object_as_kdtree(parenting_context->par, &tree_tot);
1031   BLI_assert(tree != NULL);
1032
1033   if (tree_tot < (parenting_context->is_vertex_tri ? 3 : 1)) {
1034     BKE_report(parenting_context->reports, RPT_ERROR, "Not enough vertices for vertex-parent");
1035     BLI_kdtree_3d_free(tree);
1036     return false;
1037   }
1038
1039   const bool ok = parent_set_vertex_parent_with_kdtree(C, parenting_context, tree);
1040   BLI_kdtree_3d_free(tree);
1041   return ok;
1042 }
1043
1044 static int parent_set_exec(bContext *C, wmOperator *op)
1045 {
1046   const int partype = RNA_enum_get(op->ptr, "type");
1047   struct ParentingContext parenting_context = {
1048       .reports = op->reports,
1049       .scene = CTX_data_scene(C),
1050       .par = ED_object_active_context(C),
1051       .partype = partype,
1052       .is_vertex_tri = partype == PAR_VERTEX_TRI,
1053       .xmirror = RNA_boolean_get(op->ptr, "xmirror"),
1054       .keep_transform = RNA_boolean_get(op->ptr, "keep_transform"),
1055   };
1056
1057   bool ok;
1058   if (ELEM(parenting_context.partype, PAR_VERTEX, PAR_VERTEX_TRI)) {
1059     ok = parent_set_vertex_parent(C, &parenting_context);
1060   }
1061   else {
1062     ok = parent_set_nonvertex_parent(C, &parenting_context);
1063   }
1064   if (!ok) {
1065     return OPERATOR_CANCELLED;
1066   }
1067
1068   Main *bmain = CTX_data_main(C);
1069   DEG_relations_tag_update(bmain);
1070   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
1071   WM_event_add_notifier(C, NC_OBJECT | ND_PARENT, NULL);
1072
1073   return OPERATOR_FINISHED;
1074 }
1075
1076 static int parent_set_invoke_menu(bContext *C, wmOperatorType *ot)
1077 {
1078   Object *parent = ED_object_active_context(C);
1079   uiPopupMenu *pup = UI_popup_menu_begin(C, IFACE_("Set Parent To"), ICON_NONE);
1080   uiLayout *layout = UI_popup_menu_layout(pup);
1081
1082   PointerRNA opptr;
1083 #if 0
1084   uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_OBJECT);
1085 #else
1086   uiItemFullO_ptr(layout, ot, IFACE_("Object"), ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &opptr);
1087   RNA_enum_set(&opptr, "type", PAR_OBJECT);
1088   RNA_boolean_set(&opptr, "keep_transform", false);
1089
1090   uiItemFullO_ptr(layout,
1091                   ot,
1092                   IFACE_("Object (Keep Transform)"),
1093                   ICON_NONE,
1094                   NULL,
1095                   WM_OP_EXEC_DEFAULT,
1096                   0,
1097                   &opptr);
1098   RNA_enum_set(&opptr, "type", PAR_OBJECT);
1099   RNA_boolean_set(&opptr, "keep_transform", true);
1100 #endif
1101
1102   uiItemO(
1103       layout, IFACE_("Object (Without Inverse)"), ICON_NONE, "OBJECT_OT_parent_no_inverse_set");
1104
1105   struct {
1106     bool mesh, gpencil;
1107   } has_children_of_type = {0};
1108
1109   CTX_DATA_BEGIN (C, Object *, child, selected_editable_objects) {
1110     if (child == parent) {
1111       continue;
1112     }
1113     if (child->type == OB_MESH) {
1114       has_children_of_type.mesh = true;
1115     }
1116     if (child->type == OB_GPENCIL) {
1117       has_children_of_type.gpencil = true;
1118     }
1119   }
1120   CTX_DATA_END;
1121
1122   if (parent->type == OB_ARMATURE) {
1123     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_ARMATURE);
1124     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_ARMATURE_NAME);
1125     if (!has_children_of_type.gpencil) {
1126       uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_ARMATURE_ENVELOPE);
1127     }
1128     if (has_children_of_type.mesh || has_children_of_type.gpencil) {
1129       uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_ARMATURE_AUTO);
1130     }
1131     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_BONE);
1132     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_BONE_RELATIVE);
1133   }
1134   else if (parent->type == OB_CURVE) {
1135     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_CURVE);
1136     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_FOLLOW);
1137     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_PATH_CONST);
1138   }
1139   else if (parent->type == OB_LATTICE) {
1140     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_LATTICE);
1141   }
1142
1143   /* vertex parenting */
1144   if (OB_TYPE_SUPPORT_PARVERT(parent->type)) {
1145     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_VERTEX);
1146     uiItemEnumO_ptr(layout, ot, NULL, 0, "type", PAR_VERTEX_TRI);
1147   }
1148
1149   UI_popup_menu_end(C, pup);
1150
1151   return OPERATOR_INTERFACE;
1152 }
1153
1154 static int parent_set_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1155 {
1156   if (RNA_property_is_set(op->ptr, op->type->prop)) {
1157     return parent_set_exec(C, op);
1158   }
1159   return parent_set_invoke_menu(C, op->type);
1160 }
1161
1162 static bool parent_set_poll_property(const bContext *UNUSED(C),
1163                                      wmOperator *op,
1164                                      const PropertyRNA *prop)
1165 {
1166   const char *prop_id = RNA_property_identifier(prop);
1167
1168   /* Only show XMirror for PAR_ARMATURE_ENVELOPE and PAR_ARMATURE_AUTO! */
1169   if (STREQ(prop_id, "xmirror")) {
1170     const int type = RNA_enum_get(op->ptr, "type");
1171     if (ELEM(type, PAR_ARMATURE_ENVELOPE, PAR_ARMATURE_AUTO)) {
1172       return true;
1173     }
1174     return false;
1175   }
1176
1177   return true;
1178 }
1179
1180 void OBJECT_OT_parent_set(wmOperatorType *ot)
1181 {
1182   /* identifiers */
1183   ot->name = "Make Parent";
1184   ot->description = "Set the object's parenting";
1185   ot->idname = "OBJECT_OT_parent_set";
1186
1187   /* api callbacks */
1188   ot->invoke = parent_set_invoke;
1189   ot->exec = parent_set_exec;
1190   ot->poll = ED_operator_object_active;
1191   ot->poll_property = parent_set_poll_property;
1192
1193   /* flags */
1194   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1195
1196   ot->prop = RNA_def_enum(ot->srna, "type", prop_make_parent_types, 0, "Type", "");
1197   RNA_def_boolean(
1198       ot->srna,
1199       "xmirror",
1200       false,
1201       "X Mirror",
1202       "Apply weights symmetrically along X axis, for Envelope/Automatic vertex groups creation");
1203   RNA_def_boolean(ot->srna,
1204                   "keep_transform",
1205                   false,
1206                   "Keep Transform",
1207                   "Apply transformation before parenting");
1208 }
1209
1210 /** \} */
1211
1212 /* ------------------------------------------------------------------- */
1213 /** \name Make Parent Without Inverse Operator
1214  * \{ */
1215
1216 static int parent_noinv_set_exec(bContext *C, wmOperator *op)
1217 {
1218   Main *bmain = CTX_data_main(C);
1219   Object *par = ED_object_active_context(C);
1220
1221   DEG_id_tag_update(&par->id, ID_RECALC_TRANSFORM);
1222
1223   /* context iterator */
1224   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1225     if (ob != par) {
1226       if (BKE_object_parent_loop_check(par, ob)) {
1227         BKE_report(op->reports, RPT_ERROR, "Loop in parents");
1228       }
1229       else {
1230         /* clear inverse matrix and also the object location */
1231         unit_m4(ob->parentinv);
1232         memset(ob->loc, 0, sizeof(float[3]));
1233
1234         /* set recalc flags */
1235         DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
1236
1237         /* set parenting type for object - object only... */
1238         ob->parent = par;
1239         ob->partype = PAROBJECT; /* note, dna define, not operator property */
1240       }
1241     }
1242   }
1243   CTX_DATA_END;
1244
1245   DEG_relations_tag_update(bmain);
1246   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
1247   WM_event_add_notifier(C, NC_OBJECT | ND_PARENT, NULL);
1248
1249   return OPERATOR_FINISHED;
1250 }
1251
1252 void OBJECT_OT_parent_no_inverse_set(wmOperatorType *ot)
1253 {
1254   /* identifiers */
1255   ot->name = "Make Parent without Inverse";
1256   ot->description = "Set the object's parenting without setting the inverse parent correction";
1257   ot->idname = "OBJECT_OT_parent_no_inverse_set";
1258
1259   /* api callbacks */
1260   ot->invoke = WM_operator_confirm;
1261   ot->exec = parent_noinv_set_exec;
1262   ot->poll = ED_operator_object_active_editable;
1263
1264   /* flags */
1265   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1266 }
1267
1268 /** \} */
1269
1270 /* ------------------------------------------------------------------- */
1271 /** \name Clear Track Operator
1272  * \{ */
1273
1274 enum {
1275   CLEAR_TRACK = 1,
1276   CLEAR_TRACK_KEEP_TRANSFORM = 2,
1277 };
1278
1279 static const EnumPropertyItem prop_clear_track_types[] = {
1280     {CLEAR_TRACK, "CLEAR", 0, "Clear Track", ""},
1281     {CLEAR_TRACK_KEEP_TRANSFORM,
1282      "CLEAR_KEEP_TRANSFORM",
1283      0,
1284      "Clear and Keep Transformation (Clear Track)",
1285      ""},
1286     {0, NULL, 0, NULL, NULL},
1287 };
1288
1289 /* note, poll should check for editable scene */
1290 static int object_track_clear_exec(bContext *C, wmOperator *op)
1291 {
1292   Main *bmain = CTX_data_main(C);
1293   const int type = RNA_enum_get(op->ptr, "type");
1294
1295   if (CTX_data_edit_object(C)) {
1296     BKE_report(op->reports, RPT_ERROR, "Operation cannot be performed in edit mode");
1297     return OPERATOR_CANCELLED;
1298   }
1299   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1300     bConstraint *con, *pcon;
1301
1302     /* remove track-object for old track */
1303     ob->track = NULL;
1304     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1305
1306     /* also remove all tracking constraints */
1307     for (con = ob->constraints.last; con; con = pcon) {
1308       pcon = con->prev;
1309       if (ELEM(con->type,
1310                CONSTRAINT_TYPE_TRACKTO,
1311                CONSTRAINT_TYPE_LOCKTRACK,
1312                CONSTRAINT_TYPE_DAMPTRACK)) {
1313         BKE_constraint_remove(&ob->constraints, con);
1314       }
1315     }
1316
1317     if (type == CLEAR_TRACK_KEEP_TRANSFORM) {
1318       BKE_object_apply_mat4(ob, ob->obmat, true, true);
1319     }
1320   }
1321   CTX_DATA_END;
1322
1323   DEG_relations_tag_update(bmain);
1324   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
1325
1326   return OPERATOR_FINISHED;
1327 }
1328
1329 void OBJECT_OT_track_clear(wmOperatorType *ot)
1330 {
1331   /* identifiers */
1332   ot->name = "Clear Track";
1333   ot->description = "Clear tracking constraint or flag from object";
1334   ot->idname = "OBJECT_OT_track_clear";
1335
1336   /* api callbacks */
1337   ot->invoke = WM_menu_invoke;
1338   ot->exec = object_track_clear_exec;
1339
1340   ot->poll = ED_operator_objectmode;
1341
1342   /* flags */
1343   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1344
1345   ot->prop = RNA_def_enum(ot->srna, "type", prop_clear_track_types, 0, "Type", "");
1346 }
1347
1348 /** \} */
1349
1350 /* ------------------------------------------------------------------- */
1351 /** \name Make Track Operator
1352  * \{ */
1353
1354 enum {
1355   CREATE_TRACK_DAMPTRACK = 1,
1356   CREATE_TRACK_TRACKTO = 2,
1357   CREATE_TRACK_LOCKTRACK = 3,
1358 };
1359
1360 static const EnumPropertyItem prop_make_track_types[] = {
1361     {CREATE_TRACK_DAMPTRACK, "DAMPTRACK", 0, "Damped Track Constraint", ""},
1362     {CREATE_TRACK_TRACKTO, "TRACKTO", 0, "Track to Constraint", ""},
1363     {CREATE_TRACK_LOCKTRACK, "LOCKTRACK", 0, "Lock Track Constraint", ""},
1364     {0, NULL, 0, NULL, NULL},
1365 };
1366
1367 static int track_set_exec(bContext *C, wmOperator *op)
1368 {
1369   Main *bmain = CTX_data_main(C);
1370   Object *obact = ED_object_active_context(C);
1371
1372   const int type = RNA_enum_get(op->ptr, "type");
1373
1374   switch (type) {
1375     case CREATE_TRACK_DAMPTRACK: {
1376       bConstraint *con;
1377       bDampTrackConstraint *data;
1378
1379       CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1380         if (ob != obact) {
1381           con = BKE_constraint_add_for_object(ob, "AutoTrack", CONSTRAINT_TYPE_DAMPTRACK);
1382
1383           data = con->data;
1384           data->tar = obact;
1385           DEG_id_tag_update(&ob->id,
1386                             ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1387
1388           /* Light, Camera and Speaker track differently by default */
1389           if (ELEM(ob->type, OB_LAMP, OB_CAMERA, OB_SPEAKER)) {
1390             data->trackflag = TRACK_nZ;
1391           }
1392         }
1393       }
1394       CTX_DATA_END;
1395       break;
1396     }
1397     case CREATE_TRACK_TRACKTO: {
1398       bConstraint *con;
1399       bTrackToConstraint *data;
1400
1401       CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1402         if (ob != obact) {
1403           con = BKE_constraint_add_for_object(ob, "AutoTrack", CONSTRAINT_TYPE_TRACKTO);
1404
1405           data = con->data;
1406           data->tar = obact;
1407           DEG_id_tag_update(&ob->id,
1408                             ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1409
1410           /* Light, Camera and Speaker track differently by default */
1411           if (ELEM(ob->type, OB_LAMP, OB_CAMERA, OB_SPEAKER)) {
1412             data->reserved1 = TRACK_nZ;
1413             data->reserved2 = UP_Y;
1414           }
1415         }
1416       }
1417       CTX_DATA_END;
1418       break;
1419     }
1420     case CREATE_TRACK_LOCKTRACK: {
1421       bConstraint *con;
1422       bLockTrackConstraint *data;
1423
1424       CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1425         if (ob != obact) {
1426           con = BKE_constraint_add_for_object(ob, "AutoTrack", CONSTRAINT_TYPE_LOCKTRACK);
1427
1428           data = con->data;
1429           data->tar = obact;
1430           DEG_id_tag_update(&ob->id,
1431                             ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1432
1433           /* Light, Camera and Speaker track differently by default */
1434           if (ELEM(ob->type, OB_LAMP, OB_CAMERA, OB_SPEAKER)) {
1435             data->trackflag = TRACK_nZ;
1436             data->lockflag = LOCK_Y;
1437           }
1438         }
1439       }
1440       CTX_DATA_END;
1441       break;
1442     }
1443   }
1444
1445   DEG_relations_tag_update(bmain);
1446   WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);
1447
1448   return OPERATOR_FINISHED;
1449 }
1450
1451 void OBJECT_OT_track_set(wmOperatorType *ot)
1452 {
1453   /* identifiers */
1454   ot->name = "Make Track";
1455   ot->description = "Make the object track another object, using various methods/constraints";
1456   ot->idname = "OBJECT_OT_track_set";
1457
1458   /* api callbacks */
1459   ot->invoke = WM_menu_invoke;
1460   ot->exec = track_set_exec;
1461
1462   ot->poll = ED_operator_objectmode;
1463
1464   /* flags */
1465   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1466
1467   /* properties */
1468   ot->prop = RNA_def_enum(ot->srna, "type", prop_make_track_types, 0, "Type", "");
1469 }
1470
1471 /** \} */
1472
1473 /* ------------------------------------------------------------------- */
1474 /** \name Link to Scene Operator
1475  * \{ */
1476
1477 #if 0
1478 static void link_to_scene(Main *UNUSED(bmain), ushort UNUSED(nr))
1479 {
1480   Scene *sce = (Scene *)BLI_findlink(&bmain->scene, G.curscreen->scenenr - 1);
1481   Base *base, *nbase;
1482
1483   if (sce == NULL) {
1484     return;
1485   }
1486   if (sce->id.lib) {
1487     return;
1488   }
1489
1490   for (base = FIRSTBASE; base; base = base->next) {
1491     if (BASE_SELECTED(v3d, base)) {
1492       nbase = MEM_mallocN(sizeof(Base), "newbase");
1493       *nbase = *base;
1494       BLI_addhead(&(sce->base), nbase);
1495       id_us_plus((ID *)base->object);
1496     }
1497   }
1498 }
1499 #endif
1500
1501 static int make_links_scene_exec(bContext *C, wmOperator *op)
1502 {
1503   Main *bmain = CTX_data_main(C);
1504   Scene *scene_to = BLI_findlink(&bmain->scenes, RNA_enum_get(op->ptr, "scene"));
1505
1506   if (scene_to == NULL) {
1507     BKE_report(op->reports, RPT_ERROR, "Could not find scene");
1508     return OPERATOR_CANCELLED;
1509   }
1510
1511   if (scene_to == CTX_data_scene(C)) {
1512     BKE_report(op->reports, RPT_ERROR, "Cannot link objects into the same scene");
1513     return OPERATOR_CANCELLED;
1514   }
1515
1516   if (ID_IS_LINKED(scene_to)) {
1517     BKE_report(op->reports, RPT_ERROR, "Cannot link objects into a linked scene");
1518     return OPERATOR_CANCELLED;
1519   }
1520
1521   Collection *collection_to = scene_to->master_collection;
1522   CTX_DATA_BEGIN (C, Base *, base, selected_bases) {
1523     BKE_collection_object_add(bmain, collection_to, base->object);
1524   }
1525   CTX_DATA_END;
1526
1527   DEG_relations_tag_update(bmain);
1528
1529   /* redraw the 3D view because the object center points are colored differently */
1530   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, NULL);
1531
1532   /* one day multiple scenes will be visible, then we should have some update function for them
1533    */
1534   return OPERATOR_FINISHED;
1535 }
1536
1537 enum {
1538   MAKE_LINKS_OBDATA = 1,
1539   MAKE_LINKS_MATERIALS = 2,
1540   MAKE_LINKS_ANIMDATA = 3,
1541   MAKE_LINKS_GROUP = 4,
1542   MAKE_LINKS_DUPLICOLLECTION = 5,
1543   MAKE_LINKS_MODIFIERS = 6,
1544   MAKE_LINKS_FONTS = 7,
1545 };
1546
1547 /* Return true if make link data is allowed, false otherwise */
1548 static bool allow_make_links_data(const int type, Object *ob_src, Object *ob_dst)
1549 {
1550   switch (type) {
1551     case MAKE_LINKS_OBDATA:
1552       if (ob_src->type == ob_dst->type && ob_src->type != OB_EMPTY) {
1553         return true;
1554       }
1555       break;
1556     case MAKE_LINKS_MATERIALS:
1557       if (OB_TYPE_SUPPORT_MATERIAL(ob_src->type) && OB_TYPE_SUPPORT_MATERIAL(ob_dst->type)) {
1558         return true;
1559       }
1560       break;
1561     case MAKE_LINKS_DUPLICOLLECTION:
1562       if (ob_dst->type == OB_EMPTY) {
1563         return true;
1564       }
1565       break;
1566     case MAKE_LINKS_ANIMDATA:
1567     case MAKE_LINKS_GROUP:
1568       return true;
1569     case MAKE_LINKS_MODIFIERS:
1570       if (!ELEM(OB_EMPTY, ob_src->type, ob_dst->type)) {
1571         return true;
1572       }
1573       break;
1574     case MAKE_LINKS_FONTS:
1575       if ((ob_src->data != ob_dst->data) && (ob_src->type == OB_FONT) &&
1576           (ob_dst->type == OB_FONT)) {
1577         return true;
1578       }
1579       break;
1580   }
1581   return false;
1582 }
1583
1584 static int make_links_data_exec(bContext *C, wmOperator *op)
1585 {
1586   Scene *scene = CTX_data_scene(C);
1587   Main *bmain = CTX_data_main(C);
1588   const int type = RNA_enum_get(op->ptr, "type");
1589   Object *ob_src;
1590   ID *obdata_id;
1591   int a;
1592
1593   /* collection */
1594   LinkNode *ob_collections = NULL;
1595   bool is_cycle = false;
1596   bool is_lib = false;
1597
1598   ob_src = ED_object_active_context(C);
1599
1600   /* avoid searching all collections in source object each time */
1601   if (type == MAKE_LINKS_GROUP) {
1602     ob_collections = BKE_object_groups(bmain, scene, ob_src);
1603   }
1604
1605   CTX_DATA_BEGIN (C, Base *, base_dst, selected_editable_bases) {
1606     Object *ob_dst = base_dst->object;
1607
1608     if (ob_src != ob_dst) {
1609       if (allow_make_links_data(type, ob_src, ob_dst)) {
1610         obdata_id = ob_dst->data;
1611
1612         switch (type) {
1613           case MAKE_LINKS_OBDATA: /* obdata */
1614             id_us_min(obdata_id);
1615
1616             obdata_id = ob_src->data;
1617             id_us_plus(obdata_id);
1618             ob_dst->data = obdata_id;
1619
1620             /* if amount of material indices changed: */
1621             BKE_object_materials_test(bmain, ob_dst, ob_dst->data);
1622
1623             DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
1624             break;
1625           case MAKE_LINKS_MATERIALS:
1626             /* new approach, using functions from kernel */
1627             for (a = 0; a < ob_src->totcol; a++) {
1628               Material *ma = BKE_object_material_get(ob_src, a + 1);
1629               /* also works with `ma == NULL` */
1630               BKE_object_material_assign(bmain, ob_dst, ma, a + 1, BKE_MAT_ASSIGN_USERPREF);
1631             }
1632             DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
1633             break;
1634           case MAKE_LINKS_ANIMDATA:
1635             BKE_animdata_copy_id(bmain, (ID *)ob_dst, (ID *)ob_src, 0);
1636             if (ob_dst->data && ob_src->data) {
1637               if (ID_IS_LINKED(obdata_id)) {
1638                 is_lib = true;
1639                 break;
1640               }
1641               BKE_animdata_copy_id(bmain, (ID *)ob_dst->data, (ID *)ob_src->data, 0);
1642             }
1643             DEG_id_tag_update(&ob_dst->id,
1644                               ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1645             break;
1646           case MAKE_LINKS_GROUP: {
1647             LinkNode *collection_node;
1648
1649             /* first clear collections */
1650             BKE_object_groups_clear(bmain, scene, ob_dst);
1651
1652             /* now add in the collections from the link nodes */
1653             for (collection_node = ob_collections; collection_node;
1654                  collection_node = collection_node->next) {
1655               if (ob_dst->instance_collection != collection_node->link) {
1656                 BKE_collection_object_add(bmain, collection_node->link, ob_dst);
1657               }
1658               else {
1659                 is_cycle = true;
1660               }
1661             }
1662             break;
1663           }
1664           case MAKE_LINKS_DUPLICOLLECTION:
1665             ob_dst->instance_collection = ob_src->instance_collection;
1666             if (ob_dst->instance_collection) {
1667               id_us_plus(&ob_dst->instance_collection->id);
1668               ob_dst->transflag |= OB_DUPLICOLLECTION;
1669             }
1670             DEG_id_tag_update(&ob_dst->id, ID_RECALC_COPY_ON_WRITE);
1671             break;
1672           case MAKE_LINKS_MODIFIERS:
1673             BKE_object_link_modifiers(ob_dst, ob_src);
1674             DEG_id_tag_update(&ob_dst->id,
1675                               ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1676             break;
1677           case MAKE_LINKS_FONTS: {
1678             Curve *cu_src = ob_src->data;
1679             Curve *cu_dst = ob_dst->data;
1680
1681             if (ID_IS_LINKED(obdata_id)) {
1682               is_lib = true;
1683               break;
1684             }
1685
1686             if (cu_dst->vfont) {
1687               id_us_min(&cu_dst->vfont->id);
1688             }
1689             cu_dst->vfont = cu_src->vfont;
1690             id_us_plus((ID *)cu_dst->vfont);
1691             if (cu_dst->vfontb) {
1692               id_us_min(&cu_dst->vfontb->id);
1693             }
1694             cu_dst->vfontb = cu_src->vfontb;
1695             id_us_plus((ID *)cu_dst->vfontb);
1696             if (cu_dst->vfonti) {
1697               id_us_min(&cu_dst->vfonti->id);
1698             }
1699             cu_dst->vfonti = cu_src->vfonti;
1700             id_us_plus((ID *)cu_dst->vfonti);
1701             if (cu_dst->vfontbi) {
1702               id_us_min(&cu_dst->vfontbi->id);
1703             }
1704             cu_dst->vfontbi = cu_src->vfontbi;
1705             id_us_plus((ID *)cu_dst->vfontbi);
1706
1707             DEG_id_tag_update(&ob_dst->id,
1708                               ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
1709             break;
1710           }
1711         }
1712       }
1713     }
1714   }
1715   CTX_DATA_END;
1716
1717   if (type == MAKE_LINKS_GROUP) {
1718     if (ob_collections) {
1719       BLI_linklist_free(ob_collections, NULL);
1720     }
1721
1722     if (is_cycle) {
1723       BKE_report(op->reports, RPT_WARNING, "Skipped some collections because of cycle detected");
1724     }
1725   }
1726
1727   if (is_lib) {
1728     BKE_report(op->reports, RPT_WARNING, "Skipped editing library object data");
1729   }
1730
1731   DEG_relations_tag_update(bmain);
1732   WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, CTX_wm_view3d(C));
1733   WM_event_add_notifier(C, NC_ANIMATION | ND_NLA_ACTCHANGE, CTX_wm_view3d(C));
1734   WM_event_add_notifier(C, NC_OBJECT, NULL);
1735
1736   return OPERATOR_FINISHED;
1737 }
1738
1739 void OBJECT_OT_make_links_scene(wmOperatorType *ot)
1740 {
1741   PropertyRNA *prop;
1742
1743   /* identifiers */
1744   ot->name = "Link Objects to Scene";
1745   ot->description = "Link selection to another scene";
1746   ot->idname = "OBJECT_OT_make_links_scene";
1747
1748   /* api callbacks */
1749   ot->invoke = WM_enum_search_invoke;
1750   ot->exec = make_links_scene_exec;
1751   /* better not run the poll check */
1752
1753   /* flags */
1754   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1755
1756   /* properties */
1757   prop = RNA_def_enum(ot->srna, "scene", DummyRNA_NULL_items, 0, "Scene", "");
1758   RNA_def_enum_funcs(prop, RNA_scene_local_itemf);
1759   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
1760   ot->prop = prop;
1761 }
1762
1763 void OBJECT_OT_make_links_data(wmOperatorType *ot)
1764 {
1765   static const EnumPropertyItem make_links_items[] = {
1766       {MAKE_LINKS_OBDATA, "OBDATA", 0, "Object Data", ""},
1767       {MAKE_LINKS_MATERIALS, "MATERIAL", 0, "Materials", ""},
1768       {MAKE_LINKS_ANIMDATA, "ANIMATION", 0, "Animation Data", ""},
1769       {MAKE_LINKS_GROUP, "GROUPS", 0, "Collection", ""},
1770       {MAKE_LINKS_DUPLICOLLECTION, "DUPLICOLLECTION", 0, "Instance Collection", ""},
1771       {MAKE_LINKS_MODIFIERS, "MODIFIERS", 0, "Modifiers", ""},
1772       {MAKE_LINKS_FONTS, "FONTS", 0, "Fonts", ""},
1773       {0, NULL, 0, NULL, NULL},
1774   };
1775
1776   /* identifiers */
1777   ot->name = "Link Data";
1778   ot->description = "Apply active object links to other selected objects";
1779   ot->idname = "OBJECT_OT_make_links_data";
1780
1781   /* api callbacks */
1782   ot->exec = make_links_data_exec;
1783   ot->poll = ED_operator_object_active;
1784
1785   /* flags */
1786   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1787
1788   /* properties */
1789   ot->prop = RNA_def_enum(ot->srna, "type", make_links_items, 0, "Type", "");
1790 }
1791
1792 /** \} */
1793
1794 /* ------------------------------------------------------------------- */
1795 /** \name Make Single User Operator
1796  * \{ */
1797
1798 static void libblock_relink_collection(Collection *collection, const bool do_collection)
1799 {
1800   if (do_collection) {
1801     BKE_libblock_relink_to_newid(&collection->id);
1802   }
1803
1804   for (CollectionObject *cob = collection->gobject.first; cob != NULL; cob = cob->next) {
1805     BKE_libblock_relink_to_newid(&cob->ob->id);
1806   }
1807
1808   LISTBASE_FOREACH (CollectionChild *, child, &collection->children) {
1809     libblock_relink_collection(child->collection, true);
1810   }
1811 }
1812
1813 static Collection *single_object_users_collection(Main *bmain,
1814                                                   Scene *scene,
1815                                                   Collection *collection,
1816                                                   const int flag,
1817                                                   const bool copy_collections,
1818                                                   const bool is_master_collection)
1819 {
1820   /* Generate new copies for objects in given collection and all its children,
1821    * and optionally also copy collections themselves. */
1822   if (copy_collections && !is_master_collection) {
1823     Collection *collection_new = (Collection *)BKE_id_copy(bmain, &collection->id);
1824     id_us_min(&collection_new->id);
1825     collection = ID_NEW_SET(collection, collection_new);
1826   }
1827
1828   /* We do not remap to new objects here, this is done in separate step. */
1829   LISTBASE_FOREACH (CollectionObject *, cob, &collection->gobject) {
1830     Object *ob = cob->ob;
1831     /* an object may be in more than one collection */
1832     if ((ob->id.newid == NULL) && ((ob->flag & flag) == flag)) {
1833       if (!ID_IS_LINKED(ob) && BKE_object_scenes_users_get(bmain, ob) > 1) {
1834         ID_NEW_SET(ob, BKE_id_copy(bmain, &ob->id));
1835         id_us_min(ob->id.newid);
1836       }
1837     }
1838   }
1839
1840   /* Since master collection has already be duplicated as part of scene copy,
1841    * we do not duplicate it here.
1842    * However, this means its children need to be re-added manually here,
1843    * otherwise their parent lists are empty (which will lead to crashes, see T63101). */
1844   CollectionChild *child_next, *child = collection->children.first;
1845   CollectionChild *orig_child_last = collection->children.last;
1846   for (; child != NULL; child = child_next) {
1847     child_next = child->next;
1848     Collection *collection_child_new = single_object_users_collection(
1849         bmain, scene, child->collection, flag, copy_collections, false);
1850
1851     if (is_master_collection && copy_collections && child->collection != collection_child_new) {
1852       /* We do not want a collection sync here, our collections are in a complete uninitialized
1853        * state currently. With current code, that would lead to a memory leak - because of
1854        * reasons. It would be a useless loss of computing anyway, since caller has to fully
1855        * refresh view-layers/collections caching at the end. */
1856       BKE_collection_child_add_no_sync(collection, collection_child_new);
1857       BLI_remlink(&collection->children, child);
1858       MEM_freeN(child);
1859       if (child == orig_child_last) {
1860         break;
1861       }
1862     }
1863   }
1864
1865   return collection;
1866 }
1867
1868 /* Warning, sets ID->newid pointers of objects and collections, but does not clear them. */
1869 static void single_object_users(
1870     Main *bmain, Scene *scene, View3D *v3d, const int flag, const bool copy_collections)
1871 {
1872   /* duplicate all the objects of the scene (and matching collections, if required). */
1873   Collection *master_collection = scene->master_collection;
1874   single_object_users_collection(bmain, scene, master_collection, flag, copy_collections, true);
1875
1876   /* Will also handle the master collection. */
1877   BKE_libblock_relink_to_newid(&scene->id);
1878
1879   /* Collection and object pointers in collections */
1880   libblock_relink_collection(scene->master_collection, false);
1881
1882   /* We also have to handle runtime things in UI. */
1883   if (v3d) {
1884     ID_NEW_REMAP(v3d->camera);
1885   }
1886
1887   /* Making single user may affect other scenes if they share
1888    * with current one some collections in their ViewLayer. */
1889   BKE_main_collection_sync_remap(bmain);
1890 }
1891
1892 /* not an especially efficient function, only added so the single user
1893  * button can be functional.*/
1894 void ED_object_single_user(Main *bmain, Scene *scene, Object *ob)
1895 {
1896   FOREACH_SCENE_OBJECT_BEGIN (scene, ob_iter) {
1897     ob_iter->flag &= ~OB_DONE;
1898   }
1899   FOREACH_SCENE_OBJECT_END;
1900
1901   /* tag only the one object */
1902   ob->flag |= OB_DONE;
1903
1904   single_object_users(bmain, scene, NULL, OB_DONE, false);
1905   BKE_main_id_clear_newpoins(bmain);
1906 }
1907
1908 static void single_obdata_users(
1909     Main *bmain, Scene *scene, ViewLayer *view_layer, View3D *v3d, const int flag)
1910 {
1911   Light *la;
1912   Curve *cu;
1913   Camera *cam;
1914   Mesh *me;
1915   Lattice *lat;
1916   ID *id;
1917
1918   FOREACH_OBJECT_FLAG_BEGIN (scene, view_layer, v3d, flag, ob) {
1919     if (!ID_IS_LINKED(ob)) {
1920       id = ob->data;
1921
1922       if (id && id->us > 1 && !ID_IS_LINKED(id)) {
1923         DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1924
1925         switch (ob->type) {
1926           case OB_LAMP:
1927             ob->data = la = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1928             break;
1929           case OB_CAMERA:
1930             cam = ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1931             ID_NEW_REMAP(cam->dof.focus_object);
1932             break;
1933           case OB_MESH:
1934             /* Needed to remap texcomesh below. */
1935             me = ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1936             if (me->key) { /* We do not need to set me->key->id.newid here... */
1937               BKE_animdata_copy_id_action(bmain, (ID *)me->key);
1938             }
1939             break;
1940           case OB_MBALL:
1941             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1942             break;
1943           case OB_CURVE:
1944           case OB_SURF:
1945           case OB_FONT:
1946             ob->data = cu = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1947             ID_NEW_REMAP(cu->bevobj);
1948             ID_NEW_REMAP(cu->taperobj);
1949             if (cu->key) { /* We do not need to set cu->key->id.newid here... */
1950               BKE_animdata_copy_id_action(bmain, (ID *)cu->key);
1951             }
1952             break;
1953           case OB_LATTICE:
1954             ob->data = lat = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1955             if (lat->key) { /* We do not need to set lat->key->id.newid here... */
1956               BKE_animdata_copy_id_action(bmain, (ID *)lat->key);
1957             }
1958             break;
1959           case OB_ARMATURE:
1960             DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1961             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1962             BKE_pose_rebuild(bmain, ob, ob->data, true);
1963             break;
1964           case OB_SPEAKER:
1965             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1966             break;
1967           case OB_LIGHTPROBE:
1968             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1969             break;
1970           case OB_GPENCIL:
1971             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1972             break;
1973           case OB_HAIR:
1974             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1975             break;
1976           case OB_POINTCLOUD:
1977             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1978             break;
1979           case OB_VOLUME:
1980             ob->data = ID_NEW_SET(ob->data, BKE_id_copy(bmain, ob->data));
1981             break;
1982           default:
1983             printf("ERROR %s: can't copy %s\n", __func__, id->name);
1984             BLI_assert(!"This should never happen.");
1985
1986             /* We need to end the FOREACH_OBJECT_FLAG_BEGIN iterator to prevent memory leak. */
1987             BKE_scene_objects_iterator_end(&iter_macro);
1988             return;
1989         }
1990
1991         /* Copy animation data after object data became local,
1992          * otherwise old and new object data will share the same
1993          * AnimData structure, which is not what we want.
1994          *                                             (sergey)
1995          */
1996         BKE_animdata_copy_id_action(bmain, (ID *)ob->data);
1997
1998         id_us_min(id);
1999       }
2000     }
2001   }
2002   FOREACH_OBJECT_FLAG_END;
2003
2004   me = bmain->meshes.first;
2005   while (me) {
2006     ID_NEW_REMAP(me->texcomesh);
2007     me = me->id.next;
2008   }
2009 }
2010
2011 static void single_object_action_users(
2012     Main *bmain, Scene *scene, ViewLayer *view_layer, View3D *v3d, const int flag)
2013 {
2014   FOREACH_OBJECT_FLAG_BEGIN (scene, view_layer, v3d, flag, ob) {
2015     if (!ID_IS_LINKED(ob)) {
2016       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
2017       BKE_animdata_copy_id_action(bmain, &ob->id);
2018     }
2019   }
2020   FOREACH_OBJECT_FLAG_END;
2021 }
2022
2023 static void single_mat_users(
2024     Main *bmain, Scene *scene, ViewLayer *view_layer, View3D *v3d, const int flag)
2025 {
2026   Material *ma, *man;
2027   int a;
2028
2029   FOREACH_OBJECT_FLAG_BEGIN (scene, view_layer, v3d, flag, ob) {
2030     if (!ID_IS_LINKED(ob)) {
2031       for (a = 1; a <= ob->totcol; a++) {
2032         ma = BKE_object_material_get(ob, a);
2033         if (ma) {
2034           /* do not test for LIB_TAG_NEW or use newid:
2035            * this functions guaranteed delivers single_users! */
2036
2037           if (ma->id.us > 1) {
2038             man = (Material *)BKE_id_copy(bmain, &ma->id);
2039             BKE_animdata_copy_id_action(bmain, &man->id);
2040
2041             man->id.us = 0;
2042             BKE_object_material_assign(bmain, ob, man, a, BKE_MAT_ASSIGN_USERPREF);
2043           }
2044         }
2045       }
2046     }
2047   }
2048   FOREACH_OBJECT_FLAG_END;
2049 }
2050
2051 /** \} */
2052
2053 /* ------------------------------------------------------------------- */
2054 /** \name Make Local Operator
2055  * \{ */
2056
2057 enum {
2058   MAKE_LOCAL_SELECT_OB = 1,
2059   MAKE_LOCAL_SELECT_OBDATA = 2,
2060   MAKE_LOCAL_SELECT_OBDATA_MATERIAL = 3,
2061   MAKE_LOCAL_ALL = 4,
2062 };
2063
2064 static int tag_localizable_looper(LibraryIDLinkCallbackData *cb_data)
2065 {
2066   ID **id_pointer = cb_data->id_pointer;
2067   if (*id_pointer) {
2068     (*id_pointer)->tag &= ~LIB_TAG_DOIT;
2069   }
2070
2071   return IDWALK_RET_NOP;
2072 }
2073
2074 static void tag_localizable_objects(bContext *C, const int mode)
2075 {
2076   Main *bmain = CTX_data_main(C);
2077
2078   BKE_main_id_tag_all(bmain, LIB_TAG_DOIT, false);
2079
2080   /* Set LIB_TAG_DOIT flag for all selected objects, so next we can check whether
2081    * object is gonna to become local or not.
2082    */
2083   CTX_DATA_BEGIN (C, Object *, object, selected_objects) {
2084     object->id.tag |= LIB_TAG_DOIT;
2085
2086     /* If data is also gonna to become local, mark data we're interested in
2087      * as gonna-to-be-local.
2088      */
2089     if (mode == MAKE_LOCAL_SELECT_OBDATA && object->data) {
2090       ID *data_id = (ID *)object->data;
2091       data_id->tag |= LIB_TAG_DOIT;
2092     }
2093   }
2094   CTX_DATA_END;
2095
2096   /* Also forbid making objects local if other library objects are using
2097    * them for modifiers or constraints.
2098    */
2099   for (Object *object = bmain->objects.first; object; object = object->id.next) {
2100     if ((object->id.tag & LIB_TAG_DOIT) == 0) {
2101       BKE_library_foreach_ID_link(
2102           NULL, &object->id, tag_localizable_looper, NULL, IDWALK_READONLY);
2103     }
2104     if (object->data) {
2105       ID *data_id = (ID *)object->data;
2106       if ((data_id->tag & LIB_TAG_DOIT) == 0) {
2107         BKE_library_foreach_ID_link(NULL, data_id, tag_localizable_looper, NULL, IDWALK_READONLY);
2108       }
2109     }
2110   }
2111
2112   /* TODO(sergey): Drivers targets? */
2113 }
2114
2115 /**
2116  * Instance indirectly referenced zero user objects,
2117  * otherwise they're lost on reload, see T40595.
2118  */
2119 static bool make_local_all__instance_indirect_unused(Main *bmain,
2120                                                      ViewLayer *view_layer,
2121                                                      Collection *collection)
2122 {
2123   Object *ob;
2124   bool changed = false;
2125
2126   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2127     if (ID_IS_LINKED(ob) && (ob->id.us == 0)) {
2128       Base *base;
2129
2130       id_us_plus(&ob->id);
2131
2132       BKE_collection_object_add(bmain, collection, ob);
2133       base = BKE_view_layer_base_find(view_layer, ob);
2134       ED_object_base_select(base, BA_SELECT);
2135       DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
2136
2137       changed = true;
2138     }
2139   }
2140
2141   return changed;
2142 }
2143
2144 static void make_local_animdata_tag_strips(ListBase *strips)
2145 {
2146   NlaStrip *strip;
2147
2148   for (strip = strips->first; strip; strip = strip->next) {
2149     if (strip->act) {
2150       strip->act->id.tag &= ~LIB_TAG_PRE_EXISTING;
2151     }
2152
2153     make_local_animdata_tag_strips(&strip->strips);
2154   }
2155 }
2156
2157 /* Tag all actions used by given animdata to be made local. */
2158 static void make_local_animdata_tag(AnimData *adt)
2159 {
2160   if (adt) {
2161     /* Actions - Active and Temp */
2162     if (adt->action) {
2163       adt->action->id.tag &= ~LIB_TAG_PRE_EXISTING;
2164     }
2165     if (adt->tmpact) {
2166       adt->tmpact->id.tag &= ~LIB_TAG_PRE_EXISTING;
2167     }
2168
2169     /* Drivers */
2170     /* TODO: need to handle the ID-targets too? */
2171
2172     /* NLA Data */
2173     LISTBASE_FOREACH (NlaTrack *, nlt, &adt->nla_tracks) {
2174       make_local_animdata_tag_strips(&nlt->strips);
2175     }
2176   }
2177 }
2178
2179 static void make_local_material_tag(Material *ma)
2180 {
2181   if (ma) {
2182     ma->id.tag &= ~LIB_TAG_PRE_EXISTING;
2183     make_local_animdata_tag(BKE_animdata_from_id(&ma->id));
2184
2185     /* About nodetrees: root one is made local together with material,
2186      * others we keep linked for now... */
2187   }
2188 }
2189
2190 static int make_local_exec(bContext *C, wmOperator *op)
2191 {
2192   Main *bmain = CTX_data_main(C);
2193   ParticleSystem *psys;
2194   Material *ma, ***matarar;
2195   const int mode = RNA_enum_get(op->ptr, "type");
2196   int a;
2197
2198   /* Note: we (ab)use LIB_TAG_PRE_EXISTING to cherry pick which ID to make local... */
2199   if (mode == MAKE_LOCAL_ALL) {
2200     ViewLayer *view_layer = CTX_data_view_layer(C);
2201     Collection *collection = CTX_data_collection(C);
2202
2203     BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, false);
2204
2205     /* De-select so the user can differentiate newly instanced from existing objects. */
2206     BKE_view_layer_base_deselect_all(view_layer);
2207
2208     if (make_local_all__instance_indirect_unused(bmain, view_layer, collection)) {
2209       BKE_report(op->reports,
2210                  RPT_INFO,
2211                  "Orphan library objects added to the current scene to avoid loss");
2212     }
2213   }
2214   else {
2215     BKE_main_id_tag_all(bmain, LIB_TAG_PRE_EXISTING, true);
2216     tag_localizable_objects(C, mode);
2217
2218     CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
2219       if ((ob->id.tag & LIB_TAG_DOIT) == 0) {
2220         continue;
2221       }
2222
2223       ob->id.tag &= ~LIB_TAG_PRE_EXISTING;
2224       make_local_animdata_tag(BKE_animdata_from_id(&ob->id));
2225       for (psys = ob->particlesystem.first; psys; psys = psys->next) {
2226         psys->part->id.tag &= ~LIB_TAG_PRE_EXISTING;
2227       }
2228
2229       if (mode == MAKE_LOCAL_SELECT_OBDATA_MATERIAL) {
2230         for (a = 0; a < ob->totcol; a++) {
2231           ma = ob->mat[a];
2232           if (ma) {
2233             make_local_material_tag(ma);
2234           }
2235         }
2236
2237         matarar = BKE_object_material_array_p(ob);
2238         if (matarar) {
2239           for (a = 0; a < ob->totcol; a++) {
2240             ma = (*matarar)[a];
2241             if (ma) {
2242               make_local_material_tag(ma);
2243             }
2244           }
2245         }
2246       }
2247
2248       if (ELEM(mode, MAKE_LOCAL_SELECT_OBDATA, MAKE_LOCAL_SELECT_OBDATA_MATERIAL) &&
2249           ob->data != NULL) {
2250         ID *ob_data = ob->data;
2251         ob_data->tag &= ~LIB_TAG_PRE_EXISTING;
2252         make_local_animdata_tag(BKE_animdata_from_id(ob_data));
2253       }
2254     }
2255     CTX_DATA_END;
2256   }
2257
2258   BKE_library_make_local(bmain, NULL, NULL, true, false); /* NULL is all libs */
2259
2260   WM_event_add_notifier(C, NC_WINDOW, NULL);
2261   return OPERATOR_FINISHED;
2262 }
2263
2264 void OBJECT_OT_make_local(wmOperatorType *ot)
2265 {
2266   static const EnumPropertyItem type_items[] = {
2267       {MAKE_LOCAL_SELECT_OB, "SELECT_OBJECT", 0, "Selected Objects", ""},
2268       {MAKE_LOCAL_SELECT_OBDATA, "SELECT_OBDATA", 0, "Selected Objects and Data", ""},
2269       {MAKE_LOCAL_SELECT_OBDATA_MATERIAL,
2270        "SELECT_OBDATA_MATERIAL",
2271        0,
2272        "Selected Objects, Data and Materials",
2273        ""},
2274       {MAKE_LOCAL_ALL, "ALL", 0, "All", ""},
2275       {0, NULL, 0, NULL, NULL},
2276   };
2277
2278   /* identifiers */
2279   ot->name = "Make Local";
2280   ot->description = "Make library linked data-blocks local to this file";
2281   ot->idname = "OBJECT_OT_make_local";
2282
2283   /* api callbacks */
2284   ot->invoke = WM_menu_invoke;
2285   ot->exec = make_local_exec;
2286   ot->poll = ED_operator_objectmode;
2287
2288   /* flags */
2289   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2290
2291   /* properties */
2292   ot->prop = RNA_def_enum(ot->srna, "type", type_items, 0, "Type", "");
2293 }
2294
2295 /** \} */
2296
2297 /* ------------------------------------------------------------------- */
2298 /** \name Make Library Override Operator
2299  * \{ */
2300
2301 static bool make_override_library_object_overridable_check(Main *bmain, Object *object)
2302 {
2303   /* An object is actually overrideable only if it is in at least one local collections.
2304    * Unfortunately 'direct link' flag is not enough here. */
2305   LISTBASE_FOREACH (Collection *, collection, &bmain->collections) {
2306     if (!ID_IS_LINKED(collection) && BKE_collection_has_object(collection, object)) {
2307       return true;
2308     }
2309   }
2310   LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
2311     if (!ID_IS_LINKED(scene) && BKE_collection_has_object(scene->master_collection, object)) {
2312       return true;
2313     }
2314   }
2315   return false;
2316 }
2317
2318 /* Set the object to override. */
2319 static int make_override_library_invoke(bContext *C, wmOperator *op, const wmEvent *event)
2320 {
2321   Main *bmain = CTX_data_main(C);
2322   Scene *scene = CTX_data_scene(C);
2323   Object *obact = ED_object_active_context(C);
2324
2325   /* Sanity checks. */
2326   if (!scene || ID_IS_LINKED(scene) || !obact) {
2327     return OPERATOR_CANCELLED;
2328   }
2329
2330   if ((!ID_IS_LINKED(obact) && obact->instance_collection != NULL &&
2331        ID_IS_OVERRIDABLE_LIBRARY(obact->instance_collection)) ||
2332       make_override_library_object_overridable_check(bmain, obact)) {
2333     uiPopupMenu *pup = UI_popup_menu_begin(C, IFACE_("OK?"), ICON_QUESTION);
2334     uiLayout *layout = UI_popup_menu_layout(pup);
2335
2336     /* Create operator menu item with relevant properties filled in. */
2337     PointerRNA opptr_dummy;
2338     uiItemFullO_ptr(
2339         layout, op->type, op->type->name, ICON_NONE, NULL, WM_OP_EXEC_REGION_WIN, 0, &opptr_dummy);
2340
2341     /* Present the menu and be done... */
2342     UI_popup_menu_end(C, pup);
2343
2344     /* This invoke just calls another instance of this operator... */
2345     return OPERATOR_INTERFACE;
2346   }
2347
2348   if (ID_IS_LINKED(obact)) {
2349     /* Show menu with list of directly linked collections containing the active object. */
2350     WM_enum_search_invoke(C, op, event);
2351     return OPERATOR_CANCELLED;
2352   }
2353
2354   /* Error.. cannot continue. */
2355   BKE_report(op->reports,
2356              RPT_ERROR,
2357              "Can only make library override for a referenced object or collection");
2358   return OPERATOR_CANCELLED;
2359 }
2360
2361 static int make_override_library_exec(bContext *C, wmOperator *op)
2362 {
2363   Main *bmain = CTX_data_main(C);
2364   Scene *scene = CTX_data_scene(C);
2365   ViewLayer *view_layer = CTX_data_view_layer(C);
2366   Object *obact = CTX_data_active_object(C);
2367   ID *id_root = NULL;
2368   bool is_override_instancing_object = false;
2369
2370   if (!ID_IS_LINKED(obact) && obact->instance_collection != NULL &&
2371       ID_IS_LINKED(obact->instance_collection)) {
2372     if (!ID_IS_OVERRIDABLE_LIBRARY(obact->instance_collection)) {
2373       BKE_reportf(op->reports,
2374                   RPT_ERROR_INVALID_INPUT,
2375                   "Collection '%s' (instantiated by the active object) is not overridable",
2376                   obact->instance_collection->id.name + 2);
2377       return OPERATOR_CANCELLED;
2378     }
2379
2380     id_root = &obact->instance_collection->id;
2381     is_override_instancing_object = true;
2382   }
2383   else if (!make_override_library_object_overridable_check(bmain, obact)) {
2384     const int i = RNA_property_enum_get(op->ptr, op->type->prop);
2385     const uint collection_session_uuid = *((uint *)&i);
2386     if (collection_session_uuid == MAIN_ID_SESSION_UUID_UNSET) {
2387       BKE_reportf(op->reports,
2388                   RPT_ERROR_INVALID_INPUT,
2389                   "Active object '%s' is not overridable",
2390                   obact->id.name + 2);
2391       return OPERATOR_CANCELLED;
2392     }
2393
2394     Collection *collection = BLI_listbase_bytes_find(&bmain->collections,
2395                                                      &collection_session_uuid,
2396                                                      sizeof(collection_session_uuid),
2397                                                      offsetof(ID, session_uuid));
2398     if (!ID_IS_OVERRIDABLE_LIBRARY(collection)) {
2399       BKE_reportf(op->reports,
2400                   RPT_ERROR_INVALID_INPUT,
2401                   "Could not find an overridable collection containing object '%s'",
2402                   obact->id.name + 2);
2403       return OPERATOR_CANCELLED;
2404     }
2405     id_root = &collection->id;
2406   }
2407   /* Else, poll func ensures us that ID_IS_LINKED(obact) is true. */
2408   else {
2409     id_root = &obact->id;
2410   }
2411
2412   BKE_main_id_tag_all(bmain, LIB_TAG_DOIT, false);
2413
2414   const bool success = BKE_lib_override_library_create(
2415       bmain, scene, view_layer, id_root, &obact->id);
2416
2417   /* Remove the instance empty from this scene, the items now have an overridden collection
2418    * instead. */
2419   if (success && is_override_instancing_object) {
2420     ED_object_base_free_and_unlink(bmain, scene, obact);
2421   }
2422
2423   DEG_id_tag_update(&CTX_data_scene(C)->id, ID_RECALC_BASE_FLAGS | ID_RECALC_COPY_ON_WRITE);
2424   WM_event_add_notifier(C, NC_WINDOW, NULL);
2425
2426   return success ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
2427 }
2428
2429 static bool make_override_library_poll(bContext *C)
2430 {
2431   Object *obact = CTX_data_active_object(C);
2432
2433   /* Object must be directly linked to be overridable. */
2434   return (ED_operator_objectmode(C) && obact != NULL &&
2435           (ID_IS_LINKED(obact) || (obact->instance_collection != NULL &&
2436                                    ID_IS_OVERRIDABLE_LIBRARY(obact->instance_collection))));
2437 }
2438
2439 static const EnumPropertyItem *make_override_collections_of_linked_object_itemf(
2440     bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
2441 {
2442   EnumPropertyItem item_tmp = {0}, *item = NULL;
2443   int totitem = 0;
2444
2445   Object *object = ED_object_active_context(C);
2446   Main *bmain = CTX_data_main(C);
2447
2448   if (!object || !ID_IS_LINKED(object)) {
2449     return DummyRNA_DEFAULT_items;
2450   }
2451
2452   LISTBASE_FOREACH (Collection *, collection, &bmain->collections) {
2453     /* Only check for directly linked collections. */
2454     if (!ID_IS_LINKED(&collection->id) || (collection->id.tag & LIB_TAG_INDIRECT) != 0) {
2455       continue;
2456     }
2457     if (BKE_collection_has_object_recursive(collection, object)) {
2458       item_tmp.identifier = item_tmp.name = collection->id.name + 2;
2459       item_tmp.value = *((int *)&collection->id.session_uuid);
2460       RNA_enum_item_add(&item, &totitem, &item_tmp);
2461     }
2462   }
2463
2464   RNA_enum_item_end(&item, &totitem);
2465   *r_free = true;
2466
2467   return item;
2468 }
2469
2470 void OBJECT_OT_make_override_library(wmOperatorType *ot)
2471 {
2472   /* identifiers */
2473   ot->name = "Make Library Override";
2474   ot->description = "Make a local override of this library linked data-block";
2475   ot->idname = "OBJECT_OT_make_override_library";
2476
2477   /* api callbacks */
2478   ot->invoke = make_override_library_invoke;
2479   ot->exec = make_override_library_exec;
2480   ot->poll = make_override_library_poll;
2481
2482   /* flags */
2483   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2484
2485   /* properties */
2486   PropertyRNA *prop;
2487   prop = RNA_def_enum(ot->srna,
2488                       "collection",
2489                       DummyRNA_DEFAULT_items,
2490                       MAIN_ID_SESSION_UUID_UNSET,
2491                       "Override Collection",
2492                       "Name of directly linked collection containing the selected object, to make "
2493                       "an override from");
2494   RNA_def_enum_funcs(prop, make_override_collections_of_linked_object_itemf);
2495   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
2496   ot->prop = prop;
2497 }
2498
2499 static bool convert_proxy_to_override_poll(bContext *C)
2500 {
2501   Object *obact = CTX_data_active_object(C);
2502
2503   return obact != NULL && obact->proxy != NULL;
2504 }
2505
2506 static int convert_proxy_to_override_exec(bContext *C, wmOperator *UNUSED(op))
2507 {
2508   Main *bmain = CTX_data_main(C);
2509   Scene *scene = CTX_data_scene(C);
2510   ViewLayer *view_layer = CTX_data_view_layer(C);
2511
2512   BKE_main_id_tag_all(bmain, LIB_TAG_DOIT, false);
2513
2514   Object *ob_proxy = CTX_data_active_object(C);
2515   Object *ob_proxy_group = ob_proxy->proxy_group;
2516   const bool is_override_instancing_object = ob_proxy_group != NULL;
2517
2518   const bool success = BKE_lib_override_library_proxy_convert(bmain, scene, view_layer, ob_proxy);
2519
2520   /* Remove the instance empty from this scene, the items now have an overridden collection
2521    * instead. */
2522   if (success && is_override_instancing_object) {
2523     ED_object_base_free_and_unlink(bmain, scene, ob_proxy_group);
2524   }
2525
2526   DEG_id_tag_update(&CTX_data_scene(C)->id, ID_RECALC_BASE_FLAGS | ID_RECALC_COPY_ON_WRITE);
2527   WM_event_add_notifier(C, NC_WINDOW, NULL);
2528
2529   return success ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
2530 }
2531
2532 void OBJECT_OT_convert_proxy_to_override(wmOperatorType *ot)
2533 {
2534   /* identifiers */
2535   ot->name = "Convert Proxy To Override";
2536   ot->description = "Convert a proxy to a local library override";
2537   ot->idname = "OBJECT_OT_convert_proxy_to_override";
2538
2539   /* api callbacks */
2540   ot->exec = convert_proxy_to_override_exec;
2541   ot->poll = convert_proxy_to_override_poll;
2542
2543   /* flags */
2544   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2545 }
2546
2547 /** \} */
2548
2549 /* ------------------------------------------------------------------- */
2550 /** \name Make Single User Operator
2551  * \{ */
2552
2553 enum {
2554   MAKE_SINGLE_USER_ALL = 1,
2555   MAKE_SINGLE_USER_SELECTED = 2,
2556 };
2557
2558 static int make_single_user_exec(bContext *C, wmOperator *op)
2559 {
2560   Main *bmain = CTX_data_main(C);
2561   Scene *scene = CTX_data_scene(C);
2562   ViewLayer *view_layer = CTX_data_view_layer(C);
2563   View3D *v3d = CTX_wm_view3d(C); /* ok if this is NULL */
2564   const int flag = (RNA_enum_get(op->ptr, "type") == MAKE_SINGLE_USER_SELECTED) ? SELECT : 0;
2565   const bool copy_collections = false;
2566   bool update_deps = false;
2567
2568   if (RNA_boolean_get(op->ptr, "object")) {
2569     if (flag == SELECT) {
2570       BKE_view_layer_selected_objects_tag(view_layer, OB_DONE);
2571       single_object_users(bmain, scene, v3d, OB_DONE, copy_collections);
2572     }
2573     else {
2574       single_object_users(bmain, scene, v3d, 0, copy_collections);
2575     }
2576
2577     /* needed since object relationships may have changed */
2578     update_deps = true;
2579   }
2580
2581   if (RNA_boolean_get(op->ptr, "obdata")) {
2582     single_obdata_users(bmain, scene, view_layer, v3d, flag);
2583
2584     /* Needed since some IDs were remapped? (incl. me->texcomesh, see T73797). */
2585     update_deps = true;
2586   }
2587
2588   if (RNA_boolean_get(op->ptr, "material")) {
2589     single_mat_users(bmain, scene, view_layer, v3d, flag);
2590   }
2591
2592   if (RNA_boolean_get(op->ptr, "animation")) {
2593     single_object_action_users(bmain, scene, view_layer, v3d, flag);
2594   }
2595
2596   BKE_main_id_clear_newpoins(bmain);
2597
2598   WM_event_add_notifier(C, NC_WINDOW, NULL);
2599
2600   if (update_deps) {
2601     DEG_relations_tag_update(bmain);
2602   }
2603
2604   return OPERATOR_FINISHED;
2605 }
2606
2607 void OBJECT_OT_make_single_user(wmOperatorType *ot)
2608 {
2609   static const EnumPropertyItem type_items[] = {
2610       {MAKE_SINGLE_USER_SELECTED, "SELECTED_OBJECTS", 0, "Selected Objects", ""},
2611       {MAKE_SINGLE_USER_ALL, "ALL", 0, "All", ""},
2612       {0, NULL, 0, NULL, NULL},
2613   };
2614
2615   /* identifiers */
2616   ot->name = "Make Single User";
2617   ot->description = "Make linked data local to each object";
2618   ot->idname = "OBJECT_OT_make_single_user";
2619
2620   /* Note that the invoke callback is only used from operator search,
2621    * otherwise this does nothing by default. */
2622
2623   /* api callbacks */
2624   ot->invoke = WM_operator_props_popup_confirm;
2625   ot->exec = make_single_user_exec;
2626   ot->poll = ED_operator_objectmode;
2627
2628   /* flags */
2629   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2630
2631   /* properties */
2632   ot->prop = RNA_def_enum(ot->srna, "type", type_items, MAKE_SINGLE_USER_SELECTED, "Type", "");
2633
2634   RNA_def_boolean(ot->srna, "object", 0, "Object", "Make single user objects");
2635   RNA_def_boolean(ot->srna, "obdata", 0, "Object Data", "Make single user object data");
2636   RNA_def_boolean(ot->srna, "material", 0, "Materials", "Make materials local to each data-block");
2637   RNA_def_boolean(
2638       ot->srna, "animation", 0, "Object Animation", "Make animation data local to each object");
2639 }
2640
2641 /** \} */
2642
2643 /* ------------------------------------------------------------------- */
2644 /** \name Drop Named Material on Object Operator
2645  * \{ */
2646
2647 static int drop_named_material_invoke(bContext *C, wmOperator *op, const wmEvent *event)
2648 {
2649   Main *bmain = CTX_data_main(C);
2650   Base *base = ED_view3d_give_base_under_cursor(C, event->mval);
2651   Material *ma;
2652   char name[MAX_ID_NAME - 2];
2653
2654   RNA_string_get(op->ptr, "name", name);
2655   ma = (Material *)BKE_libblock_find_name(bmain, ID_MA, name);
2656   if (base == NULL || ma == NULL) {
2657     return OPERATOR_CANCELLED;
2658   }
2659
2660   BKE_object_material_assign(CTX_data_main(C), base->object, ma, 1, BKE_MAT_ASSIGN_USERPREF);
2661
2662   DEG_id_tag_update(&base->object->id, ID_RECALC_TRANSFORM);
2663
2664   WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, base->object);
2665   WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, CTX_wm_view3d(C));
2666   WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, ma);
2667
2668   return OPERATOR_FINISHED;
2669 }
2670
2671 /* used for dropbox */
2672 /* assigns to object under cursor, only first material slot */
2673 void OBJECT_OT_drop_named_material(wmOperatorType *ot)
2674 {
2675   /* identifiers */
2676   ot->name = "Drop Named Material on Object";
2677   ot->idname = "OBJECT_OT_drop_named_material";
2678
2679   /* api callbacks */
2680   ot->invoke = drop_named_material_invoke;
2681   ot->poll = ED_operator_objectmode;
2682
2683   /* flags */
2684   ot->flag = OPTYPE_UNDO | OPTYPE_INTERNAL;
2685
2686   /* properties */
2687   RNA_def_string(ot->srna, "name", "Material", MAX_ID_NAME - 2, "Name", "Material name to assign");
2688 }
2689
2690 /** \} */
2691
2692 /* ------------------------------------------------------------------- */
2693 /** \name Unlink Object Operator
2694  * \{ */
2695
2696 static int object_unlink_data_exec(bContext *C, wmOperator *op)
2697 {
2698   ID *id;
2699   PropertyPointerRNA pprop;
2700
2701   UI_context_active_but_prop_get_templateID(C, &pprop.ptr, &pprop.prop);
2702
2703   if (pprop.prop == NULL) {
2704     BKE_report(op->reports, RPT_ERROR, "Incorrect context for running object data unlink");
2705     return OPERATOR_CANCELLED;
2706   }
2707
2708   id = pprop.ptr.owner_id;
2709
2710   if (GS(id->name) == ID_OB) {
2711     Object *ob = (Object *)id;
2712     if (ob->data) {
2713       ID *id_data = ob->data;
2714
2715       if (GS(id_data->name) == ID_IM) {
2716         id_us_min(id_data);
2717         ob->data = NULL;
2718       }
2719       else {
2720         BKE_report(op->reports, RPT_ERROR, "Can't unlink this object data");
2721         return OPERATOR_CANCELLED;
2722       }
2723     }
2724   }
2725
2726   RNA_property_update(C, &pprop.ptr, pprop.prop);
2727
2728   return OPERATOR_FINISHED;
2729 }
2730
2731 /**
2732  * \note Only for empty-image objects, this operator is needed
2733  */
2734 void OBJECT_OT_unlink_data(wmOperatorType *ot)
2735 {
2736   /* identifiers */
2737   ot->name = "Unlink";
2738   ot->idname = "OBJECT_OT_unlink_data";
2739
2740   /* api callbacks */
2741   ot->exec = object_unlink_data_exec;
2742
2743   /* flags */
2744   ot->flag = OPTYPE_INTERNAL;
2745 }
2746
2747 /** \} */