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