Fix T81079: Switch object ignoring visibility settings
[blender.git] / source / blender / editors / object / object_add.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 <ctype.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_camera_types.h"
32 #include "DNA_collection_types.h"
33 #include "DNA_curve_types.h"
34 #include "DNA_gpencil_types.h"
35 #include "DNA_key_types.h"
36 #include "DNA_light_types.h"
37 #include "DNA_lightprobe_types.h"
38 #include "DNA_material_types.h"
39 #include "DNA_mesh_types.h"
40 #include "DNA_meta_types.h"
41 #include "DNA_object_fluidsim_types.h"
42 #include "DNA_object_force_types.h"
43 #include "DNA_object_types.h"
44 #include "DNA_pointcloud_types.h"
45 #include "DNA_scene_types.h"
46 #include "DNA_vfont_types.h"
47
48 #include "BLI_ghash.h"
49 #include "BLI_listbase.h"
50 #include "BLI_math.h"
51 #include "BLI_string.h"
52 #include "BLI_utildefines.h"
53
54 #include "BLT_translation.h"
55
56 #include "BKE_action.h"
57 #include "BKE_anim_data.h"
58 #include "BKE_armature.h"
59 #include "BKE_camera.h"
60 #include "BKE_collection.h"
61 #include "BKE_constraint.h"
62 #include "BKE_context.h"
63 #include "BKE_curve.h"
64 #include "BKE_displist.h"
65 #include "BKE_duplilist.h"
66 #include "BKE_effect.h"
67 #include "BKE_font.h"
68 #include "BKE_gpencil_curve.h"
69 #include "BKE_gpencil_geom.h"
70 #include "BKE_hair.h"
71 #include "BKE_key.h"
72 #include "BKE_lattice.h"
73 #include "BKE_layer.h"
74 #include "BKE_lib_id.h"
75 #include "BKE_lib_query.h"
76 #include "BKE_lib_remap.h"
77 #include "BKE_light.h"
78 #include "BKE_lightprobe.h"
79 #include "BKE_main.h"
80 #include "BKE_material.h"
81 #include "BKE_mball.h"
82 #include "BKE_mesh.h"
83 #include "BKE_mesh_runtime.h"
84 #include "BKE_nla.h"
85 #include "BKE_object.h"
86 #include "BKE_particle.h"
87 #include "BKE_pointcloud.h"
88 #include "BKE_report.h"
89 #include "BKE_scene.h"
90 #include "BKE_speaker.h"
91 #include "BKE_volume.h"
92
93 #include "DEG_depsgraph.h"
94 #include "DEG_depsgraph_build.h"
95 #include "DEG_depsgraph_query.h"
96
97 #include "RNA_access.h"
98 #include "RNA_define.h"
99 #include "RNA_enum_types.h"
100
101 #include "UI_interface.h"
102
103 #include "WM_api.h"
104 #include "WM_types.h"
105
106 #include "ED_armature.h"
107 #include "ED_curve.h"
108 #include "ED_gpencil.h"
109 #include "ED_mball.h"
110 #include "ED_mesh.h"
111 #include "ED_node.h"
112 #include "ED_object.h"
113 #include "ED_outliner.h"
114 #include "ED_physics.h"
115 #include "ED_render.h"
116 #include "ED_screen.h"
117 #include "ED_transform.h"
118 #include "ED_view3d.h"
119
120 #include "UI_resources.h"
121
122 #include "object_intern.h"
123
124 /* -------------------------------------------------------------------- */
125 /** \name Local Enum Declarations
126  * \{ */
127
128 /* this is an exact copy of the define in rna_light.c
129  * kept here because of linking order.
130  * Icons are only defined here */
131 const EnumPropertyItem rna_enum_light_type_items[] = {
132     {LA_LOCAL, "POINT", ICON_LIGHT_POINT, "Point", "Omnidirectional point light source"},
133     {LA_SUN, "SUN", ICON_LIGHT_SUN, "Sun", "Constant direction parallel ray light source"},
134     {LA_SPOT, "SPOT", ICON_LIGHT_SPOT, "Spot", "Directional cone light source"},
135     {LA_AREA, "AREA", ICON_LIGHT_AREA, "Area", "Directional area light source"},
136     {0, NULL, 0, NULL, NULL},
137 };
138
139 /* copy from rna_object_force.c */
140 static const EnumPropertyItem field_type_items[] = {
141     {PFIELD_FORCE, "FORCE", ICON_FORCE_FORCE, "Force", ""},
142     {PFIELD_WIND, "WIND", ICON_FORCE_WIND, "Wind", ""},
143     {PFIELD_VORTEX, "VORTEX", ICON_FORCE_VORTEX, "Vortex", ""},
144     {PFIELD_MAGNET, "MAGNET", ICON_FORCE_MAGNETIC, "Magnetic", ""},
145     {PFIELD_HARMONIC, "HARMONIC", ICON_FORCE_HARMONIC, "Harmonic", ""},
146     {PFIELD_CHARGE, "CHARGE", ICON_FORCE_CHARGE, "Charge", ""},
147     {PFIELD_LENNARDJ, "LENNARDJ", ICON_FORCE_LENNARDJONES, "Lennard-Jones", ""},
148     {PFIELD_TEXTURE, "TEXTURE", ICON_FORCE_TEXTURE, "Texture", ""},
149     {PFIELD_GUIDE, "GUIDE", ICON_FORCE_CURVE, "Curve Guide", ""},
150     {PFIELD_BOID, "BOID", ICON_FORCE_BOID, "Boid", ""},
151     {PFIELD_TURBULENCE, "TURBULENCE", ICON_FORCE_TURBULENCE, "Turbulence", ""},
152     {PFIELD_DRAG, "DRAG", ICON_FORCE_DRAG, "Drag", ""},
153     {PFIELD_FLUIDFLOW, "FLUID", ICON_FORCE_FLUIDFLOW, "Fluid Flow", ""},
154     {0, NULL, 0, NULL, NULL},
155 };
156
157 static EnumPropertyItem lightprobe_type_items[] = {
158     {LIGHTPROBE_TYPE_CUBE,
159      "CUBEMAP",
160      ICON_LIGHTPROBE_CUBEMAP,
161      "Reflection Cubemap",
162      "Reflection probe with spherical or cubic attenuation"},
163     {LIGHTPROBE_TYPE_PLANAR,
164      "PLANAR",
165      ICON_LIGHTPROBE_PLANAR,
166      "Reflection Plane",
167      "Planar reflection probe"},
168     {LIGHTPROBE_TYPE_GRID,
169      "GRID",
170      ICON_LIGHTPROBE_GRID,
171      "Irradiance Volume",
172      "Irradiance probe to capture diffuse indirect lighting"},
173     {0, NULL, 0, NULL, NULL},
174 };
175
176 enum {
177   ALIGN_WORLD = 0,
178   ALIGN_VIEW,
179   ALIGN_CURSOR,
180 };
181
182 static const EnumPropertyItem align_options[] = {
183     {ALIGN_WORLD, "WORLD", 0, "World", "Align the new object to the world"},
184     {ALIGN_VIEW, "VIEW", 0, "View", "Align the new object to the view"},
185     {ALIGN_CURSOR, "CURSOR", 0, "3D Cursor", "Use the 3D cursor orientation for the new object"},
186     {0, NULL, 0, NULL, NULL},
187 };
188
189 /** \} */
190
191 /* -------------------------------------------------------------------- */
192 /** \name Public Add Object API
193  *
194  * \{ */
195
196 void ED_object_location_from_view(bContext *C, float loc[3])
197 {
198   const Scene *scene = CTX_data_scene(C);
199   copy_v3_v3(loc, scene->cursor.location);
200 }
201
202 void ED_object_rotation_from_quat(float rot[3], const float viewquat[4], const char align_axis)
203 {
204   BLI_assert(align_axis >= 'X' && align_axis <= 'Z');
205
206   switch (align_axis) {
207     case 'X': {
208       /* Same as 'rv3d->viewinv[1]' */
209       const float axis_y[4] = {0.0f, 1.0f, 0.0f};
210       float quat_y[4], quat[4];
211       axis_angle_to_quat(quat_y, axis_y, M_PI_2);
212       mul_qt_qtqt(quat, viewquat, quat_y);
213       quat_to_eul(rot, quat);
214       break;
215     }
216     case 'Y': {
217       quat_to_eul(rot, viewquat);
218       rot[0] -= (float)M_PI_2;
219       break;
220     }
221     case 'Z': {
222       quat_to_eul(rot, viewquat);
223       break;
224     }
225   }
226 }
227
228 void ED_object_rotation_from_view(bContext *C, float rot[3], const char align_axis)
229 {
230   RegionView3D *rv3d = CTX_wm_region_view3d(C);
231   BLI_assert(align_axis >= 'X' && align_axis <= 'Z');
232   if (rv3d) {
233     float viewquat[4];
234     copy_qt_qt(viewquat, rv3d->viewquat);
235     viewquat[0] *= -1.0f;
236     ED_object_rotation_from_quat(rot, viewquat, align_axis);
237   }
238   else {
239     zero_v3(rot);
240   }
241 }
242
243 void ED_object_base_init_transform_on_add(Object *object, const float loc[3], const float rot[3])
244 {
245   if (loc) {
246     copy_v3_v3(object->loc, loc);
247   }
248
249   if (rot) {
250     copy_v3_v3(object->rot, rot);
251   }
252
253   BKE_object_to_mat4(object, object->obmat);
254 }
255
256 /* Uses context to figure out transform for primitive.
257  * Returns standard diameter. */
258 float ED_object_new_primitive_matrix(
259     bContext *C, Object *obedit, const float loc[3], const float rot[3], float r_primmat[4][4])
260 {
261   Scene *scene = CTX_data_scene(C);
262   View3D *v3d = CTX_wm_view3d(C);
263   float mat[3][3], rmat[3][3], cmat[3][3], imat[3][3];
264
265   unit_m4(r_primmat);
266
267   eul_to_mat3(rmat, rot);
268   invert_m3(rmat);
269
270   /* inverse transform for initial rotation and object */
271   copy_m3_m4(mat, obedit->obmat);
272   mul_m3_m3m3(cmat, rmat, mat);
273   invert_m3_m3(imat, cmat);
274   copy_m4_m3(r_primmat, imat);
275
276   /* center */
277   copy_v3_v3(r_primmat[3], loc);
278   sub_v3_v3v3(r_primmat[3], r_primmat[3], obedit->obmat[3]);
279   invert_m3_m3(imat, mat);
280   mul_m3_v3(imat, r_primmat[3]);
281
282   {
283     const float dia = v3d ? ED_view3d_grid_scale(scene, v3d, NULL) :
284                             ED_scene_grid_scale(scene, NULL);
285     return dia;
286   }
287
288   /* return 1.0f; */
289 }
290
291 /** \} */
292
293 /* -------------------------------------------------------------------- */
294 /** \name Add Object Operator
295  * \{ */
296
297 static void view_align_update(struct Main *UNUSED(main),
298                               struct Scene *UNUSED(scene),
299                               struct PointerRNA *ptr)
300 {
301   RNA_struct_idprops_unset(ptr, "rotation");
302 }
303
304 void ED_object_add_unit_props_size(wmOperatorType *ot)
305 {
306   RNA_def_float_distance(
307       ot->srna, "size", 2.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Size", "", 0.001, 100.00);
308 }
309
310 void ED_object_add_unit_props_radius_ex(wmOperatorType *ot, float default_value)
311 {
312   RNA_def_float_distance(
313       ot->srna, "radius", default_value, 0.0, OBJECT_ADD_SIZE_MAXF, "Radius", "", 0.001, 100.00);
314 }
315
316 void ED_object_add_unit_props_radius(wmOperatorType *ot)
317 {
318   ED_object_add_unit_props_radius_ex(ot, 1.0f);
319 }
320
321 void ED_object_add_generic_props(wmOperatorType *ot, bool do_editmode)
322 {
323   PropertyRNA *prop;
324
325   if (do_editmode) {
326     prop = RNA_def_boolean(
327         ot->srna, "enter_editmode", 0, "Enter Editmode", "Enter editmode when adding this object");
328     RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
329   }
330   /* note: this property gets hidden for add-camera operator */
331   prop = RNA_def_enum(
332       ot->srna, "align", align_options, ALIGN_WORLD, "Align", "The alignment of the new object");
333   RNA_def_property_update_runtime(prop, view_align_update);
334
335   prop = RNA_def_float_vector_xyz(ot->srna,
336                                   "location",
337                                   3,
338                                   NULL,
339                                   -OBJECT_ADD_SIZE_MAXF,
340                                   OBJECT_ADD_SIZE_MAXF,
341                                   "Location",
342                                   "Location for the newly added object",
343                                   -1000.0f,
344                                   1000.0f);
345   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
346   prop = RNA_def_float_rotation(ot->srna,
347                                 "rotation",
348                                 3,
349                                 NULL,
350                                 -OBJECT_ADD_SIZE_MAXF,
351                                 OBJECT_ADD_SIZE_MAXF,
352                                 "Rotation",
353                                 "Rotation for the newly added object",
354                                 DEG2RADF(-360.0f),
355                                 DEG2RADF(360.0f));
356   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
357
358   prop = RNA_def_float_vector_xyz(ot->srna,
359                                   "scale",
360                                   3,
361                                   NULL,
362                                   -OBJECT_ADD_SIZE_MAXF,
363                                   OBJECT_ADD_SIZE_MAXF,
364                                   "Scale",
365                                   "Scale for the newly added object",
366                                   -1000.0f,
367                                   1000.0f);
368   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
369 }
370
371 void ED_object_add_mesh_props(wmOperatorType *ot)
372 {
373   RNA_def_boolean(ot->srna, "calc_uvs", true, "Generate UVs", "Generate a default UV map");
374 }
375
376 bool ED_object_add_generic_get_opts(bContext *C,
377                                     wmOperator *op,
378                                     const char view_align_axis,
379                                     float loc[3],
380                                     float rot[3],
381                                     float scale[3],
382                                     bool *enter_editmode,
383                                     ushort *local_view_bits,
384                                     bool *is_view_aligned)
385 {
386   PropertyRNA *prop;
387
388   /* Switch to Edit mode? optional prop */
389   if ((prop = RNA_struct_find_property(op->ptr, "enter_editmode"))) {
390     bool _enter_editmode;
391     if (!enter_editmode) {
392       enter_editmode = &_enter_editmode;
393     }
394
395     if (RNA_property_is_set(op->ptr, prop) && enter_editmode) {
396       *enter_editmode = RNA_property_boolean_get(op->ptr, prop);
397     }
398     else {
399       *enter_editmode = (U.flag & USER_ADD_EDITMODE) != 0;
400       RNA_property_boolean_set(op->ptr, prop, *enter_editmode);
401     }
402   }
403
404   if (local_view_bits) {
405     View3D *v3d = CTX_wm_view3d(C);
406     if (v3d && v3d->localvd) {
407       *local_view_bits = v3d->local_view_uuid;
408     }
409   }
410
411   /* Location! */
412   {
413     float _loc[3];
414     if (!loc) {
415       loc = _loc;
416     }
417
418     if (RNA_struct_property_is_set(op->ptr, "location")) {
419       RNA_float_get_array(op->ptr, "location", loc);
420     }
421     else {
422       ED_object_location_from_view(C, loc);
423       RNA_float_set_array(op->ptr, "location", loc);
424     }
425   }
426
427   /* Rotation! */
428   {
429     bool _is_view_aligned;
430     float _rot[3];
431     if (!is_view_aligned) {
432       is_view_aligned = &_is_view_aligned;
433     }
434     if (!rot) {
435       rot = _rot;
436     }
437
438     if (RNA_struct_property_is_set(op->ptr, "rotation")) {
439       /* If rotation is set, always use it. Alignment (and corresponding user preference)
440        * can be ignored since this is in world space anyways.
441        * To not confuse (e.g. on redo), dont set it to ALIGN_WORLD in the op UI though. */
442       *is_view_aligned = false;
443       RNA_float_get_array(op->ptr, "rotation", rot);
444     }
445     else {
446       int alignment = ALIGN_WORLD;
447       prop = RNA_struct_find_property(op->ptr, "align");
448
449       if (RNA_property_is_set(op->ptr, prop)) {
450         /* If alignment is set, always use it. */
451         *is_view_aligned = alignment == ALIGN_VIEW;
452         alignment = RNA_property_enum_get(op->ptr, prop);
453       }
454       else {
455         /* If alignment is not set, use User Preferences. */
456         *is_view_aligned = (U.flag & USER_ADD_VIEWALIGNED) != 0;
457         if (*is_view_aligned) {
458           RNA_property_enum_set(op->ptr, prop, ALIGN_VIEW);
459           alignment = ALIGN_VIEW;
460         }
461         else if ((U.flag & USER_ADD_CURSORALIGNED) != 0) {
462           RNA_property_enum_set(op->ptr, prop, ALIGN_CURSOR);
463           alignment = ALIGN_CURSOR;
464         }
465         else {
466           RNA_property_enum_set(op->ptr, prop, ALIGN_WORLD);
467           alignment = ALIGN_WORLD;
468         }
469       }
470       switch (alignment) {
471         case ALIGN_WORLD:
472           RNA_float_get_array(op->ptr, "rotation", rot);
473           break;
474         case ALIGN_VIEW:
475           ED_object_rotation_from_view(C, rot, view_align_axis);
476           RNA_float_set_array(op->ptr, "rotation", rot);
477           break;
478         case ALIGN_CURSOR: {
479           const Scene *scene = CTX_data_scene(C);
480           float tmat[3][3];
481           BKE_scene_cursor_rot_to_mat3(&scene->cursor, tmat);
482           mat3_normalized_to_eul(rot, tmat);
483           RNA_float_set_array(op->ptr, "rotation", rot);
484           break;
485         }
486       }
487     }
488   }
489
490   /* Scale! */
491   {
492     float _scale[3];
493     if (!scale) {
494       scale = _scale;
495     }
496
497     /* For now this is optional, we can make it always use. */
498     copy_v3_fl(scale, 1.0f);
499     if ((prop = RNA_struct_find_property(op->ptr, "scale"))) {
500       if (RNA_property_is_set(op->ptr, prop)) {
501         RNA_property_float_get_array(op->ptr, prop, scale);
502       }
503       else {
504         copy_v3_fl(scale, 1.0f);
505         RNA_property_float_set_array(op->ptr, prop, scale);
506       }
507     }
508   }
509
510   return true;
511 }
512
513 /**
514  * For object add primitive operators, or for object creation when `obdata != NULL`.
515  * \param obdata: Assigned to #Object.data, with increased user count.
516  *
517  * \note Do not call undo push in this function (users of this function have to).
518  */
519 Object *ED_object_add_type_with_obdata(bContext *C,
520                                        const int type,
521                                        const char *name,
522                                        const float loc[3],
523                                        const float rot[3],
524                                        const bool enter_editmode,
525                                        const ushort local_view_bits,
526                                        ID *obdata)
527 {
528   Main *bmain = CTX_data_main(C);
529   Scene *scene = CTX_data_scene(C);
530   ViewLayer *view_layer = CTX_data_view_layer(C);
531
532   /* For as long scene has editmode... */
533   {
534     Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
535     if (obedit != NULL) {
536       ED_object_editmode_exit_ex(bmain, scene, obedit, EM_FREEDATA);
537     }
538   }
539
540   /* deselects all, sets active object */
541   Object *ob;
542   if (obdata != NULL) {
543     BLI_assert(type == BKE_object_obdata_to_type(obdata));
544     ob = BKE_object_add_for_data(bmain, view_layer, type, name, obdata, true);
545     const short *materials_len_p = BKE_id_material_len_p(obdata);
546     if (materials_len_p && *materials_len_p > 0) {
547       BKE_object_materials_test(bmain, ob, ob->data);
548     }
549   }
550   else {
551     ob = BKE_object_add(bmain, view_layer, type, name);
552   }
553   BASACT(view_layer)->local_view_bits = local_view_bits;
554   /* editor level activate, notifiers */
555   ED_object_base_activate(C, view_layer->basact);
556
557   /* more editor stuff */
558   ED_object_base_init_transform_on_add(ob, loc, rot);
559
560   /* TODO(sergey): This is weird to manually tag objects for update, better to
561    * use DEG_id_tag_update here perhaps.
562    */
563   DEG_id_type_tag(bmain, ID_OB);
564   DEG_relations_tag_update(bmain);
565   if (ob->data != NULL) {
566     DEG_id_tag_update_ex(bmain, (ID *)ob->data, ID_RECALC_EDITORS);
567   }
568
569   if (enter_editmode) {
570     ED_object_editmode_enter_ex(bmain, scene, ob, 0);
571   }
572
573   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
574
575   /* TODO(sergey): Use proper flag for tagging here. */
576   DEG_id_tag_update(&scene->id, 0);
577
578   ED_outliner_select_sync_from_object_tag(C);
579
580   return ob;
581 }
582
583 Object *ED_object_add_type(bContext *C,
584                            const int type,
585                            const char *name,
586                            const float loc[3],
587                            const float rot[3],
588                            const bool enter_editmode,
589                            const ushort local_view_bits)
590 {
591   return ED_object_add_type_with_obdata(
592       C, type, name, loc, rot, enter_editmode, local_view_bits, NULL);
593 }
594
595 /* for object add operator */
596 static int object_add_exec(bContext *C, wmOperator *op)
597 {
598   ushort local_view_bits;
599   bool enter_editmode;
600   float loc[3], rot[3], radius;
601   WM_operator_view3d_unit_defaults(C, op);
602   if (!ED_object_add_generic_get_opts(
603           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
604     return OPERATOR_CANCELLED;
605   }
606   radius = RNA_float_get(op->ptr, "radius");
607   Object *ob = ED_object_add_type(
608       C, RNA_enum_get(op->ptr, "type"), NULL, loc, rot, enter_editmode, local_view_bits);
609
610   if (ob->type == OB_LATTICE) {
611     /* lattice is a special case!
612      * we never want to scale the obdata since that is the rest-state */
613     copy_v3_fl(ob->scale, radius);
614   }
615   else {
616     BKE_object_obdata_size_init(ob, radius);
617   }
618
619   return OPERATOR_FINISHED;
620 }
621
622 void OBJECT_OT_add(wmOperatorType *ot)
623 {
624   /* identifiers */
625   ot->name = "Add Object";
626   ot->description = "Add an object to the scene";
627   ot->idname = "OBJECT_OT_add";
628
629   /* api callbacks */
630   ot->exec = object_add_exec;
631   ot->poll = ED_operator_objectmode;
632
633   /* flags */
634   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
635
636   /* properties */
637   ED_object_add_unit_props_radius(ot);
638   PropertyRNA *prop = RNA_def_enum(ot->srna, "type", rna_enum_object_type_items, 0, "Type", "");
639   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ID);
640
641   ED_object_add_generic_props(ot, true);
642 }
643
644 /** \} */
645
646 /* -------------------------------------------------------------------- */
647 /** \name Add Probe Operator
648  * \{ */
649
650 /* for object add operator */
651 static const char *get_lightprobe_defname(int type)
652 {
653   switch (type) {
654     case LIGHTPROBE_TYPE_GRID:
655       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "IrradianceVolume");
656     case LIGHTPROBE_TYPE_PLANAR:
657       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "ReflectionPlane");
658     case LIGHTPROBE_TYPE_CUBE:
659       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "ReflectionCubemap");
660     default:
661       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "LightProbe");
662   }
663 }
664
665 static int lightprobe_add_exec(bContext *C, wmOperator *op)
666 {
667   bool enter_editmode;
668   ushort local_view_bits;
669   float loc[3], rot[3];
670   WM_operator_view3d_unit_defaults(C, op);
671   if (!ED_object_add_generic_get_opts(
672           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
673     return OPERATOR_CANCELLED;
674   }
675   int type = RNA_enum_get(op->ptr, "type");
676   float radius = RNA_float_get(op->ptr, "radius");
677
678   Object *ob = ED_object_add_type(
679       C, OB_LIGHTPROBE, get_lightprobe_defname(type), loc, rot, false, local_view_bits);
680   copy_v3_fl(ob->scale, radius);
681
682   LightProbe *probe = (LightProbe *)ob->data;
683
684   BKE_lightprobe_type_set(probe, type);
685
686   DEG_relations_tag_update(CTX_data_main(C));
687
688   return OPERATOR_FINISHED;
689 }
690
691 void OBJECT_OT_lightprobe_add(wmOperatorType *ot)
692 {
693   /* identifiers */
694   ot->name = "Add Light Probe";
695   ot->description = "Add a light probe object";
696   ot->idname = "OBJECT_OT_lightprobe_add";
697
698   /* api callbacks */
699   ot->exec = lightprobe_add_exec;
700   ot->poll = ED_operator_objectmode;
701
702   /* flags */
703   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
704
705   /* properties */
706   ot->prop = RNA_def_enum(ot->srna, "type", lightprobe_type_items, 0, "Type", "");
707
708   ED_object_add_unit_props_radius(ot);
709   ED_object_add_generic_props(ot, true);
710 }
711
712 /** \} */
713
714 /* -------------------------------------------------------------------- */
715 /** \name Add Effector Operator
716  * \{ */
717
718 /* for object add operator */
719
720 static const char *get_effector_defname(ePFieldType type)
721 {
722   switch (type) {
723     case PFIELD_FORCE:
724       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Force");
725     case PFIELD_VORTEX:
726       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Vortex");
727     case PFIELD_MAGNET:
728       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Magnet");
729     case PFIELD_WIND:
730       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Wind");
731     case PFIELD_GUIDE:
732       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "CurveGuide");
733     case PFIELD_TEXTURE:
734       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "TextureField");
735     case PFIELD_HARMONIC:
736       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Harmonic");
737     case PFIELD_CHARGE:
738       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Charge");
739     case PFIELD_LENNARDJ:
740       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Lennard-Jones");
741     case PFIELD_BOID:
742       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Boid");
743     case PFIELD_TURBULENCE:
744       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Turbulence");
745     case PFIELD_DRAG:
746       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Drag");
747     case PFIELD_FLUIDFLOW:
748       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "FluidField");
749     case PFIELD_NULL:
750       return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Field");
751     case NUM_PFIELD_TYPES:
752       break;
753   }
754
755   BLI_assert(false);
756   return CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Field");
757 }
758
759 static int effector_add_exec(bContext *C, wmOperator *op)
760 {
761   bool enter_editmode;
762   ushort local_view_bits;
763   float loc[3], rot[3];
764   WM_operator_view3d_unit_defaults(C, op);
765   if (!ED_object_add_generic_get_opts(
766           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
767     return OPERATOR_CANCELLED;
768   }
769   int type = RNA_enum_get(op->ptr, "type");
770   float dia = RNA_float_get(op->ptr, "radius");
771
772   Object *ob;
773   if (type == PFIELD_GUIDE) {
774     Main *bmain = CTX_data_main(C);
775     Scene *scene = CTX_data_scene(C);
776     Curve *cu;
777     ob = ED_object_add_type(
778         C, OB_CURVE, get_effector_defname(type), loc, rot, false, local_view_bits);
779
780     cu = ob->data;
781     cu->flag |= CU_PATH | CU_3D;
782     ED_object_editmode_enter_ex(bmain, scene, ob, 0);
783
784     float mat[4][4];
785     ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
786     BLI_addtail(&cu->editnurb->nurbs,
787                 ED_curve_add_nurbs_primitive(C, ob, mat, CU_NURBS | CU_PRIM_PATH, dia));
788     if (!enter_editmode) {
789       ED_object_editmode_exit_ex(bmain, scene, ob, EM_FREEDATA);
790     }
791   }
792   else {
793     ob = ED_object_add_type(
794         C, OB_EMPTY, get_effector_defname(type), loc, rot, false, local_view_bits);
795     BKE_object_obdata_size_init(ob, dia);
796     if (ELEM(type, PFIELD_WIND, PFIELD_VORTEX)) {
797       ob->empty_drawtype = OB_SINGLE_ARROW;
798     }
799   }
800
801   ob->pd = BKE_partdeflect_new(type);
802
803   DEG_relations_tag_update(CTX_data_main(C));
804
805   return OPERATOR_FINISHED;
806 }
807
808 void OBJECT_OT_effector_add(wmOperatorType *ot)
809 {
810   /* identifiers */
811   ot->name = "Add Effector";
812   ot->description = "Add an empty object with a physics effector to the scene";
813   ot->idname = "OBJECT_OT_effector_add";
814
815   /* api callbacks */
816   ot->exec = effector_add_exec;
817   ot->poll = ED_operator_objectmode;
818
819   /* flags */
820   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
821
822   /* properties */
823   ot->prop = RNA_def_enum(ot->srna, "type", field_type_items, 0, "Type", "");
824
825   ED_object_add_unit_props_radius(ot);
826   ED_object_add_generic_props(ot, true);
827 }
828
829 /** \} */
830
831 /* -------------------------------------------------------------------- */
832 /** \name Add Camera Operator
833  * \{ */
834
835 static int object_camera_add_exec(bContext *C, wmOperator *op)
836 {
837   View3D *v3d = CTX_wm_view3d(C);
838   Scene *scene = CTX_data_scene(C);
839
840   /* force view align for cameras */
841   RNA_enum_set(op->ptr, "align", ALIGN_VIEW);
842
843   ushort local_view_bits;
844   bool enter_editmode;
845   float loc[3], rot[3];
846   if (!ED_object_add_generic_get_opts(
847           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
848     return OPERATOR_CANCELLED;
849   }
850   Object *ob = ED_object_add_type(C, OB_CAMERA, NULL, loc, rot, false, local_view_bits);
851
852   if (v3d) {
853     if (v3d->camera == NULL) {
854       v3d->camera = ob;
855     }
856     if (v3d->scenelock && scene->camera == NULL) {
857       scene->camera = ob;
858     }
859   }
860
861   Camera *cam = ob->data;
862   cam->drawsize = v3d ? ED_view3d_grid_scale(scene, v3d, NULL) : ED_scene_grid_scale(scene, NULL);
863
864   return OPERATOR_FINISHED;
865 }
866
867 void OBJECT_OT_camera_add(wmOperatorType *ot)
868 {
869   PropertyRNA *prop;
870
871   /* identifiers */
872   ot->name = "Add Camera";
873   ot->description = "Add a camera object to the scene";
874   ot->idname = "OBJECT_OT_camera_add";
875
876   /* api callbacks */
877   ot->exec = object_camera_add_exec;
878   ot->poll = ED_operator_objectmode;
879
880   /* flags */
881   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
882
883   ED_object_add_generic_props(ot, true);
884
885   /* hide this for cameras, default */
886   prop = RNA_struct_type_find_property(ot->srna, "align");
887   RNA_def_property_flag(prop, PROP_HIDDEN);
888 }
889
890 /** \} */
891
892 /* -------------------------------------------------------------------- */
893 /** \name Add Metaball Operator
894  * \{ */
895
896 static int object_metaball_add_exec(bContext *C, wmOperator *op)
897 {
898   Main *bmain = CTX_data_main(C);
899   Scene *scene = CTX_data_scene(C);
900   ViewLayer *view_layer = CTX_data_view_layer(C);
901
902   ushort local_view_bits;
903   bool enter_editmode;
904   float loc[3], rot[3];
905   WM_operator_view3d_unit_defaults(C, op);
906   if (!ED_object_add_generic_get_opts(
907           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
908     return OPERATOR_CANCELLED;
909   }
910
911   bool newob = false;
912   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
913   if (obedit == NULL || obedit->type != OB_MBALL) {
914     obedit = ED_object_add_type(C, OB_MBALL, NULL, loc, rot, true, local_view_bits);
915     newob = true;
916   }
917   else {
918     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
919   }
920
921   float mat[4][4];
922   ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
923   /* Halving here is done to account for constant values from #BKE_mball_element_add.
924    * While the default radius of the resulting meta element is 2,
925    * we want to pass in 1 so other values such as resolution are scaled by 1.0. */
926   float dia = RNA_float_get(op->ptr, "radius") / 2;
927
928   ED_mball_add_primitive(C, obedit, newob, mat, dia, RNA_enum_get(op->ptr, "type"));
929
930   /* userdef */
931   if (newob && !enter_editmode) {
932     ED_object_editmode_exit_ex(bmain, scene, obedit, EM_FREEDATA);
933   }
934
935   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
936
937   return OPERATOR_FINISHED;
938 }
939
940 void OBJECT_OT_metaball_add(wmOperatorType *ot)
941 {
942   /* identifiers */
943   ot->name = "Add Metaball";
944   ot->description = "Add an metaball object to the scene";
945   ot->idname = "OBJECT_OT_metaball_add";
946
947   /* api callbacks */
948   ot->invoke = WM_menu_invoke;
949   ot->exec = object_metaball_add_exec;
950   ot->poll = ED_operator_scene_editable;
951
952   /* flags */
953   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
954
955   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_metaelem_type_items, 0, "Primitive", "");
956
957   ED_object_add_unit_props_radius_ex(ot, 2.0f);
958   ED_object_add_generic_props(ot, true);
959 }
960
961 /** \} */
962
963 /* -------------------------------------------------------------------- */
964 /** \name Add Text Operator
965  * \{ */
966
967 static int object_add_text_exec(bContext *C, wmOperator *op)
968 {
969   Object *obedit = CTX_data_edit_object(C);
970   bool enter_editmode;
971   ushort local_view_bits;
972   float loc[3], rot[3];
973
974   WM_operator_view3d_unit_defaults(C, op);
975   if (!ED_object_add_generic_get_opts(
976           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
977     return OPERATOR_CANCELLED;
978   }
979   if (obedit && obedit->type == OB_FONT) {
980     return OPERATOR_CANCELLED;
981   }
982
983   obedit = ED_object_add_type(C, OB_FONT, NULL, loc, rot, enter_editmode, local_view_bits);
984   BKE_object_obdata_size_init(obedit, RNA_float_get(op->ptr, "radius"));
985
986   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
987
988   return OPERATOR_FINISHED;
989 }
990
991 void OBJECT_OT_text_add(wmOperatorType *ot)
992 {
993   /* identifiers */
994   ot->name = "Add Text";
995   ot->description = "Add a text object to the scene";
996   ot->idname = "OBJECT_OT_text_add";
997
998   /* api callbacks */
999   ot->exec = object_add_text_exec;
1000   ot->poll = ED_operator_objectmode;
1001
1002   /* flags */
1003   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1004
1005   /* properties */
1006   ED_object_add_unit_props_radius(ot);
1007   ED_object_add_generic_props(ot, true);
1008 }
1009
1010 /** \} */
1011
1012 /* -------------------------------------------------------------------- */
1013 /** \name Add Armature Operator
1014  * \{ */
1015
1016 static int object_armature_add_exec(bContext *C, wmOperator *op)
1017 {
1018   Main *bmain = CTX_data_main(C);
1019   Scene *scene = CTX_data_scene(C);
1020   ViewLayer *view_layer = CTX_data_view_layer(C);
1021   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
1022
1023   RegionView3D *rv3d = CTX_wm_region_view3d(C);
1024   bool newob = false;
1025   bool enter_editmode;
1026   ushort local_view_bits;
1027   float loc[3], rot[3], dia;
1028   bool view_aligned = rv3d && (U.flag & USER_ADD_VIEWALIGNED);
1029
1030   WM_operator_view3d_unit_defaults(C, op);
1031   if (!ED_object_add_generic_get_opts(
1032           C, op, 'Z', loc, rot, NULL, &enter_editmode, &local_view_bits, NULL)) {
1033     return OPERATOR_CANCELLED;
1034   }
1035   if ((obedit == NULL) || (obedit->type != OB_ARMATURE)) {
1036     obedit = ED_object_add_type(C, OB_ARMATURE, NULL, loc, rot, true, local_view_bits);
1037     ED_object_editmode_enter_ex(bmain, scene, obedit, 0);
1038     newob = true;
1039   }
1040   else {
1041     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
1042   }
1043
1044   if (obedit == NULL) {
1045     BKE_report(op->reports, RPT_ERROR, "Cannot create editmode armature");
1046     return OPERATOR_CANCELLED;
1047   }
1048
1049   dia = RNA_float_get(op->ptr, "radius");
1050   ED_armature_ebone_add_primitive(obedit, dia, view_aligned);
1051
1052   /* userdef */
1053   if (newob && !enter_editmode) {
1054     ED_object_editmode_exit_ex(bmain, scene, obedit, EM_FREEDATA);
1055   }
1056
1057   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
1058
1059   return OPERATOR_FINISHED;
1060 }
1061
1062 void OBJECT_OT_armature_add(wmOperatorType *ot)
1063 {
1064   /* identifiers */
1065   ot->name = "Add Armature";
1066   ot->description = "Add an armature object to the scene";
1067   ot->idname = "OBJECT_OT_armature_add";
1068
1069   /* api callbacks */
1070   ot->exec = object_armature_add_exec;
1071   ot->poll = ED_operator_objectmode;
1072
1073   /* flags */
1074   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1075
1076   /* properties */
1077   ED_object_add_unit_props_radius(ot);
1078   ED_object_add_generic_props(ot, true);
1079 }
1080
1081 /** \} */
1082
1083 /* -------------------------------------------------------------------- */
1084 /** \name Add Empty Operator
1085  * \{ */
1086
1087 static int object_empty_add_exec(bContext *C, wmOperator *op)
1088 {
1089   Object *ob;
1090   int type = RNA_enum_get(op->ptr, "type");
1091   ushort local_view_bits;
1092   float loc[3], rot[3];
1093
1094   WM_operator_view3d_unit_defaults(C, op);
1095   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1096     return OPERATOR_CANCELLED;
1097   }
1098   ob = ED_object_add_type(C, OB_EMPTY, NULL, loc, rot, false, local_view_bits);
1099
1100   BKE_object_empty_draw_type_set(ob, type);
1101   BKE_object_obdata_size_init(ob, RNA_float_get(op->ptr, "radius"));
1102
1103   return OPERATOR_FINISHED;
1104 }
1105
1106 void OBJECT_OT_empty_add(wmOperatorType *ot)
1107 {
1108   /* identifiers */
1109   ot->name = "Add Empty";
1110   ot->description = "Add an empty object to the scene";
1111   ot->idname = "OBJECT_OT_empty_add";
1112
1113   /* api callbacks */
1114   ot->invoke = WM_menu_invoke;
1115   ot->exec = object_empty_add_exec;
1116   ot->poll = ED_operator_objectmode;
1117
1118   /* flags */
1119   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1120
1121   /* properties */
1122   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_object_empty_drawtype_items, 0, "Type", "");
1123
1124   ED_object_add_unit_props_radius(ot);
1125   ED_object_add_generic_props(ot, false);
1126 }
1127
1128 static int empty_drop_named_image_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1129 {
1130   Scene *scene = CTX_data_scene(C);
1131
1132   Image *ima = NULL;
1133
1134   ima = (Image *)WM_operator_drop_load_path(C, op, ID_IM);
1135   if (!ima) {
1136     return OPERATOR_CANCELLED;
1137   }
1138   /* handled below */
1139   id_us_min(&ima->id);
1140
1141   Object *ob = NULL;
1142   Object *ob_cursor = ED_view3d_give_object_under_cursor(C, event->mval);
1143
1144   /* either change empty under cursor or create a new empty */
1145   if (ob_cursor && ob_cursor->type == OB_EMPTY) {
1146     WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1147     DEG_id_tag_update((ID *)ob_cursor, ID_RECALC_TRANSFORM);
1148     ob = ob_cursor;
1149   }
1150   else {
1151     /* add new empty */
1152     ushort local_view_bits;
1153     float rot[3];
1154
1155     if (!ED_object_add_generic_get_opts(
1156             C, op, 'Z', NULL, rot, NULL, NULL, &local_view_bits, NULL)) {
1157       return OPERATOR_CANCELLED;
1158     }
1159     ob = ED_object_add_type(C, OB_EMPTY, NULL, NULL, rot, false, local_view_bits);
1160
1161     ED_object_location_from_view(C, ob->loc);
1162     ED_view3d_cursor3d_position(C, event->mval, false, ob->loc);
1163     ED_object_rotation_from_view(C, ob->rot, 'Z');
1164     ob->empty_drawsize = 5.0f;
1165   }
1166
1167   BKE_object_empty_draw_type_set(ob, OB_EMPTY_IMAGE);
1168
1169   id_us_min(ob->data);
1170   ob->data = ima;
1171   id_us_plus(ob->data);
1172
1173   return OPERATOR_FINISHED;
1174 }
1175
1176 void OBJECT_OT_drop_named_image(wmOperatorType *ot)
1177 {
1178   PropertyRNA *prop;
1179
1180   /* identifiers */
1181   ot->name = "Add Empty Image/Drop Image to Empty";
1182   ot->description = "Add an empty image type to scene with data";
1183   ot->idname = "OBJECT_OT_drop_named_image";
1184
1185   /* api callbacks */
1186   ot->invoke = empty_drop_named_image_invoke;
1187   ot->poll = ED_operator_objectmode;
1188
1189   /* flags */
1190   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1191
1192   /* properties */
1193   prop = RNA_def_string(ot->srna, "filepath", NULL, FILE_MAX, "Filepath", "Path to image file");
1194   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1195   RNA_def_boolean(ot->srna,
1196                   "relative_path",
1197                   true,
1198                   "Relative Path",
1199                   "Select the file relative to the blend file");
1200   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1201   prop = RNA_def_string(ot->srna, "name", NULL, MAX_ID_NAME - 2, "Name", "Image name to assign");
1202   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1203   ED_object_add_generic_props(ot, false);
1204 }
1205
1206 /** \} */
1207
1208 /* -------------------------------------------------------------------- */
1209 /** \name Add Gpencil Operator
1210  * \{ */
1211
1212 static bool object_gpencil_add_poll(bContext *C)
1213 {
1214   Scene *scene = CTX_data_scene(C);
1215   Object *obact = CTX_data_active_object(C);
1216
1217   if ((scene == NULL) || (ID_IS_LINKED(scene))) {
1218     return false;
1219   }
1220
1221   if (obact && obact->type == OB_GPENCIL) {
1222     if (obact->mode != OB_MODE_OBJECT) {
1223       return false;
1224     }
1225   }
1226
1227   return true;
1228 }
1229
1230 static int object_gpencil_add_exec(bContext *C, wmOperator *op)
1231 {
1232   Object *ob = CTX_data_active_object(C);
1233   bGPdata *gpd = (ob && (ob->type == OB_GPENCIL)) ? ob->data : NULL;
1234
1235   const int type = RNA_enum_get(op->ptr, "type");
1236
1237   ushort local_view_bits;
1238   float loc[3], rot[3];
1239   bool newob = false;
1240
1241   /* Note: We use 'Y' here (not 'Z'), as */
1242   WM_operator_view3d_unit_defaults(C, op);
1243   if (!ED_object_add_generic_get_opts(C, op, 'Y', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1244     return OPERATOR_CANCELLED;
1245   }
1246   /* add new object if not currently editing a GP object,
1247    * or if "empty" was chosen (i.e. user wants a blank GP canvas)
1248    */
1249   if ((gpd == NULL) || (GPENCIL_ANY_MODE(gpd) == false) || (type == GP_EMPTY)) {
1250     const char *ob_name = NULL;
1251     switch (type) {
1252       case GP_MONKEY: {
1253         ob_name = "Suzanne";
1254         break;
1255       }
1256       case GP_STROKE: {
1257         ob_name = "Stroke";
1258         break;
1259       }
1260       default: {
1261         break;
1262       }
1263     }
1264
1265     ob = ED_object_add_type(C, OB_GPENCIL, ob_name, loc, rot, true, local_view_bits);
1266     gpd = ob->data;
1267     newob = true;
1268   }
1269   else {
1270     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1271     WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_ADDED, NULL);
1272   }
1273
1274   /* create relevant geometry */
1275   switch (type) {
1276     case GP_STROKE: {
1277       float radius = RNA_float_get(op->ptr, "radius");
1278       float mat[4][4];
1279
1280       ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
1281       mul_v3_fl(mat[0], radius);
1282       mul_v3_fl(mat[1], radius);
1283       mul_v3_fl(mat[2], radius);
1284
1285       ED_gpencil_create_stroke(C, ob, mat);
1286       break;
1287     }
1288     case GP_MONKEY: {
1289       float radius = RNA_float_get(op->ptr, "radius");
1290       float mat[4][4];
1291
1292       ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
1293       mul_v3_fl(mat[0], radius);
1294       mul_v3_fl(mat[1], radius);
1295       mul_v3_fl(mat[2], radius);
1296
1297       ED_gpencil_create_monkey(C, ob, mat);
1298       break;
1299     }
1300     case GP_EMPTY:
1301       /* do nothing */
1302       break;
1303
1304     default:
1305       BKE_report(op->reports, RPT_WARNING, "Not implemented");
1306       break;
1307   }
1308
1309   /* If this is a new object, initialize default stuff (colors, etc.) */
1310   if (newob) {
1311     /* set default viewport color to black */
1312     copy_v3_fl(ob->color, 0.0f);
1313
1314     ED_gpencil_add_defaults(C, ob);
1315   }
1316
1317   return OPERATOR_FINISHED;
1318 }
1319
1320 void OBJECT_OT_gpencil_add(wmOperatorType *ot)
1321 {
1322   /* identifiers */
1323   ot->name = "Add Grease Pencil";
1324   ot->description = "Add a Grease Pencil object to the scene";
1325   ot->idname = "OBJECT_OT_gpencil_add";
1326
1327   /* api callbacks */
1328   ot->invoke = WM_menu_invoke;
1329   ot->exec = object_gpencil_add_exec;
1330   ot->poll = object_gpencil_add_poll;
1331
1332   /* flags */
1333   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1334
1335   /* properties */
1336   ED_object_add_unit_props_radius(ot);
1337   ED_object_add_generic_props(ot, false);
1338
1339   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_object_gpencil_type_items, 0, "Type", "");
1340 }
1341
1342 /** \} */
1343
1344 /* -------------------------------------------------------------------- */
1345 /** \name Add Light Operator
1346  * \{ */
1347
1348 static const char *get_light_defname(int type)
1349 {
1350   switch (type) {
1351     case LA_LOCAL:
1352       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Point");
1353     case LA_SUN:
1354       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Sun");
1355     case LA_SPOT:
1356       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Spot");
1357     case LA_AREA:
1358       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Area");
1359     default:
1360       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Light");
1361   }
1362 }
1363
1364 static int object_light_add_exec(bContext *C, wmOperator *op)
1365 {
1366   Object *ob;
1367   Light *la;
1368   int type = RNA_enum_get(op->ptr, "type");
1369   ushort local_view_bits;
1370   float loc[3], rot[3];
1371
1372   WM_operator_view3d_unit_defaults(C, op);
1373   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1374     return OPERATOR_CANCELLED;
1375   }
1376   ob = ED_object_add_type(C, OB_LAMP, get_light_defname(type), loc, rot, false, local_view_bits);
1377
1378   float size = RNA_float_get(op->ptr, "radius");
1379   /* Better defaults for light size. */
1380   switch (type) {
1381     case LA_LOCAL:
1382     case LA_SPOT:
1383       break;
1384     case LA_AREA:
1385       size *= 4.0f;
1386       break;
1387     default:
1388       size *= 0.5f;
1389       break;
1390   }
1391   BKE_object_obdata_size_init(ob, size);
1392
1393   la = (Light *)ob->data;
1394   la->type = type;
1395
1396   if (type == LA_SUN) {
1397     la->energy = 1.0f;
1398   }
1399
1400   return OPERATOR_FINISHED;
1401 }
1402
1403 void OBJECT_OT_light_add(wmOperatorType *ot)
1404 {
1405   /* identifiers */
1406   ot->name = "Add Light";
1407   ot->description = "Add a light object to the scene";
1408   ot->idname = "OBJECT_OT_light_add";
1409
1410   /* api callbacks */
1411   ot->invoke = WM_menu_invoke;
1412   ot->exec = object_light_add_exec;
1413   ot->poll = ED_operator_objectmode;
1414
1415   /* flags */
1416   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1417
1418   /* properties */
1419   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_light_type_items, 0, "Type", "");
1420   RNA_def_property_translation_context(ot->prop, BLT_I18NCONTEXT_ID_LIGHT);
1421
1422   ED_object_add_unit_props_radius(ot);
1423   ED_object_add_generic_props(ot, false);
1424 }
1425
1426 /** \} */
1427
1428 /* -------------------------------------------------------------------- */
1429 /** \name Add Collection Instance Operator
1430  * \{ */
1431
1432 static int collection_instance_add_exec(bContext *C, wmOperator *op)
1433 {
1434   Main *bmain = CTX_data_main(C);
1435   Collection *collection;
1436   ushort local_view_bits;
1437   float loc[3], rot[3];
1438
1439   PropertyRNA *prop_name = RNA_struct_find_property(op->ptr, "name");
1440   PropertyRNA *prop_location = RNA_struct_find_property(op->ptr, "location");
1441
1442   if (RNA_property_is_set(op->ptr, prop_name)) {
1443     char name[MAX_ID_NAME - 2];
1444     RNA_property_string_get(op->ptr, prop_name, name);
1445     collection = (Collection *)BKE_libblock_find_name(bmain, ID_GR, name);
1446
1447     if (!RNA_property_is_set(op->ptr, prop_location)) {
1448       const wmEvent *event = CTX_wm_window(C)->eventstate;
1449       ARegion *region = CTX_wm_region(C);
1450       const int mval[2] = {event->x - region->winrct.xmin, event->y - region->winrct.ymin};
1451       ED_object_location_from_view(C, loc);
1452       ED_view3d_cursor3d_position(C, mval, false, loc);
1453       RNA_property_float_set_array(op->ptr, prop_location, loc);
1454     }
1455   }
1456   else {
1457     collection = BLI_findlink(&bmain->collections, RNA_enum_get(op->ptr, "collection"));
1458   }
1459
1460   if (collection == NULL) {
1461     return OPERATOR_CANCELLED;
1462   }
1463
1464   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1465     return OPERATOR_CANCELLED;
1466   }
1467
1468   Scene *scene = CTX_data_scene(C);
1469   ViewLayer *view_layer = CTX_data_view_layer(C);
1470
1471   /* Avoid dependency cycles. */
1472   LayerCollection *active_lc = BKE_layer_collection_get_active(view_layer);
1473   while (BKE_collection_cycle_find(active_lc->collection, collection)) {
1474     active_lc = BKE_layer_collection_activate_parent(view_layer, active_lc);
1475   }
1476
1477   Object *ob = ED_object_add_type(
1478       C, OB_EMPTY, collection->id.name + 2, loc, rot, false, local_view_bits);
1479   ob->instance_collection = collection;
1480   ob->empty_drawsize = U.collection_instance_empty_size;
1481   ob->transflag |= OB_DUPLICOLLECTION;
1482   id_us_plus(&collection->id);
1483
1484   /* works without this except if you try render right after, see: 22027 */
1485   DEG_relations_tag_update(bmain);
1486   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
1487   WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1488   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
1489
1490   return OPERATOR_FINISHED;
1491 }
1492
1493 /* only used as menu */
1494 void OBJECT_OT_collection_instance_add(wmOperatorType *ot)
1495 {
1496   PropertyRNA *prop;
1497
1498   /* identifiers */
1499   ot->name = "Add Collection Instance";
1500   ot->description = "Add a collection instance";
1501   ot->idname = "OBJECT_OT_collection_instance_add";
1502
1503   /* api callbacks */
1504   ot->invoke = WM_enum_search_invoke;
1505   ot->exec = collection_instance_add_exec;
1506   ot->poll = ED_operator_objectmode;
1507
1508   /* flags */
1509   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1510
1511   /* properties */
1512   RNA_def_string(
1513       ot->srna, "name", "Collection", MAX_ID_NAME - 2, "Name", "Collection name to add");
1514   prop = RNA_def_enum(ot->srna, "collection", DummyRNA_NULL_items, 0, "Collection", "");
1515   RNA_def_enum_funcs(prop, RNA_collection_itemf);
1516   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
1517   ot->prop = prop;
1518   ED_object_add_generic_props(ot, false);
1519 }
1520
1521 /** \} */
1522
1523 /* -------------------------------------------------------------------- */
1524 /** \name Add Data Instance Operator
1525  *
1526  * Use for dropping ID's from the outliner.
1527  * \{ */
1528
1529 static int object_data_instance_add_exec(bContext *C, wmOperator *op)
1530 {
1531   Main *bmain = CTX_data_main(C);
1532   ID *id = NULL;
1533   ushort local_view_bits;
1534   float loc[3], rot[3];
1535
1536   PropertyRNA *prop_name = RNA_struct_find_property(op->ptr, "name");
1537   PropertyRNA *prop_type = RNA_struct_find_property(op->ptr, "type");
1538   PropertyRNA *prop_location = RNA_struct_find_property(op->ptr, "location");
1539
1540   /* These shouldn't fail when created by outliner dropping as it checks the ID is valid. */
1541   if (!RNA_property_is_set(op->ptr, prop_name) || !RNA_property_is_set(op->ptr, prop_type)) {
1542     return OPERATOR_CANCELLED;
1543   }
1544   const short id_type = RNA_property_enum_get(op->ptr, prop_type);
1545   char name[MAX_ID_NAME - 2];
1546   RNA_property_string_get(op->ptr, prop_name, name);
1547   id = BKE_libblock_find_name(bmain, id_type, name);
1548   if (id == NULL) {
1549     return OPERATOR_CANCELLED;
1550   }
1551   const int object_type = BKE_object_obdata_to_type(id);
1552   if (object_type == -1) {
1553     return OPERATOR_CANCELLED;
1554   }
1555
1556   if (!RNA_property_is_set(op->ptr, prop_location)) {
1557     const wmEvent *event = CTX_wm_window(C)->eventstate;
1558     ARegion *region = CTX_wm_region(C);
1559     const int mval[2] = {event->x - region->winrct.xmin, event->y - region->winrct.ymin};
1560     ED_object_location_from_view(C, loc);
1561     ED_view3d_cursor3d_position(C, mval, false, loc);
1562     RNA_property_float_set_array(op->ptr, prop_location, loc);
1563   }
1564
1565   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1566     return OPERATOR_CANCELLED;
1567   }
1568
1569   Scene *scene = CTX_data_scene(C);
1570
1571   ED_object_add_type_with_obdata(
1572       C, object_type, id->name + 2, loc, rot, false, local_view_bits, id);
1573
1574   /* Works without this except if you try render right after, see: T22027. */
1575   DEG_relations_tag_update(bmain);
1576   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
1577   WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1578   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
1579
1580   return OPERATOR_FINISHED;
1581 }
1582
1583 void OBJECT_OT_data_instance_add(wmOperatorType *ot)
1584 {
1585   /* identifiers */
1586   ot->name = "Add Object Data Instance";
1587   ot->description = "Add an object data instance";
1588   ot->idname = "OBJECT_OT_data_instance_add";
1589
1590   /* api callbacks */
1591   ot->exec = object_data_instance_add_exec;
1592   ot->poll = ED_operator_objectmode;
1593
1594   /* flags */
1595   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1596
1597   /* properties */
1598   RNA_def_string(ot->srna, "name", "Name", MAX_ID_NAME - 2, "Name", "ID name to add");
1599   PropertyRNA *prop = RNA_def_enum(ot->srna, "type", rna_enum_id_type_items, 0, "Type", "");
1600   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ID);
1601   ED_object_add_generic_props(ot, false);
1602 }
1603
1604 /** \} */
1605
1606 /* -------------------------------------------------------------------- */
1607 /** \name Add Speaker Operator
1608  * \{ */
1609
1610 static int object_speaker_add_exec(bContext *C, wmOperator *op)
1611 {
1612   Main *bmain = CTX_data_main(C);
1613   Scene *scene = CTX_data_scene(C);
1614
1615   ushort local_view_bits;
1616   float loc[3], rot[3];
1617   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1618     return OPERATOR_CANCELLED;
1619   }
1620   Object *ob = ED_object_add_type(C, OB_SPEAKER, NULL, loc, rot, false, local_view_bits);
1621
1622   /* to make it easier to start using this immediately in NLA, a default sound clip is created
1623    * ready to be moved around to retime the sound and/or make new sound clips
1624    */
1625   {
1626     /* create new data for NLA hierarchy */
1627     AnimData *adt = BKE_animdata_add_id(&ob->id);
1628     NlaTrack *nlt = BKE_nlatrack_add(adt, NULL);
1629     NlaStrip *strip = BKE_nla_add_soundstrip(bmain, scene, ob->data);
1630     strip->start = CFRA;
1631     strip->end += strip->start;
1632
1633     /* hook them up */
1634     BKE_nlatrack_add_strip(nlt, strip);
1635
1636     /* auto-name the strip, and give the track an interesting name  */
1637     BLI_strncpy(nlt->name, DATA_("SoundTrack"), sizeof(nlt->name));
1638     BKE_nlastrip_validate_name(adt, strip);
1639
1640     WM_event_add_notifier(C, NC_ANIMATION | ND_NLA | NA_EDITED, NULL);
1641   }
1642
1643   return OPERATOR_FINISHED;
1644 }
1645
1646 void OBJECT_OT_speaker_add(wmOperatorType *ot)
1647 {
1648   /* identifiers */
1649   ot->name = "Add Speaker";
1650   ot->description = "Add a speaker object to the scene";
1651   ot->idname = "OBJECT_OT_speaker_add";
1652
1653   /* api callbacks */
1654   ot->exec = object_speaker_add_exec;
1655   ot->poll = ED_operator_objectmode;
1656
1657   /* flags */
1658   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1659
1660   ED_object_add_generic_props(ot, true);
1661 }
1662
1663 /** \} */
1664
1665 /* -------------------------------------------------------------------- */
1666 /** \name Add Hair Operator
1667  * \{ */
1668
1669 static bool object_hair_add_poll(bContext *C)
1670 {
1671   if (!U.experimental.use_new_hair_type) {
1672     return false;
1673   }
1674   return ED_operator_objectmode(C);
1675 }
1676
1677 static int object_hair_add_exec(bContext *C, wmOperator *op)
1678 {
1679   ushort local_view_bits;
1680   float loc[3], rot[3];
1681   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1682     return OPERATOR_CANCELLED;
1683   }
1684
1685   Object *object = ED_object_add_type(C, OB_HAIR, NULL, loc, rot, false, local_view_bits);
1686   object->dtx |= OB_DRAWBOUNDOX; /* TODO: remove once there is actual drawing. */
1687
1688   return OPERATOR_FINISHED;
1689 }
1690
1691 void OBJECT_OT_hair_add(wmOperatorType *ot)
1692 {
1693   /* identifiers */
1694   ot->name = "Add Hair";
1695   ot->description = "Add a hair object to the scene";
1696   ot->idname = "OBJECT_OT_hair_add";
1697
1698   /* api callbacks */
1699   ot->exec = object_hair_add_exec;
1700   ot->poll = object_hair_add_poll;
1701
1702   /* flags */
1703   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1704
1705   ED_object_add_generic_props(ot, false);
1706 }
1707
1708 /** \} */
1709
1710 /* -------------------------------------------------------------------- */
1711 /** \name Add Point Cloud Operator
1712  * \{ */
1713
1714 static bool object_pointcloud_add_poll(bContext *C)
1715 {
1716   if (!U.experimental.use_new_particle_system) {
1717     return false;
1718   }
1719   return ED_operator_objectmode(C);
1720 }
1721
1722 static int object_pointcloud_add_exec(bContext *C, wmOperator *op)
1723 {
1724   ushort local_view_bits;
1725   float loc[3], rot[3];
1726   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, NULL, &local_view_bits, NULL)) {
1727     return OPERATOR_CANCELLED;
1728   }
1729
1730   Object *object = ED_object_add_type(C, OB_POINTCLOUD, NULL, loc, rot, false, local_view_bits);
1731   object->dtx |= OB_DRAWBOUNDOX; /* TODO: remove once there is actual drawing. */
1732
1733   return OPERATOR_FINISHED;
1734 }
1735
1736 void OBJECT_OT_pointcloud_add(wmOperatorType *ot)
1737 {
1738   /* identifiers */
1739   ot->name = "Add Point Cloud";
1740   ot->description = "Add a point cloud object to the scene";
1741   ot->idname = "OBJECT_OT_pointcloud_add";
1742
1743   /* api callbacks */
1744   ot->exec = object_pointcloud_add_exec;
1745   ot->poll = object_pointcloud_add_poll;
1746
1747   /* flags */
1748   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1749
1750   ED_object_add_generic_props(ot, false);
1751 }
1752
1753 /** \} */
1754
1755 /* -------------------------------------------------------------------- */
1756 /** \name Delete Object Operator
1757  * \{ */
1758 /* remove base from a specific scene */
1759 /* note: now unlinks constraints as well */
1760 void ED_object_base_free_and_unlink(Main *bmain, Scene *scene, Object *ob)
1761 {
1762   if (BKE_library_ID_is_indirectly_used(bmain, ob) && ID_REAL_USERS(ob) <= 1 &&
1763       ID_EXTRA_USERS(ob) == 0) {
1764     /* We cannot delete indirectly used object... */
1765     printf(
1766         "WARNING, undeletable object '%s', should have been catched before reaching this "
1767         "function!",
1768         ob->id.name + 2);
1769     return;
1770   }
1771
1772   DEG_id_tag_update_ex(bmain, &ob->id, ID_RECALC_BASE_FLAGS);
1773
1774   BKE_scene_collections_object_remove(bmain, scene, ob, true);
1775 }
1776
1777 static int object_delete_exec(bContext *C, wmOperator *op)
1778 {
1779   Main *bmain = CTX_data_main(C);
1780   Scene *scene = CTX_data_scene(C);
1781   wmWindowManager *wm = CTX_wm_manager(C);
1782   const bool use_global = RNA_boolean_get(op->ptr, "use_global");
1783   uint changed_count = 0;
1784
1785   if (CTX_data_edit_object(C)) {
1786     return OPERATOR_CANCELLED;
1787   }
1788
1789   CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
1790     const bool is_indirectly_used = BKE_library_ID_is_indirectly_used(bmain, ob);
1791     if (ob->id.tag & LIB_TAG_INDIRECT) {
1792       /* Can this case ever happen? */
1793       BKE_reportf(op->reports,
1794                   RPT_WARNING,
1795                   "Cannot delete indirectly linked object '%s'",
1796                   ob->id.name + 2);
1797       continue;
1798     }
1799     if (is_indirectly_used && ID_REAL_USERS(ob) <= 1 && ID_EXTRA_USERS(ob) == 0) {
1800       BKE_reportf(op->reports,
1801                   RPT_WARNING,
1802                   "Cannot delete object '%s' from scene '%s', indirectly used objects need at "
1803                   "least one user",
1804                   ob->id.name + 2,
1805                   scene->id.name + 2);
1806       continue;
1807     }
1808
1809     /* if grease pencil object, set cache as dirty */
1810     if (ob->type == OB_GPENCIL) {
1811       bGPdata *gpd = (bGPdata *)ob->data;
1812       DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
1813     }
1814
1815     /* This is sort of a quick hack to address T51243 -
1816      * Proper thing to do here would be to nuke most of all this custom scene/object/base handling,
1817      * and use generic lib remap/query for that.
1818      * But this is for later (aka 2.8, once layers & co are settled and working).
1819      */
1820     if (use_global && ob->id.lib == NULL) {
1821       /* We want to nuke the object, let's nuke it the easy way (not for linked data though)... */
1822       BKE_id_delete(bmain, &ob->id);
1823       changed_count += 1;
1824       continue;
1825     }
1826
1827     /* remove from Grease Pencil parent */
1828     /* XXX This is likely not correct?
1829      *     Will also remove parent from grease pencil from other scenes,
1830      *     even when use_global is false... */
1831     for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1832       LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1833         if (gpl->parent != NULL) {
1834           if (gpl->parent == ob) {
1835             gpl->parent = NULL;
1836           }
1837         }
1838       }
1839     }
1840
1841     /* remove from current scene only */
1842     ED_object_base_free_and_unlink(bmain, scene, ob);
1843     changed_count += 1;
1844
1845     if (use_global) {
1846       Scene *scene_iter;
1847       for (scene_iter = bmain->scenes.first; scene_iter; scene_iter = scene_iter->id.next) {
1848         if (scene_iter != scene && !ID_IS_LINKED(scene_iter)) {
1849           if (is_indirectly_used && ID_REAL_USERS(ob) <= 1 && ID_EXTRA_USERS(ob) == 0) {
1850             BKE_reportf(op->reports,
1851                         RPT_WARNING,
1852                         "Cannot delete object '%s' from scene '%s', indirectly used objects need "
1853                         "at least one user",
1854                         ob->id.name + 2,
1855                         scene_iter->id.name + 2);
1856             break;
1857           }
1858           ED_object_base_free_and_unlink(bmain, scene_iter, ob);
1859         }
1860       }
1861     }
1862     /* end global */
1863   }
1864   CTX_DATA_END;
1865
1866   BKE_reportf(op->reports, RPT_INFO, "Deleted %u object(s)", changed_count);
1867
1868   if (changed_count == 0) {
1869     return OPERATOR_CANCELLED;
1870   }
1871
1872   /* delete has to handle all open scenes */
1873   BKE_main_id_tag_listbase(&bmain->scenes, LIB_TAG_DOIT, true);
1874   LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
1875     scene = WM_window_get_active_scene(win);
1876
1877     if (scene->id.tag & LIB_TAG_DOIT) {
1878       scene->id.tag &= ~LIB_TAG_DOIT;
1879
1880       DEG_relations_tag_update(bmain);
1881
1882       DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
1883       WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1884       WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
1885     }
1886   }
1887
1888   return OPERATOR_FINISHED;
1889 }
1890
1891 void OBJECT_OT_delete(wmOperatorType *ot)
1892 {
1893   /* identifiers */
1894   ot->name = "Delete";
1895   ot->description = "Delete selected objects";
1896   ot->idname = "OBJECT_OT_delete";
1897
1898   /* api callbacks */
1899   ot->invoke = WM_operator_confirm_or_exec;
1900   ot->exec = object_delete_exec;
1901   ot->poll = ED_operator_objectmode;
1902
1903   /* flags */
1904   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1905
1906   PropertyRNA *prop;
1907   prop = RNA_def_boolean(
1908       ot->srna, "use_global", 0, "Delete Globally", "Remove object from all scenes");
1909   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1910   WM_operator_properties_confirm_or_exec(ot);
1911 }
1912
1913 /** \} */
1914
1915 /* -------------------------------------------------------------------- */
1916 /** \name Copy Object Utilities
1917  * \{ */
1918
1919 /* after copying objects, copied data should get new pointers */
1920 static void copy_object_set_idnew(bContext *C)
1921 {
1922   Main *bmain = CTX_data_main(C);
1923
1924   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1925     BKE_libblock_relink_to_newid(&ob->id);
1926   }
1927   CTX_DATA_END;
1928
1929 #ifndef NDEBUG
1930   /* Call to `BKE_libblock_relink_to_newid` above is supposed to have cleared all those flags. */
1931   ID *id_iter;
1932   FOREACH_MAIN_ID_BEGIN (bmain, id_iter) {
1933     if (GS(id_iter->name) == ID_OB) {
1934       /* Not all duplicated objects would be used by other newly duplicated data, so their flag
1935        * will not always be cleared. */
1936       continue;
1937     }
1938     BLI_assert((id_iter->tag & LIB_TAG_NEW) == 0);
1939   }
1940   FOREACH_MAIN_ID_END;
1941 #endif
1942
1943   BKE_main_id_tag_all(bmain, LIB_TAG_NEW, false);
1944   BKE_main_id_clear_newpoins(bmain);
1945 }
1946
1947 /** \} */
1948
1949 /* -------------------------------------------------------------------- */
1950 /** \name Make Instanced Objects Real Operator
1951  * \{ */
1952
1953 /* XXX TODO That whole hierarchy handling based on persistent_id tricks is
1954  * very confusing and convoluted, and it will fail in many cases besides basic ones.
1955  * Think this should be replaced by a proper tree-like representation of the instantiations,
1956  * should help a lot in both readability, and precise consistent rebuilding of hierarchy.
1957  */
1958
1959 /**
1960  * \note regarding hashing dupli-objects which come from OB_DUPLICOLLECTION,
1961  * skip the first member of #DupliObject.persistent_id
1962  * since its a unique index and we only want to know if the group objects are from the same
1963  * dupli-group instance.
1964  *
1965  * \note regarding hashing dupli-objects which come from non-OB_DUPLICOLLECTION,
1966  * include the first member of #DupliObject.persistent_id
1967  * since its the index of the vertex/face the object is instantiated on and we want to identify
1968  * objects on the same vertex/face.
1969  * In other words, we consider each group of objects from a same item as being
1970  * the 'local group' where to check for parents.
1971  */
1972 static uint dupliobject_hash(const void *ptr)
1973 {
1974   const DupliObject *dob = ptr;
1975   uint hash = BLI_ghashutil_ptrhash(dob->ob);
1976
1977   if (dob->type == OB_DUPLICOLLECTION) {
1978     for (int i = 1; (i < MAX_DUPLI_RECUR) && dob->persistent_id[i] != INT_MAX; i++) {
1979       hash ^= (dob->persistent_id[i] ^ i);
1980     }
1981   }
1982   else {
1983     hash ^= (dob->persistent_id[0] ^ 0);
1984   }
1985   return hash;
1986 }
1987
1988 /**
1989  * \note regarding hashing dupli-objects when using OB_DUPLICOLLECTION,
1990  * skip the first member of #DupliObject.persistent_id
1991  * since its a unique index and we only want to know if the group objects are from the same
1992  * dupli-group instance.
1993  */
1994 static uint dupliobject_instancer_hash(const void *ptr)
1995 {
1996   const DupliObject *dob = ptr;
1997   uint hash = BLI_ghashutil_inthash(dob->persistent_id[0]);
1998   for (int i = 1; (i < MAX_DUPLI_RECUR) && dob->persistent_id[i] != INT_MAX; i++) {
1999     hash ^= (dob->persistent_id[i] ^ i);
2000   }
2001   return hash;
2002 }
2003
2004 /* Compare function that matches dupliobject_hash */
2005 static bool dupliobject_cmp(const void *a_, const void *b_)
2006 {
2007   const DupliObject *a = a_;
2008   const DupliObject *b = b_;
2009
2010   if (a->ob != b->ob) {
2011     return true;
2012   }
2013
2014   if (a->type != b->type) {
2015     return true;
2016   }
2017
2018   if (a->type == OB_DUPLICOLLECTION) {
2019     for (int i = 1; (i < MAX_DUPLI_RECUR); i++) {
2020       if (a->persistent_id[i] != b->persistent_id[i]) {
2021         return true;
2022       }
2023       if (a->persistent_id[i] == INT_MAX) {
2024         break;
2025       }
2026     }
2027   }
2028   else {
2029     if (a->persistent_id[0] != b->persistent_id[0]) {
2030       return true;
2031     }
2032   }
2033
2034   /* matching */
2035   return false;
2036 }
2037
2038 /* Compare function that matches dupliobject_instancer_hash. */
2039 static bool dupliobject_instancer_cmp(const void *a_, const void *b_)
2040 {
2041   const DupliObject *a = a_;
2042   const DupliObject *b = b_;
2043
2044   for (int i = 0; (i < MAX_DUPLI_RECUR); i++) {
2045     if (a->persistent_id[i] != b->persistent_id[i]) {
2046       return true;
2047     }
2048     if (a->persistent_id[i] == INT_MAX) {
2049       break;
2050     }
2051   }
2052
2053   /* matching */
2054   return false;
2055 }
2056
2057 static void make_object_duplilist_real(bContext *C,
2058                                        Depsgraph *depsgraph,
2059                                        Scene *scene,
2060                                        Base *base,
2061                                        const bool use_base_parent,
2062                                        const bool use_hierarchy)
2063 {
2064   Main *bmain = CTX_data_main(C);
2065   ViewLayer *view_layer = CTX_data_view_layer(C);
2066   GHash *parent_gh = NULL, *instancer_gh = NULL;
2067
2068   if (!(base->object->transflag & OB_DUPLI)) {
2069     return;
2070   }
2071
2072   Object *object_eval = DEG_get_evaluated_object(depsgraph, base->object);
2073   ListBase *lb_duplis = object_duplilist(depsgraph, scene, object_eval);
2074
2075   GHash *dupli_gh = BLI_ghash_ptr_new(__func__);
2076   if (use_hierarchy) {
2077     parent_gh = BLI_ghash_new(dupliobject_hash, dupliobject_cmp, __func__);
2078
2079     if (use_base_parent) {
2080       instancer_gh = BLI_ghash_new(
2081           dupliobject_instancer_hash, dupliobject_instancer_cmp, __func__);
2082     }
2083   }
2084
2085   LISTBASE_FOREACH (DupliObject *, dob, lb_duplis) {
2086     Object *ob_src = DEG_get_original_object(dob->ob);
2087     Object *ob_dst = ID_NEW_SET(ob_src, BKE_id_copy(bmain, &ob_src->id));
2088     id_us_min(&ob_dst->id);
2089
2090     /* font duplis can have a totcol without material, we get them from parent
2091      * should be implemented better...
2092      */
2093     if (ob_dst->mat == NULL) {
2094       ob_dst->totcol = 0;
2095     }
2096
2097     BKE_collection_object_add_from(bmain, scene, base->object, ob_dst);
2098     Base *base_dst = BKE_view_layer_base_find(view_layer, ob_dst);
2099     BLI_assert(base_dst != NULL);
2100
2101     ED_object_base_select(base_dst, BA_SELECT);
2102     DEG_id_tag_update(&ob_dst->id, ID_RECALC_SELECT);
2103
2104     BKE_scene_object_base_flag_sync_from_base(base_dst);
2105
2106     /* make sure apply works */
2107     BKE_animdata_free(&ob_dst->id, true);
2108     ob_dst->adt = NULL;
2109
2110     /* Proxies are not to be copied. */
2111     ob_dst->proxy_from = NULL;
2112     ob_dst->proxy_group = NULL;
2113     ob_dst->proxy = NULL;
2114
2115     ob_dst->parent = NULL;
2116     BKE_constraints_free(&ob_dst->constraints);
2117     ob_dst->runtime.curve_cache = NULL;
2118     const bool is_dupli_instancer = (ob_dst->transflag & OB_DUPLI) != 0;
2119     ob_dst->transflag &= ~OB_DUPLI;
2120     /* Remove instantiated collection, it's annoying to keep it here
2121      * (and get potentially a lot of usages of it then...). */
2122     id_us_min((ID *)ob_dst->instance_collection);
2123     ob_dst->instance_collection = NULL;
2124
2125     copy_m4_m4(ob_dst->obmat, dob->mat);
2126     BKE_object_apply_mat4(ob_dst, ob_dst->obmat, false, false);
2127
2128     BLI_ghash_insert(dupli_gh, dob, ob_dst);
2129     if (parent_gh) {
2130       void **val;
2131       /* Due to nature of hash/comparison of this ghash, a lot of duplis may be considered as
2132        * 'the same', this avoids trying to insert same key several time and
2133        * raise asserts in debug builds... */
2134       if (!BLI_ghash_ensure_p(parent_gh, dob, &val)) {
2135         *val = ob_dst;
2136       }
2137
2138       if (is_dupli_instancer && instancer_gh) {
2139         /* Same as above, we may have several 'hits'. */
2140         if (!BLI_ghash_ensure_p(instancer_gh, dob, &val)) {
2141           *val = ob_dst;
2142         }
2143       }
2144     }
2145   }
2146
2147   LISTBASE_FOREACH (DupliObject *, dob, lb_duplis) {
2148     Object *ob_src = dob->ob;
2149     Object *ob_dst = BLI_ghash_lookup(dupli_gh, dob);
2150
2151     /* Remap new object to itself, and clear again newid pointer of orig object. */
2152     BKE_libblock_relink_to_newid(&ob_dst->id);
2153
2154     DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
2155
2156     if (use_hierarchy) {
2157       /* original parents */
2158       Object *ob_src_par = ob_src->parent;
2159       Object *ob_dst_par = NULL;
2160
2161       /* find parent that was also made real */
2162       if (ob_src_par) {
2163         /* OK to keep most of the members uninitialized,
2164          * they won't be read, this is simply for a hash lookup. */
2165         DupliObject dob_key;
2166         dob_key.ob = ob_src_par;
2167         dob_key.type = dob->type;
2168         if (dob->type == OB_DUPLICOLLECTION) {
2169           memcpy(&dob_key.persistent_id[1],
2170                  &dob->persistent_id[1],
2171                  sizeof(dob->persistent_id[1]) * (MAX_DUPLI_RECUR - 1));
2172         }
2173         else {
2174           dob_key.persistent_id[0] = dob->persistent_id[0];
2175         }
2176         ob_dst_par = BLI_ghash_lookup(parent_gh, &dob_key);
2177       }
2178
2179       if (ob_dst_par) {
2180         /* allow for all possible parent types */
2181         ob_dst->partype = ob_src->partype;
2182         BLI_strncpy(ob_dst->parsubstr, ob_src->parsubstr, sizeof(ob_dst->parsubstr));
2183         ob_dst->par1 = ob_src->par1;
2184         ob_dst->par2 = ob_src->par2;
2185         ob_dst->par3 = ob_src->par3;
2186
2187         copy_m4_m4(ob_dst->parentinv, ob_src->parentinv);
2188
2189         ob_dst->parent = ob_dst_par;
2190       }
2191     }
2192     if (use_base_parent && ob_dst->parent == NULL) {
2193       Object *ob_dst_par = NULL;
2194
2195       if (instancer_gh != NULL) {
2196         /* OK to keep most of the members uninitialized,
2197          * they won't be read, this is simply for a hash lookup. */
2198         DupliObject dob_key;
2199         /* We are looking one step upper in hierarchy, so we need to 'shift' the persitent_id,
2200          * ignoring the first item.
2201          * We only check on persistent_id here, since we have no idea what object it might be. */
2202         memcpy(&dob_key.persistent_id[0],
2203                &dob->persistent_id[1],
2204                sizeof(dob_key.persistent_id[0]) * (MAX_DUPLI_RECUR - 1));
2205         ob_dst_par = BLI_ghash_lookup(instancer_gh, &dob_key);
2206       }
2207
2208       if (ob_dst_par == NULL) {
2209         /* Default to parenting to root object...
2210          * Always the case when use_hierarchy is false. */
2211         ob_dst_par = base->object;
2212       }
2213
2214       ob_dst->parent = ob_dst_par;
2215       ob_dst->partype = PAROBJECT;
2216     }
2217
2218     if (ob_dst->parent) {
2219       /* note, this may be the parent of other objects, but it should
2220        * still work out ok */
2221       BKE_object_apply_mat4(ob_dst, dob->mat, false, true);
2222
2223       /* to set ob_dst->orig and in case there's any other discrepancies */
2224       DEG_id_tag_update(&ob_dst->id, ID_RECALC_TRANSFORM);
2225     }
2226   }
2227
2228   if (base->object->transflag & OB_DUPLICOLLECTION && base->object->instance_collection) {
2229     LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
2230       if (ob->proxy_group == base->object) {
2231         ob->proxy = NULL;
2232         ob->proxy_from = NULL;
2233         DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
2234       }
2235     }
2236     base->object->instance_collection = NULL;
2237   }
2238
2239   ED_object_base_select(base, BA_DESELECT);
2240   DEG_id_tag_update(&base->object->id, ID_RECALC_SELECT);
2241
2242   BLI_ghash_free(dupli_gh, NULL, NULL);
2243   if (parent_gh) {
2244     BLI_ghash_free(parent_gh, NULL, NULL);
2245   }
2246   if (instancer_gh) {
2247     BLI_ghash_free(instancer_gh, NULL, NULL);
2248   }
2249
2250   free_object_duplilist(lb_duplis);
2251
2252   BKE_main_id_clear_newpoins(bmain);
2253
2254   base->object->transflag &= ~OB_DUPLI;
2255   DEG_id_tag_update(&base->object->id, ID_RECALC_COPY_ON_WRITE);
2256 }
2257
2258 static int object_duplicates_make_real_exec(bContext *C, wmOperator *op)
2259 {
2260   Main *bmain = CTX_data_main(C);
2261   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
2262   Scene *scene = CTX_data_scene(C);
2263
2264   const bool use_base_parent = RNA_boolean_get(op->ptr, "use_base_parent");
2265   const bool use_hierarchy = RNA_boolean_get(op->ptr, "use_hierarchy");
2266
2267   BKE_main_id_clear_newpoins(bmain);
2268
2269   CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
2270     make_object_duplilist_real(C, depsgraph, scene, base, use_base_parent, use_hierarchy);
2271
2272     /* dependencies were changed */
2273     WM_event_add_notifier(C, NC_OBJECT | ND_PARENT, base->object);
2274   }
2275   CTX_DATA_END;
2276
2277   DEG_relations_tag_update(bmain);
2278   WM_event_add_notifier(C, NC_SCENE, scene);
2279   WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
2280   ED_outliner_select_sync_from_object_tag(C);
2281
2282   return OPERATOR_FINISHED;
2283 }
2284
2285 void OBJECT_OT_duplicates_make_real(wmOperatorType *ot)
2286 {
2287   /* identifiers */
2288   ot->name = "Make Instances Real";
2289   ot->description = "Make instanced objects attached to this object real";
2290   ot->idname = "OBJECT_OT_duplicates_make_real";
2291
2292   /* api callbacks */
2293   ot->exec = object_duplicates_make_real_exec;
2294
2295   ot->poll = ED_operator_objectmode;
2296
2297   /* flags */
2298   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2299
2300   RNA_def_boolean(ot->srna,
2301                   "use_base_parent",
2302                   0,
2303                   "Parent",
2304                   "Parent newly created objects to the original duplicator");
2305   RNA_def_boolean(
2306       ot->srna, "use_hierarchy", 0, "Keep Hierarchy", "Maintain parent child relationships");
2307 }
2308
2309 /** \} */
2310
2311 /* -------------------------------------------------------------------- */
2312 /** \name Data Convert Operator
2313  * \{ */
2314
2315 static const EnumPropertyItem convert_target_items[] = {
2316     {OB_CURVE, "CURVE", ICON_OUTLINER_OB_CURVE, "Curve", "Curve from Mesh or Text objects"},
2317     {OB_MESH,
2318      "MESH",
2319      ICON_OUTLINER_OB_MESH,
2320      "Mesh",
2321 #ifdef WITH_PARTICLE_NODES
2322      "Mesh from Curve, Surface, Metaball, Text, or Pointcloud objects"},
2323 #else
2324      "Mesh from Curve, Surface, Metaball, or Text objects"},
2325 #endif
2326     {OB_GPENCIL,
2327      "GPENCIL",
2328      ICON_OUTLINER_OB_GREASEPENCIL,
2329      "Grease Pencil",
2330      "Grease Pencil from Curve or Mesh objects"},
2331 #ifdef WITH_PARTICLE_NODES
2332     {OB_POINTCLOUD,
2333      "POINTCLOUD",
2334      ICON_OUTLINER_OB_POINTCLOUD,
2335      "Pointcloud",
2336      "Pointcloud from Mesh objects"},
2337 #endif
2338     {0, NULL, 0, NULL, NULL},
2339 };
2340
2341 static void object_data_convert_ensure_curve_cache(Depsgraph *depsgraph, Scene *scene, Object *ob)
2342 {
2343   if (ob->runtime.curve_cache == NULL) {
2344     /* Force creation. This is normally not needed but on operator
2345      * redo we might end up with an object which isn't evaluated yet.
2346      * Also happens in case we are working on a copy of the object
2347      * (all its caches have been nuked then).
2348      */
2349     if (ELEM(ob->type, OB_SURF, OB_CURVE, OB_FONT)) {
2350       /* We need 'for render' ON here, to enable computing bevel dipslist if needed.
2351        * Also makes sense anyway, we would not want e.g. to lose hidden parts etc. */
2352       BKE_displist_make_curveTypes(depsgraph, scene, ob, true, false);
2353     }
2354     else if (ob->type == OB_MBALL) {
2355       BKE_displist_make_mball(depsgraph, scene, ob);
2356     }
2357   }
2358 }
2359
2360 static void object_data_convert_curve_to_mesh(Main *bmain, Depsgraph *depsgraph, Object *ob)
2361 {
2362   Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
2363   Curve *curve = ob->data;
2364
2365   Mesh *mesh = BKE_mesh_new_from_object_to_bmain(bmain, depsgraph, object_eval, true);
2366   if (mesh == NULL) {
2367     /* Unable to convert the curve to a mesh. */
2368     return;
2369   }
2370
2371   BKE_object_free_modifiers(ob, 0);
2372   /* Replace curve used by the object itself. */
2373   ob->data = mesh;
2374   ob->type = OB_MESH;
2375   id_us_min(&curve->id);
2376   id_us_plus(&mesh->id);
2377   /* Change objects which are using same curve.
2378    * A bit annoying, but:
2379    * - It's possible to have multiple curve objects selected which are sharing the same curve
2380    *   datablock. We don't want mesh to be created for every of those objects.
2381    * - This is how conversion worked for a long long time. */
2382   LISTBASE_FOREACH (Object *, other_object, &bmain->objects) {
2383     if (other_object->data == curve) {
2384       other_object->type = OB_MESH;
2385
2386       id_us_min((ID *)other_object->data);
2387       other_object->data = ob->data;
2388       id_us_plus((ID *)other_object->data);
2389     }
2390   }
2391 }
2392
2393 static bool object_convert_poll(bContext *C)
2394 {
2395   Scene *scene = CTX_data_scene(C);
2396   Base *base_act = CTX_data_active_base(C);
2397   Object *obact = base_act ? base_act->object : NULL;
2398
2399   if (obact == NULL || obact->data == NULL || ID_IS_LINKED(obact) ||
2400       ID_IS_OVERRIDE_LIBRARY(obact) || ID_IS_OVERRIDE_LIBRARY(obact->data)) {
2401     return false;
2402   }
2403
2404   return (!ID_IS_LINKED(scene) && (BKE_object_is_in_editmode(obact) == false) &&
2405           (base_act->flag & BASE_SELECTED));
2406 }
2407
2408 /* Helper for object_convert_exec */
2409 static Base *duplibase_for_convert(
2410     Main *bmain, Depsgraph *depsgraph, Scene *scene, ViewLayer *view_layer, Base *base, Object *ob)
2411 {
2412   if (ob == NULL) {
2413     ob = base->object;
2414   }
2415
2416   Object *obn = (Object *)BKE_id_copy(bmain, &ob->id);
2417   id_us_min(&obn->id);
2418   DEG_id_tag_update(&obn->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
2419   BKE_collection_object_add_from(bmain, scene, ob, obn);
2420
2421   Base *basen = BKE_view_layer_base_find(view_layer, obn);
2422   ED_object_base_select(basen, BA_SELECT);
2423   ED_object_base_select(base, BA_DESELECT);
2424
2425   /* XXX An ugly hack needed because if we re-run depsgraph with some new MBall objects
2426    * having same 'family name' as orig ones, they will affect end result of MBall computation...
2427    * For until we get rid of that name-based thingy in MBalls, that should do the trick
2428    * (this is weak, but other solution (to change name of obn) is even worse imho).
2429    * See T65996. */
2430   const bool is_meta_ball = (obn->type == OB_MBALL);
2431   void *obdata = obn->data;
2432   if (is_meta_ball) {
2433     obn->type = OB_EMPTY;
2434     obn->data = NULL;
2435   }
2436
2437   /* XXX Doing that here is stupid, it means we update and re-evaluate the whole depsgraph every
2438    * time we need to duplicate an object to convert it. Even worse, this is not 100% correct, since
2439    * we do not yet have duplicated obdata.
2440    * However, that is a safe solution for now. Proper, longer-term solution is to refactor
2441    * object_convert_exec to:
2442    *  - duplicate all data it needs to in a first loop.
2443    *  - do a single update.
2444    *  - convert data in a second loop. */
2445   DEG_graph_tag_relations_update(depsgraph);
2446   CustomData_MeshMasks customdata_mask_prev = scene->customdata_mask;
2447   CustomData_MeshMasks_update(&scene->customdata_mask, &CD_MASK_MESH);
2448   BKE_scene_graph_update_tagged(depsgraph, bmain);
2449   scene->customdata_mask = customdata_mask_prev;
2450
2451   if (is_meta_ball) {
2452     obn->type = OB_MBALL;
2453     obn->data = obdata;
2454   }
2455
2456   return basen;
2457 }
2458
2459 static int object_convert_exec(bContext *C, wmOperator *op)
2460 {
2461   Main *bmain = CTX_data_main(C);
2462   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
2463   Scene *scene = CTX_data_scene(C);
2464   ViewLayer *view_layer = CTX_data_view_layer(C);
2465   View3D *v3d = CTX_wm_view3d(C);
2466   Base *basen = NULL, *basact = NULL;
2467   Object *ob1, *obact = CTX_data_active_object(C);
2468   const short target = RNA_enum_get(op->ptr, "target");
2469   bool keep_original = RNA_boolean_get(op->ptr, "keep_original");
2470
2471   const float angle = RNA_float_get(op->ptr, "angle");
2472   const int thickness = RNA_int_get(op->ptr, "thickness");
2473   const bool use_seams = RNA_boolean_get(op->ptr, "seams");
2474   const bool use_faces = RNA_boolean_get(op->ptr, "faces");
2475   const float offset = RNA_float_get(op->ptr, "offset");
2476
2477   int a, mballConverted = 0;
2478   bool gpencilConverted = false;
2479
2480   /* don't forget multiple users! */
2481
2482   {
2483     FOREACH_SCENE_OBJECT_BEGIN (scene, ob) {
2484       ob->flag &= ~OB_DONE;
2485
2486       /* flag data that's not been edited (only needed for !keep_original) */
2487       if (ob->data) {
2488         ((ID *)ob->data)->tag |= LIB_TAG_DOIT;
2489       }
2490
2491       /* possible metaball basis is not in this scene */
2492       if (ob->type == OB_MBALL && target == OB_MESH) {
2493         if (BKE_mball_is_basis(ob) == false) {
2494           Object *ob_basis;
2495           ob_basis = BKE_mball_basis_find(scene, ob);
2496           if (ob_basis) {
2497             ob_basis->flag &= ~OB_DONE;
2498           }
2499         }
2500       }
2501     }
2502     FOREACH_SCENE_OBJECT_END;
2503   }
2504
2505   ListBase selected_editable_bases;
2506   CTX_data_selected_editable_bases(C, &selected_editable_bases);
2507
2508   /* Ensure we get all meshes calculated with a sufficient data-mask,
2509    * needed since re-evaluating single modifiers causes bugs if they depend
2510    * on other objects data masks too, see: T50950. */
2511   {
2512     LISTBASE_FOREACH (CollectionPointerLink *, link, &selected_editable_bases) {
2513       Base *base = link->ptr.data;
2514       Object *ob = base->object;
2515
2516       /* The way object type conversion works currently (enforcing conversion of *all* objects
2517        * using converted object-data, even some un-selected/hidden/another scene ones,
2518        * sounds totally bad to me.
2519        * However, changing this is more design than bug-fix, not to mention convoluted code below,
2520        * so that will be for later.
2521        * But at the very least, do not do that with linked IDs! */
2522       if ((ID_IS_LINKED(ob) || (ob->data && ID_IS_LINKED(ob->data))) && !keep_original) {
2523         keep_original = true;
2524         BKE_report(
2525             op->reports,
2526             RPT_INFO,
2527             "Converting some linked object/object data, enforcing 'Keep Original' option to True");
2528       }
2529
2530       DEG_id_tag_update(&base->object->id, ID_RECALC_GEOMETRY);
2531     }
2532
2533     CustomData_MeshMasks customdata_mask_prev = scene->customdata_mask;
2534     CustomData_MeshMasks_update(&scene->customdata_mask, &CD_MASK_MESH);
2535     BKE_scene_graph_update_tagged(depsgraph, bmain);
2536     scene->customdata_mask = customdata_mask_prev;
2537   }
2538
2539   LISTBASE_FOREACH (CollectionPointerLink *, link, &selected_editable_bases) {
2540     Object *newob = NULL;
2541     Base *base = link->ptr.data;
2542     Object *ob = base->object;
2543
2544     if (ob->flag & OB_DONE || !IS_TAGGED(ob->data)) {
2545       if (ob->type != target) {
2546         base->flag &= ~SELECT;
2547         ob->flag &= ~SELECT;
2548       }
2549
2550       /* obdata already modified */
2551       if (!IS_TAGGED(ob->data)) {
2552         /* When 2 objects with linked data are selected, converting both
2553          * would keep modifiers on all but the converted object T26003. */
2554         if (ob->type == OB_MESH) {
2555           BKE_object_free_modifiers(ob, 0); /* after derivedmesh calls! */
2556         }
2557         if (ob->type == OB_GPENCIL) {
2558           BKE_object_free_modifiers(ob, 0); /* after derivedmesh calls! */
2559           BKE_object_free_shaderfx(ob, 0);
2560         }
2561       }
2562     }
2563     else if (ob->type == OB_MESH && target == OB_CURVE) {
2564       ob->flag |= OB_DONE;
2565
2566       if (keep_original) {
2567         basen = duplibase_for_convert(bmain, depsgraph, scene, view_layer, base, NULL);
2568         newob = basen->object;
2569
2570         /* decrement original mesh's usage count  */
2571         Mesh *me = newob->data;
2572         id_us_min(&me->id);
2573
2574         /* make a new copy of the mesh */
2575         newob->data = BKE_id_copy(bmain, &me->id);
2576       }
2577       else {
2578         newob = ob;
2579       }
2580
2581       BKE_mesh_to_curve(bmain, depsgraph, scene, newob);
2582
2583       if (newob->type == OB_CURVE) {
2584         BKE_object_free_modifiers(newob, 0); /* after derivedmesh calls! */
2585         if (newob->rigidbody_object != NULL) {
2586           ED_rigidbody_object_remove(bmain, scene, newob);
2587         }
2588       }
2589     }
2590     else if (ob->type == OB_MESH && target == OB_GPENCIL) {
2591       ob->flag |= OB_DONE;
2592
2593       /* Create a new grease pencil object and copy transformations. */
2594       ushort local_view_bits = (v3d && v3d->localvd) ? v3d->local_view_uuid : 0;
2595       float loc[3], size[3], rot[3][3], eul[3];
2596       float matrix[4][4];
2597       mat4_to_loc_rot_size(loc, rot, size, ob->obmat);
2598       mat3_to_eul(eul, rot);
2599
2600       Object *ob_gpencil = ED_gpencil_add_object(C, loc, local_view_bits);
2601       copy_v3_v3(ob_gpencil->loc, loc);
2602       copy_v3_v3(ob_gpencil->rot, eul);
2603       copy_v3_v3(ob_gpencil->scale, size);
2604       unit_m4(matrix);
2605       /* Set object in 3D mode. */
2606       bGPdata *gpd = (bGPdata *)ob_gpencil->data;
2607       gpd->draw_mode = GP_DRAWMODE_3D;
2608
2609       gpencilConverted |= BKE_gpencil_convert_mesh(bmain,
2610                                                    depsgraph,
2611                                                    scene,
2612                                                    ob_gpencil,
2613                                                    ob,
2614                                                    angle,
2615                                                    thickness,
2616                                                    offset,
2617                                                    matrix,
2618                                                    0,
2619                                                    use_seams,
2620                                                    use_faces);
2621
2622       /* Remove unused materials. */
2623       int actcol = ob_gpencil->actcol;
2624       for (int slot = 1; slot <= ob_gpencil->totcol; slot++) {
2625         while (slot <= ob_gpencil->totcol &&
2626                !BKE_object_material_slot_used(ob_gpencil->data, slot)) {
2627           ob_gpencil->actcol = slot;
2628           BKE_object_material_slot_remove(CTX_data_main(C), ob_gpencil);
2629
2630           if (actcol >= slot) {
2631             actcol--;
2632           }
2633         }
2634       }
2635       ob_gpencil->actcol = actcol;
2636     }
2637     else if (ob->type == OB_MESH && target == OB_POINTCLOUD) {
2638       ob->flag |= OB_DONE;
2639
2640       if (keep_original) {
2641         basen = duplibase_for_convert(bmain, depsgraph, scene, view_layer, base, NULL);
2642         newob = basen->object;
2643
2644         /* decrement original mesh's usage count  */
2645         Mesh *me = newob->data;
2646         id_us_min(&me->id);
2647
2648         /* make a new copy of the mesh */
2649         newob->data = BKE_id_copy(bmain, &me->id);
2650       }
2651       else {
2652         newob = ob;
2653       }
2654
2655       BKE_mesh_to_pointcloud(bmain, depsgraph, scene, newob);
2656
2657       if (newob->type == OB_POINTCLOUD) {
2658         BKE_object_free_modifiers(newob, 0); /* after derivedmesh calls! */
2659         ED_rigidbody_object_remove(bmain, scene, newob);
2660       }
2661     }
2662     else if (ob->type == OB_MESH) {
2663       ob->flag |= OB_DONE;
2664
2665       if (keep_original) {
2666         basen = duplibase_for_convert(bmain, depsgraph, scene, view_layer, base, NULL);
2667         newob = basen->object;
2668
2669         /* decrement original mesh's usage count  */
2670         Mesh *me = newob->data;
2671         id_us_min(&me->id);
2672
2673         /* make a new copy of the mesh */
2674         newob->data = BKE_id_copy(bmain, &me->id);
2675       }
2676       else {
2677         newob = ob;
2678         DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
2679       }
2680
2681       /* make new mesh data from the original copy */
2682       /* note: get the mesh from the original, not from the copy in some
2683        * cases this doesn't give correct results (when MDEF is used for eg)
2684        */
2685       Scene *scene_eval = (Scene *)DEG_get_evaluated_id(depsgraph, &scene->id);
2686       Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
2687       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
2688       me_eval = BKE_mesh_copy_for_eval(me_eval, false);
2689       BKE_mesh_nomain_to_mesh(me_eval, newob->data, newob, &CD_MASK_MESH, true);
2690       BKE_object_free_modifiers(newob, 0); /* after derivedmesh calls! */
2691     }
2692     else if (ob->type == OB_FONT) {
2693       ob->flag |= OB_DONE;
2694
2695       if (keep_original) {
2696         basen = duplibase_for_convert(bmain, depsgraph, scene, view_layer, base, NULL);
2697         newob = basen->object;
2698
2699         /* decrement original curve's usage count  */
2700         id_us_min(&((Curve *)newob->data)->id);
2701
2702         /* make a new copy of the curve */
2703         newob->data = BKE_id_copy(bmain, ob->data);
2704       }
2705       else {
2706         newob = ob;
2707       }
2708
2709       Curve *cu = newob->data;
2710
2711       Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
2712       BKE_vfont_to_curve_ex(ob_eval, ob_eval->data, FO_EDIT, &cu->nurb, NULL, NULL, NULL, NULL);
2713
2714       newob->type = OB_CURVE;
2715       cu->type = OB_CURVE;
2716
2717       if (cu->vfont) {
2718         id_us_min(&cu->vfont->id);
2719         cu->vfont = NULL;
2720       }
2721       if (cu->vfontb) {
2722         id_us_min(&cu->vfontb->id);
2723         cu->vfontb = NULL;
2724       }
2725       if (cu->vfonti) {
2726         id_us_min(&cu->vfonti->id);
2727         cu->vfonti = NULL;
2728       }
2729       if (cu->vfontbi) {
2730         id_us_min(&cu->vfontbi->id);
2731         cu->vfontbi = NULL;
2732       }
2733
2734       if (!keep_original) {
2735         /* other users */
2736         if (ID_REAL_USERS(&cu->id) > 1) {
2737           for (ob1 = bmain->objects.first; ob1; ob1 = ob1->id.next) {
2738             if (ob1->data == ob->data) {
2739               ob1->type = OB_CURVE;
2740               DEG_id_tag_update(&ob1->id,
2741                                 ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
2742             }
2743           }
2744         }
2745       }
2746
2747       LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
2748         nu->charidx = 0;
2749       }
2750
2751       cu->flag &= ~CU_3D;
2752       BKE_curve_curve_dimension_update(cu);
2753
2754       if (target == OB_MESH) {
2755         /* No assumption should be made that the resulting objects is a mesh, as conversion can
2756          * fail. */
2757         object_data_convert_curve_to_mesh(bmain, depsgraph, newob);
2758         /* meshes doesn't use displist */
2759         BKE_object_free_curve_cache(newob);
2760       }
2761     }
2762     else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
2763       ob->flag |= OB_DONE;
2764
2765       if (target == OB_MESH) {
2766         if (keep_original) {
2767           basen = duplibase_for_convert(bmain, depsgraph, scene, view_layer, base, NULL);
2768           newob = basen->object;
2769
2770           /* decrement original curve's usage count  */
2771           id_us_min(&((Curve *)newob->data)->id);
2772
2773           /* make a new copy of the curve */
2774           newob->data = BKE_id_copy(bmain, ob->data);
2775         }
2776         else {
2777           newob = ob;
2778         }
2779
2780         /* No assumption should be made that the resulting objects is a mesh, as conversion can
2781          * fail. */
2782         object_data_convert_curve_to_mesh(bmain, depsgraph, newob);
2783         /* meshes doesn't use displist */
2784         BKE_object_free_curve_cache(newob);
2785       }
2786       else if (target == OB_GPENCIL) {
2787         if (ob->type != OB_CURVE) {
2788           ob->flag &= ~OB_DONE;
2789           BKE_report(op->reports, RPT_ERROR, "Convert Surfaces to Grease Pencil is not supported");
2790         }
2791         else {
2792           /* Create a new grease pencil object and copy transformations.
2793            * Nurbs Surface are not supported.
2794            */
2795           ushort local_view_bits = (v3d && v3d->localvd) ? v3d->local_view_uuid : 0;
2796           Object *ob_gpencil = ED_gpencil_add_object(C, ob->loc, local_view_bits);
2797           copy_v3_v3(ob_gpencil->rot, ob->rot);
2798           copy_v3_v3(ob_gpencil->scale, ob->scale);
2799           BKE_gpencil_convert_curve(bmain, scene, ob_gpencil, ob, false, 1.0f, 0.0f);
2800           gpencilConverted = true;
2801         }
2802       }
2803     }
2804     else if (ob->type == OB_MBALL && target == OB_MESH) {
2805       Object *baseob;
2806
2807       base->flag &= ~BASE_SELECTED;
2808       ob->base_flag &= ~BASE_SELECTED;
2809
2810       baseob = BKE_mball_basis_find(scene, ob);
2811
2812       if (ob != baseob) {
2813         /* if motherball is converting it would be marked as done later */
2814         ob->flag |= OB_DONE;
2815       }
2816
2817       if (!(baseob->flag & OB_DONE)) {
2818         basen = duplibase_for_convert(bmain, depsgraph, scene, view_layer, base, baseob);
2819         newob = basen->object;
2820
2821         MetaBall *mb = newob->data;
2822         id_us_min(&mb->id);
2823
2824         newob->data = BKE_mesh_add(bmain, "Mesh");
2825         newob->type = OB_MESH;
2826
2827         Mesh *me = newob->data;
2828         me->totcol = mb->totcol;
2829         if (newob->totcol) {
2830           me->mat = MEM_dupallocN(mb->mat);
2831           for (a = 0; a < newob->totcol; a++) {
2832             id_us_plus((ID *)me->mat[a]);
2833           }
2834         }
2835
2836         object_data_convert_ensure_curve_cache(depsgraph, scene, baseob);
2837         BKE_mesh_from_metaball(&baseob->runtime.curve_cache->disp, newob->data);
2838
2839         if (obact->type == OB_MBALL) {
2840           basact = basen;
2841         }
2842
2843         baseob->flag |= OB_DONE;
2844         mballConverted = 1;
2845       }
2846     }
2847     else if (ob->type == OB_POINTCLOUD && target == OB_MESH) {
2848       ob->flag |= OB_DONE;
2849
2850       if (keep_original) {
2851         basen = duplibase_for_convert(bmain, depsgraph, scene, view_layer, base, NULL);
2852         newob = basen->object;
2853
2854         /* decrement original pointclouds's usage count  */
2855         PointCloud *pointcloud = newob->data;
2856         id_us_min(&pointcloud->id);
2857
2858         /* make a new copy of the pointcloud */
2859         newob->data = BKE_id_copy(bmain, &pointcloud->id);
2860       }
2861       else {
2862         newob = ob;
2863       }
2864
2865       BKE_pointcloud_to_mesh(bmain, depsgraph, scene, newob);
2866
2867       if (newob->type == OB_MESH) {
2868         BKE_object_free_modifiers(newob, 0); /* after derivedmesh calls! */
2869         ED_rigidbody_object_remove(bmain, scene, newob);
2870       }
2871     }
2872     else {
2873       continue;
2874     }
2875
2876     /* Ensure new object has consistent material data with its new obdata. */
2877     if (newob) {
2878       BKE_object_materials_test(bmain, newob, newob->data);
2879     }
2880
2881     /* tag obdata if it was been changed */
2882
2883     /* If the original object is active then make this object active */
2884     if (basen) {
2885       if (ob == obact) {
2886         /* store new active base to update BASACT */
2887         basact = basen;
2888       }
2889
2890       basen = NULL;
2891     }
2892
2893     if (!keep_original && (ob->flag & OB_DONE)) {
2894       /* NOTE: Tag transform for update because object parenting to curve with path is handled
2895        * differently from all other cases. Converting curve to mesh and mesh to curve will likely
2896        * affect the way children are evaluated.
2897        * It is not enough to tag only geometry and rely on the curve parenting relations because
2898        * this relation is lost when curve is converted to mesh. */
2899       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY | ID_RECALC_TRANSFORM);
2900       ((ID *)ob->data)->tag &= ~LIB_TAG_DOIT; /* flag not to convert this datablock again */
2901     }
2902   }
2903   BLI_freelistN(&selected_editable_bases);
2904
2905   if (!keep_original) {
2906     if (mballConverted) {
2907       /* We need to remove non-basis MBalls first, otherwise we won't be able to detect them if
2908        * their basis happens to be removed first. */
2909       FOREACH_SCENE_OBJECT_BEGIN (scene, ob_mball) {
2910         if (ob_mball->type == OB_MBALL) {
2911           Object *ob_basis = NULL;
2912           if (!BKE_mball_is_basis(ob_mball) &&
2913               ((ob_basis = BKE_mball_basis_find(scene, ob_mball)) && (ob_basis->flag & OB_DONE))) {
2914             ED_object_base_free_and_unlink(bmain, scene, ob_mball);
2915           }
2916         }
2917       }
2918       FOREACH_SCENE_OBJECT_END;
2919       FOREACH_SCENE_OBJECT_BEGIN (scene, ob_mball) {
2920         if (ob_mball->type == OB_MBALL) {
2921           if (ob_mball->flag & OB_DONE) {
2922             if (BKE_mball_is_basis(ob_mball)) {
2923               ED_object_base_free_and_unlink(bmain, scene, ob_mball);
2924             }
2925           }
2926         }
2927       }
2928       FOREACH_SCENE_OBJECT_END;
2929     }
2930     /* Remove curves and meshes converted to Grease Pencil object. */
2931     if (gpencilConverted) {
2932       FOREACH_SCENE_OBJECT_BEGIN (scene, ob_delete) {
2933         if ((ob_delete->type == OB_CURVE) || (ob_delete->type == OB_MESH)) {
2934           if (ob_delete->flag & OB_DONE) {
2935             ED_object_base_free_and_unlink(bmain, scene, ob_delete);
2936           }
2937         }
2938       }
2939       FOREACH_SCENE_OBJECT_END;
2940     }
2941   }
2942
2943   // XXX  ED_object_editmode_enter(C, 0);
2944   // XXX  exit_editmode(C, EM_FREEDATA|); /* freedata, but no undo */
2945
2946   if (basact) {
2947     /* active base was changed */
2948     ED_object_base_activate(C, basact);
2949     BASACT(view_layer) = basact;
2950   }
2951   else if (BASACT(view_layer)->object->flag & OB_DONE) {
2952     WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, BASACT(view_layer)->object);
2953     WM_event_add_notifier(C, NC_OBJECT | ND_DATA, BASACT(view_layer)->object);
2954   }
2955
2956   DEG_relations_tag_update(bmain);
2957   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
2958   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, scene);
2959   WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
2960   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
2961
2962   return OPERATOR_FINISHED;
2963 }
2964
2965 static void object_convert_ui(bContext *UNUSED(C), wmOperator *op)
2966 {
2967   uiLayout *layout = op->layout;
2968   PointerRNA ptr;
2969
2970   uiLayoutSetPropSep(layout, true);
2971
2972   RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
2973   uiItemR(layout, &ptr, "target", 0, NULL, ICON_NONE);
2974   uiItemR(layout, &ptr, "keep_original", 0, NULL, ICON_NONE);
2975
2976   if (RNA_enum_get(&ptr, "target") == OB_GPENCIL) {
2977     uiItemR(layout, &ptr, "thickness", 0, NULL, ICON_NONE);
2978     uiItemR(layout, &ptr, "angle", 0, NULL, ICON_NONE);
2979     uiItemR(layout, &ptr, "offset", 0, NULL, ICON_NONE);
2980     uiItemR(layout, &ptr, "seams", 0, NULL, ICON_NONE);
2981     uiItemR(layout, &ptr, "faces", 0, NULL, ICON_NONE);
2982   }
2983 }
2984
2985 void OBJECT_OT_convert(wmOperatorType *ot)
2986 {
2987   PropertyRNA *prop;
2988
2989   /* identifiers */
2990   ot->name = "Convert To";
2991   ot->description = "Convert selected objects to another type";
2992   ot->idname = "OBJECT_OT_convert";
2993
2994   /* api callbacks */
2995   ot->invoke = WM_menu_invoke;
2996   ot->exec = object_convert_exec;
2997   ot->poll = object_convert_poll;
2998   ot->ui = object_convert_ui;
2999
3000   /* flags */
3001   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3002
3003   /* properties */
3004   ot->prop = RNA_def_enum(
3005       ot->srna, "target", convert_target_items, OB_MESH, "Target", "Type of object to convert to");
3006   RNA_def_boolean(ot->srna,
3007                   "keep_original",
3008                   0,
3009                   "Keep Original",
3010                   "Keep original objects instead of replacing them");
3011
3012   prop = RNA_def_float_rotation(ot->srna,
3013                                 "angle",
3014                                 0,
3015                                 NULL,
3016                                 DEG2RADF(0.0f),
3017                                 DEG2RADF(180.0f),
3018                                 "Threshold Angle",
3019                                 "Threshold to determine ends of the strokes",
3020                                 DEG2RADF(0.0f),
3021                                 DEG2RADF(180.0f));
3022   RNA_def_property_float_default(prop, DEG2RADF(70.0f));
3023
3024   RNA_def_int(ot->srna, "thickness", 5, 1, 100, "Thickness", "", 1, 100);
3025   RNA_def_boolean(ot->srna, "seams", 0, "Only Seam Edges", "Convert only seam edges");
3026   RNA_def_boolean(ot->srna, "faces", 1, "Export Faces", "Export faces as filled strokes");
3027   RNA_def_float_distance(ot->srna,
3028                          "offset",
3029                          0.01f,
3030                          0.0,
3031                          OBJECT_ADD_SIZE_MAXF,
3032                          "Stroke Offset",
3033                          "Offset strokes from fill",
3034                          0.0,
3035                          100.00);
3036 }
3037
3038 /** \} */
3039
3040 /* -------------------------------------------------------------------- */
3041 /** \name Duplicate Object Operator
3042  * \{ */
3043
3044 /*
3045  * dupflag: a flag made from constants declared in DNA_userdef_types.h
3046  * The flag tells adduplicate() whether to copy data linked to the object,
3047  * or to reference the existing data.
3048  * U.dupflag for default operations or you can construct a flag as python does
3049  * if the dupflag is 0 then no data will be copied (linked duplicate). */
3050
3051 /* used below, assumes id.new is correct */
3052 /* leaves selection of base/object unaltered */
3053 /* Does set ID->newid pointers. */
3054 static Base *object_add_duplicate_internal(Main *bmain,
3055                                            Scene *scene,
3056                                            ViewLayer *view_layer,
3057                                            Object *ob,
3058                                            const eDupli_ID_Flags dupflag,
3059                                            const eLibIDDuplicateFlags duplicate_options)
3060 {
3061   Base *base, *basen = NULL;
3062   Object *obn;
3063
3064   if (ob->mode & OB_MODE_POSE) {
3065     /* nothing? */
3066   }
3067   else {
3068     obn = ID_NEW_SET(ob, BKE_object_duplicate(bmain, ob, dupflag, duplicate_options));
3069     DEG_id_tag_update(&obn->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
3070
3071     base = BKE_view_layer_base_find(view_layer, ob);
3072     if ((base != NULL) && (base->flag & BASE_VISIBLE_DEPSGRAPH)) {
3073       BKE_collection_object_add_from(bmain, scene, ob, obn);
3074     }
3075     else {
3076       LayerCollection *layer_collection = BKE_layer_collection_get_active(view_layer);
3077       BKE_collection_object_add(bmain, layer_collection->collection, obn);
3078     }
3079
3080     basen = BKE_view_layer_base_find(view_layer, obn);
3081     if (base != NULL) {
3082       basen->local_view_bits = base->local_view_bits;
3083     }
3084
3085     /* 1) duplis should end up in same collection as the original
3086      * 2) Rigid Body sim participants MUST always be part of a collection...
3087      */
3088     /* XXX: is 2) really a good measure here? */
3089     if (ob->rigidbody_object || ob->rigidbody_constraint) {
3090       Collection *collection;
3091       for (collection = bmain->collections.first; collection; collection = collection->id.next) {
3092         if (BKE_collection_has_object(collection, ob)) {
3093           BKE_collection_object_add(bmain, collection, obn);
3094         }
3095       }
3096     }
3097   }
3098   return basen;
3099 }
3100
3101 /* single object duplicate, if dupflag==0, fully linked, else it uses the flags given */
3102 /* leaves selection of base/object unaltered.
3103  * note: don't call this within a loop since clear_* funcs loop over the entire database.
3104  * note: caller must do DAG_relations_tag_update(bmain);
3105  *       this is not done automatic since we may duplicate many objects in a batch */
3106 Base *ED_object_add_duplicate(
3107     Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base, const eDupli_ID_Flags dupflag)
3108 {
3109   Base *basen;
3110   Object *ob;
3111
3112   basen = object_add_duplicate_internal(
3113       bmain, scene, view_layer, base->object, dupflag, LIB_ID_DUPLICATE_IS_SUBPROCESS);
3114   if (basen == NULL) {
3115     return NULL;
3116   }
3117
3118   ob = basen->object;
3119
3120   /* link own references to the newly duplicated data T26816. */
3121   BKE_libblock_relink_to_newid(&ob->id);
3122
3123   /* DAG_relations_tag_update(bmain); */ /* caller must do */
3124
3125   if (ob->data != NULL) {
3126     DEG_id_tag_update_ex(bmain, (ID *)ob->data, ID_RECALC_EDITORS);
3127   }
3128
3129   BKE_main_id_clear_newpoins(bmain);
3130
3131   return basen;
3132 }
3133
3134 /* contextual operator dupli */
3135 static int duplicate_exec(bContext *C, wmOperator *op)
3136 {
3137   Main *bmain = CTX_data_main(C);
3138   Scene *scene = CTX_data_scene(C);
3139   ViewLayer *view_layer = CTX_data_view_layer(C);
3140   const bool linked = RNA_boolean_get(op->ptr, "linked");
3141   const eDupli_ID_Flags dupflag = (linked) ? 0 : (eDupli_ID_Flags)U.dupflag;
3142
3143   /* We need to handle that here ourselves, because we may duplicate several objects, in which case
3144    * we also want to remap pointers between those... */
3145   BKE_main_id_tag_all(bmain, LIB_TAG_NEW, false);
3146   BKE_main_id_clear_newpoins(bmain);
3147
3148   CTX_DATA_BEGIN (C, Base *, base, selected_bases) {
3149     Base *basen = object_add_duplicate_internal(
3150         bmain, scene, view_layer, base->object, dupflag, LIB_ID_DUPLICATE_IS_SUBPROCESS);
3151
3152     /* note that this is safe to do with this context iterator,
3153      * the list is made in advance */
3154     ED_object_base_select(base, BA_DESELECT);
3155     ED_object_base_select(basen, BA_SELECT);
3156
3157     if (basen == NULL) {
3158       continue;
3159     }
3160
3161     /* new object becomes active */
3162     if (BASACT(view_layer) == base) {
3163       ED_object_base_activate(C, basen);
3164     }
3165
3166     if (basen->object->data) {
3167       DEG_id_tag_update(basen->object->data, 0);
3168     }
3169   }
3170   CTX_DATA_END;
3171
3172   /* Note that this will also clear newid pointers and tags. */
3173   copy_object_set_idnew(C);
3174
3175   ED_outliner_select_sync_from_object_tag(C);
3176
3177   DEG_relations_tag_update(bmain);
3178   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE | ID_RECALC_SELECT);
3179
3180   WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
3181   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
3182
3183   return OPERATOR_FINISHED;
3184 }
3185
3186 void OBJECT_OT_duplicate(wmOperatorType *ot)
3187 {
3188   PropertyRNA *prop;
3189
3190   /* identifiers */
3191   ot->name = "Duplicate Objects";
3192   ot->description = "Duplicate selected objects";
3193   ot->idname = "OBJECT_OT_duplicate";
3194
3195   /* api callbacks */
3196   ot->exec = duplicate_exec;
3197   ot->poll = ED_operator_objectmode;
3198
3199   /* flags */
3200   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3201
3202   /* to give to transform */
3203   prop = RNA_def_boolean(ot->srna,
3204                          "linked",
3205                          0,
3206                          "Linked",
3207                          "Duplicate object but not object data, linking to the original data");
3208   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
3209
3210   prop = RNA_def_enum(
3211       ot->srna, "mode", rna_enum_transform_mode_types, TFM_TRANSLATION, "Mode", "");
3212   RNA_def_property_flag(prop, PROP_HIDDEN);
3213 }
3214
3215 /** \} */
3216
3217 /* -------------------------------------------------------------------- */
3218 /** \name Add Named Object Operator
3219  *
3220  * Use for drag & drop.
3221  * \{ */
3222
3223 static int object_add_named_exec(bContext *C, wmOperator *op)
3224 {
3225   wmWindow *win = CTX_wm_window(C);
3226   const wmEvent *event = win ? win->eventstate : NULL;
3227   Main *bmain = CTX_data_main(C);
3228   Scene *scene = CTX_data_scene(C);
3229   ViewLayer *view_layer = CTX_data_view_layer(C);
3230   Base *basen;
3231   Object *ob;
3232   const bool linked = RNA_boolean_get(op->ptr, "linked");
3233   const eDupli_ID_Flags dupflag = (linked) ? 0 : (eDupli_ID_Flags)U.dupflag;
3234   char name[MAX_ID_NAME - 2];
3235
3236   /* find object, create fake base */
3237   RNA_string_get(op->ptr, "name", name);
3238   ob = (Object *)BKE_libblock_find_name(bmain, ID_OB, name);
3239
3240   if (ob == NULL) {
3241     BKE_report(op->reports, RPT_ERROR, "Object not found");
3242     return OPERATOR_CANCELLED;
3243   }
3244
3245   /* prepare dupli */
3246   basen = object_add_duplicate_internal(bmain, scene, view_layer, ob, dupflag, 0);
3247
3248   if (basen == NULL) {
3249     BKE_report(op->reports, RPT_ERROR, "Object could not be duplicated");
3250     return OPERATOR_CANCELLED;
3251   }
3252
3253   basen->object->restrictflag &= ~OB_RESTRICT_VIEWPORT;
3254
3255   if (event) {
3256     ARegion *region = CTX_wm_region(C);
3257     const int mval[2] = {event->x - region->winrct.xmin, event->y - region->winrct.ymin};
3258     ED_object_location_from_view(C, basen->object->loc);
3259     ED_view3d_cursor3d_position(C, mval, false, basen->object->loc);
3260   }
3261
3262   ED_object_base_select(basen, BA_SELECT);
3263   ED_object_base_activate(C, basen);
3264
3265   copy_object_set_idnew(C);
3266
3267   /* TODO(sergey): Only update relations for the current scene. */
3268   DEG_relations_tag_update(bmain);
3269
3270   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
3271   WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
3272   WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
3273   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
3274   ED_outliner_select_sync_from_object_tag(C);
3275
3276   return OPERATOR_FINISHED;
3277 }
3278
3279 void OBJECT_OT_add_named(wmOperatorType *ot)
3280 {
3281   /* identifiers */
3282   ot->name = "Add Named Object";
3283   ot->description = "Add named object";
3284   ot->idname = "OBJECT_OT_add_named";
3285
3286   /* api callbacks */
3287   ot->exec = object_add_named_exec;
3288   ot->poll = ED_operator_objectmode;
3289
3290   /* flags */
3291   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3292
3293   RNA_def_boolean(ot->srna,
3294                   "linked",
3295                   0,
3296                   "Linked",
3297                   "Duplicate object but not object data, linking to the original data");
3298   RNA_def_string(ot->srna, "name", NULL, MAX_ID_NAME - 2, "Name", "Object name to add");
3299 }
3300
3301 /** \} */
3302
3303 /* -------------------------------------------------------------------- */
3304 /** \name Join Object Operator
3305  *
3306  * \{ */
3307
3308 static bool object_join_poll(bContext *C)
3309 {
3310   Object *ob = CTX_data_active_object(C);
3311
3312   if (ob == NULL || ob->data == NULL || ID_IS_LINKED(ob) || ID_IS_OVERRIDE_LIBRARY(ob) ||
3313       ID_IS_OVERRIDE_LIBRARY(ob->data)) {
3314     return false;
3315   }
3316
3317   if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_ARMATURE, OB_GPENCIL)) {
3318     return ED_operator_screenactive(C);
3319   }
3320   return false;
3321 }
3322
3323 static int object_join_exec(bContext *C, wmOperator *op)
3324 {
3325   Object *ob = CTX_data_active_object(C);
3326
3327   if (ob->mode & OB_MODE_EDIT) {
3328     BKE_report(op->reports, RPT_ERROR, "This data does not support joining in edit mode");
3329     return OPERATOR_CANCELLED;
3330   }
3331   if (BKE_object_obdata_is_libdata(ob)) {
3332     BKE_report(op->reports, RPT_ERROR, "Cannot edit external library data");
3333     return OPERATOR_CANCELLED;
3334   }
3335   if (ob->type == OB_GPENCIL) {
3336     bGPdata *gpd = (bGPdata *)ob->data;
3337     if ((!gpd) || GPENCIL_ANY_MODE(gpd)) {
3338       BKE_report(op->reports, RPT_ERROR, "This data does not support joining in this mode");
3339       return OPERATOR_CANCELLED;
3340     }
3341   }
3342
3343   int ret = OPERATOR_CANCELLED;
3344   if (ob->type == OB_MESH) {
3345     ret = ED_mesh_join_objects_exec(C, op);
3346   }
3347   else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
3348     ret = ED_curve_join_objects_exec(C, op);
3349   }
3350   else if (ob->type == OB_ARMATURE) {
3351     ret = ED_armature_join_objects_exec(C, op);
3352   }
3353   else if (ob->type == OB_GPENCIL) {
3354     ret = ED_gpencil_join_objects_exec(C, op);
3355   }
3356
3357   if (ret & OPERATOR_FINISHED) {
3358     /* Even though internally failure to invert is accounted for with a fallback,
3359      * show a warning since the result may not be what the user expects. See T80077.
3360      *
3361      * Failure to invert the matrix is typically caused by zero scaled axes
3362      * (which can be caused by constraints, even if the input scale isn't zero).
3363      *
3364      * Internally the join functions use #invert_m4_m4_safe_ortho which creates
3365      * an inevitable matrix from one that has one or more degenerate axes.
3366      *
3367      * In most cases we don't worry about special handling for non-inevitable matrices however for
3368      * joining objects there may be flat 2D objects where it's not obvious the scale is zero.
3369      * In this case, using #invert_m4_m4_safe_ortho works as well as we can expect,
3370      * joining the contents, flattening on the axis that's zero scaled.
3371      * If the zero scale is removed, the data on this axis remains un-scaled
3372      * (something that wouldn't work for #invert_m4_m4_safe). */
3373     float imat_test[4][4];
3374     if (!invert_m4_m4(imat_test, ob->obmat)) {
3375       BKE_report(op->reports,
3376                  RPT_WARNING,
3377                  "Active object final transform has one or more zero scaled axes");
3378     }
3379   }
3380
3381   return ret;
3382 }
3383
3384 void OBJECT_OT_join(wmOperatorType *ot)
3385 {
3386   /* identifiers */
3387   ot->name = "Join";
3388   ot->description = "Join selected objects into active object";
3389   ot->idname = "OBJECT_OT_join";
3390
3391   /* api callbacks */
3392   ot->exec = object_join_exec;
3393   ot->poll = object_join_poll;
3394
3395   /* flags */
3396   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3397 }
3398
3399 /** \} */
3400
3401 /* -------------------------------------------------------------------- */
3402 /** \name Join as Shape Key Operator
3403  * \{ */
3404
3405 static bool join_shapes_poll(bContext *C)
3406 {
3407   Object *ob = CTX_data_active_object(C);
3408
3409   if (ob == NULL || ob->data == NULL || ID_IS_LINKED(ob) || ID_IS_OVERRIDE_LIBRARY(ob) ||
3410       ID_IS_OVERRIDE_LIBRARY(ob->data)) {
3411     return false;
3412   }
3413
3414   /* only meshes supported at the moment */
3415   if (ob->type == OB_MESH) {
3416     return ED_operator_screenactive(C);
3417   }
3418   return false;
3419 }
3420
3421 static int join_shapes_exec(bContext *C, wmOperator *op)
3422 {
3423   Object *ob = CTX_data_active_object(C);
3424
3425   if (ob->mode & OB_MODE_EDIT) {
3426     BKE_report(op->reports, RPT_ERROR, "This data does not support joining in edit mode");
3427     return OPERATOR_CANCELLED;
3428   }
3429   if (BKE_object_obdata_is_libdata(ob)) {
3430     BKE_report(op->reports, RPT_ERROR, "Cannot edit external library data");
3431     return OPERATOR_CANCELLED;
3432   }
3433
3434   if (ob->type == OB_MESH) {
3435     return ED_mesh_shapes_join_objects_exec(C, op);
3436   }
3437
3438   return OPERATOR_CANCELLED;
3439 }
3440
3441 void OBJECT_OT_join_shapes(wmOperatorType *ot)
3442 {
3443   /* identifiers */
3444   ot->name = "Join as Shapes";
3445   ot->description = "Copy the current resulting shape of another selected object to this one";
3446   ot->idname = "OBJECT_OT_join_shapes";
3447
3448   /* api callbacks */
3449   ot->exec = join_shapes_exec;
3450   ot->poll = join_shapes_poll;
3451
3452   /* flags */
3453   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
3454 }
3455
3456 /** \} */