Fix T65301: Convert to mesh with Keep Original loses adjust operator panel.
[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 <stdlib.h>
25 #include <string.h>
26 #include <ctype.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_light_types.h"
35 #include "DNA_key_types.h"
36 #include "DNA_material_types.h"
37 #include "DNA_mesh_types.h"
38 #include "DNA_meta_types.h"
39 #include "DNA_object_fluidsim_types.h"
40 #include "DNA_object_force_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_lightprobe_types.h"
43 #include "DNA_scene_types.h"
44 #include "DNA_vfont_types.h"
45 #include "DNA_gpencil_types.h"
46
47 #include "BLI_utildefines.h"
48 #include "BLI_ghash.h"
49 #include "BLI_listbase.h"
50 #include "BLI_math.h"
51 #include "BLI_string.h"
52
53 #include "BLT_translation.h"
54
55 #include "BKE_action.h"
56 #include "BKE_anim.h"
57 #include "BKE_animsys.h"
58 #include "BKE_armature.h"
59 #include "BKE_camera.h"
60 #include "BKE_collection.h"
61 #include "BKE_context.h"
62 #include "BKE_constraint.h"
63 #include "BKE_curve.h"
64 #include "BKE_displist.h"
65 #include "BKE_effect.h"
66 #include "BKE_font.h"
67 #include "BKE_gpencil.h"
68 #include "BKE_key.h"
69 #include "BKE_light.h"
70 #include "BKE_lattice.h"
71 #include "BKE_layer.h"
72 #include "BKE_library.h"
73 #include "BKE_library_query.h"
74 #include "BKE_library_remap.h"
75 #include "BKE_lightprobe.h"
76 #include "BKE_main.h"
77 #include "BKE_material.h"
78 #include "BKE_mball.h"
79 #include "BKE_mesh.h"
80 #include "BKE_mesh_runtime.h"
81 #include "BKE_nla.h"
82 #include "BKE_object.h"
83 #include "BKE_particle.h"
84 #include "BKE_report.h"
85 #include "BKE_scene.h"
86 #include "BKE_speaker.h"
87
88 #include "DEG_depsgraph.h"
89 #include "DEG_depsgraph_build.h"
90 #include "DEG_depsgraph_query.h"
91
92 #include "RNA_access.h"
93 #include "RNA_define.h"
94 #include "RNA_enum_types.h"
95
96 #include "WM_api.h"
97 #include "WM_types.h"
98
99 #include "ED_armature.h"
100 #include "ED_curve.h"
101 #include "ED_gpencil.h"
102 #include "ED_mball.h"
103 #include "ED_mesh.h"
104 #include "ED_node.h"
105 #include "ED_object.h"
106 #include "ED_physics.h"
107 #include "ED_render.h"
108 #include "ED_screen.h"
109 #include "ED_transform.h"
110 #include "ED_view3d.h"
111
112 #include "UI_resources.h"
113
114 #include "object_intern.h"
115
116 /* -------------------------------------------------------------------- */
117 /** \name Local Enum Declarations
118  * \{ */
119
120 /* this is an exact copy of the define in rna_light.c
121  * kept here because of linking order.
122  * Icons are only defined here */
123 const EnumPropertyItem rna_enum_light_type_items[] = {
124     {LA_LOCAL, "POINT", ICON_LIGHT_POINT, "Point", "Omnidirectional point light source"},
125     {LA_SUN, "SUN", ICON_LIGHT_SUN, "Sun", "Constant direction parallel ray light source"},
126     {LA_SPOT, "SPOT", ICON_LIGHT_SPOT, "Spot", "Directional cone light source"},
127     {LA_AREA, "AREA", ICON_LIGHT_AREA, "Area", "Directional area light source"},
128     {0, NULL, 0, NULL, NULL},
129 };
130
131 /* copy from rna_object_force.c */
132 static const EnumPropertyItem field_type_items[] = {
133     {PFIELD_FORCE, "FORCE", ICON_FORCE_FORCE, "Force", ""},
134     {PFIELD_WIND, "WIND", ICON_FORCE_WIND, "Wind", ""},
135     {PFIELD_VORTEX, "VORTEX", ICON_FORCE_VORTEX, "Vortex", ""},
136     {PFIELD_MAGNET, "MAGNET", ICON_FORCE_MAGNETIC, "Magnetic", ""},
137     {PFIELD_HARMONIC, "HARMONIC", ICON_FORCE_HARMONIC, "Harmonic", ""},
138     {PFIELD_CHARGE, "CHARGE", ICON_FORCE_CHARGE, "Charge", ""},
139     {PFIELD_LENNARDJ, "LENNARDJ", ICON_FORCE_LENNARDJONES, "Lennard-Jones", ""},
140     {PFIELD_TEXTURE, "TEXTURE", ICON_FORCE_TEXTURE, "Texture", ""},
141     {PFIELD_GUIDE, "GUIDE", ICON_FORCE_CURVE, "Curve Guide", ""},
142     {PFIELD_BOID, "BOID", ICON_FORCE_BOID, "Boid", ""},
143     {PFIELD_TURBULENCE, "TURBULENCE", ICON_FORCE_TURBULENCE, "Turbulence", ""},
144     {PFIELD_DRAG, "DRAG", ICON_FORCE_DRAG, "Drag", ""},
145     {PFIELD_SMOKEFLOW, "SMOKE", ICON_FORCE_SMOKEFLOW, "Smoke Flow", ""},
146     {0, NULL, 0, NULL, NULL},
147 };
148
149 static EnumPropertyItem lightprobe_type_items[] = {
150     {LIGHTPROBE_TYPE_CUBE,
151      "CUBEMAP",
152      ICON_LIGHTPROBE_CUBEMAP,
153      "Reflection Cubemap",
154      "Reflection probe with spherical or cubic attenuation"},
155     {LIGHTPROBE_TYPE_PLANAR,
156      "PLANAR",
157      ICON_LIGHTPROBE_PLANAR,
158      "Reflection Plane",
159      "Planar reflection probe"},
160     {LIGHTPROBE_TYPE_GRID,
161      "GRID",
162      ICON_LIGHTPROBE_GRID,
163      "Irradiance Volume",
164      "Irradiance probe to capture diffuse indirect lighting"},
165     {0, NULL, 0, NULL, NULL},
166 };
167
168 enum {
169   ALIGN_WORLD = 0,
170   ALIGN_VIEW,
171   ALIGN_CURSOR,
172 };
173
174 static const EnumPropertyItem align_options[] = {
175     {ALIGN_WORLD, "WORLD", 0, "World", "Align the new object to the world"},
176     {ALIGN_VIEW, "VIEW", 0, "View", "Align the new object to the view"},
177     {ALIGN_CURSOR, "CURSOR", 0, "3D Cursor", "Use the 3D cursor orientation for the new object"},
178     {0, NULL, 0, NULL, NULL},
179 };
180
181 /** \} */
182
183 /* -------------------------------------------------------------------- */
184 /** \name Public Add Object API
185  *
186  * \{ */
187
188 void ED_object_location_from_view(bContext *C, float loc[3])
189 {
190   const Scene *scene = CTX_data_scene(C);
191   copy_v3_v3(loc, scene->cursor.location);
192 }
193
194 void ED_object_rotation_from_quat(float rot[3], const float viewquat[4], const char align_axis)
195 {
196   BLI_assert(align_axis >= 'X' && align_axis <= 'Z');
197
198   switch (align_axis) {
199     case 'X': {
200       /* Same as 'rv3d->viewinv[1]' */
201       float axis_y[4] = {0.0f, 1.0f, 0.0f};
202       float quat_y[4], quat[4];
203       axis_angle_to_quat(quat_y, axis_y, M_PI_2);
204       mul_qt_qtqt(quat, viewquat, quat_y);
205       quat_to_eul(rot, quat);
206       break;
207     }
208     case 'Y': {
209       quat_to_eul(rot, viewquat);
210       rot[0] -= (float)M_PI_2;
211       break;
212     }
213     case 'Z': {
214       quat_to_eul(rot, viewquat);
215       break;
216     }
217   }
218 }
219
220 void ED_object_rotation_from_view(bContext *C, float rot[3], const char align_axis)
221 {
222   RegionView3D *rv3d = CTX_wm_region_view3d(C);
223   BLI_assert(align_axis >= 'X' && align_axis <= 'Z');
224   if (rv3d) {
225     float viewquat[4];
226     copy_qt_qt(viewquat, rv3d->viewquat);
227     viewquat[0] *= -1.0f;
228     ED_object_rotation_from_quat(rot, viewquat, align_axis);
229   }
230   else {
231     zero_v3(rot);
232   }
233 }
234
235 void ED_object_base_init_transform(bContext *C, Base *base, const float loc[3], const float rot[3])
236 {
237   Object *ob = base->object;
238   Scene *scene = CTX_data_scene(C);
239   Depsgraph *depsgraph = CTX_data_depsgraph(C);
240
241   if (!scene) {
242     return;
243   }
244
245   if (loc) {
246     copy_v3_v3(ob->loc, loc);
247   }
248
249   if (rot) {
250     copy_v3_v3(ob->rot, rot);
251   }
252
253   BKE_object_where_is_calc(depsgraph, scene, ob);
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 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(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(primmat, imat);
275
276   /* center */
277   copy_v3_v3(primmat[3], loc);
278   sub_v3_v3v3(primmat[3], primmat[3], obedit->obmat[3]);
279   invert_m3_m3(imat, mat);
280   mul_m3_v3(imat, 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(wmOperatorType *ot)
311 {
312   RNA_def_float_distance(
313       ot->srna, "radius", 1.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Radius", "", 0.001, 100.00);
314 }
315
316 void ED_object_add_generic_props(wmOperatorType *ot, bool do_editmode)
317 {
318   PropertyRNA *prop;
319
320   if (do_editmode) {
321     prop = RNA_def_boolean(
322         ot->srna, "enter_editmode", 0, "Enter Editmode", "Enter editmode when adding this object");
323     RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
324   }
325   /* note: this property gets hidden for add-camera operator */
326   prop = RNA_def_enum(
327       ot->srna, "align", align_options, ALIGN_WORLD, "Align", "The alignment of the new object");
328   RNA_def_property_update_runtime(prop, view_align_update);
329
330   prop = RNA_def_float_vector_xyz(ot->srna,
331                                   "location",
332                                   3,
333                                   NULL,
334                                   -OBJECT_ADD_SIZE_MAXF,
335                                   OBJECT_ADD_SIZE_MAXF,
336                                   "Location",
337                                   "Location for the newly added object",
338                                   -1000.0f,
339                                   1000.0f);
340   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
341   prop = RNA_def_float_rotation(ot->srna,
342                                 "rotation",
343                                 3,
344                                 NULL,
345                                 -OBJECT_ADD_SIZE_MAXF,
346                                 OBJECT_ADD_SIZE_MAXF,
347                                 "Rotation",
348                                 "Rotation for the newly added object",
349                                 DEG2RADF(-360.0f),
350                                 DEG2RADF(360.0f));
351   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
352 }
353
354 void ED_object_add_mesh_props(wmOperatorType *ot)
355 {
356   RNA_def_boolean(ot->srna, "calc_uvs", true, "Generate UVs", "Generate a default UV map");
357 }
358
359 bool ED_object_add_generic_get_opts(bContext *C,
360                                     wmOperator *op,
361                                     const char view_align_axis,
362                                     float loc[3],
363                                     float rot[3],
364                                     bool *enter_editmode,
365                                     ushort *local_view_bits,
366                                     bool *is_view_aligned)
367 {
368   PropertyRNA *prop;
369
370   /* Switch to Edit mode? optional prop */
371   if ((prop = RNA_struct_find_property(op->ptr, "enter_editmode"))) {
372     bool _enter_editmode;
373     if (!enter_editmode) {
374       enter_editmode = &_enter_editmode;
375     }
376
377     if (RNA_property_is_set(op->ptr, prop) && enter_editmode) {
378       *enter_editmode = RNA_property_boolean_get(op->ptr, prop);
379     }
380     else {
381       *enter_editmode = (U.flag & USER_ADD_EDITMODE) != 0;
382       RNA_property_boolean_set(op->ptr, prop, *enter_editmode);
383     }
384   }
385
386   if (local_view_bits) {
387     View3D *v3d = CTX_wm_view3d(C);
388     if (v3d && v3d->localvd) {
389       *local_view_bits = v3d->local_view_uuid;
390     }
391   }
392
393   /* Location! */
394   {
395     float _loc[3];
396     if (!loc) {
397       loc = _loc;
398     }
399
400     if (RNA_struct_property_is_set(op->ptr, "location")) {
401       RNA_float_get_array(op->ptr, "location", loc);
402     }
403     else {
404       ED_object_location_from_view(C, loc);
405       RNA_float_set_array(op->ptr, "location", loc);
406     }
407   }
408
409   /* Rotation! */
410   {
411     bool _is_view_aligned;
412     float _rot[3];
413     if (!is_view_aligned) {
414       is_view_aligned = &_is_view_aligned;
415     }
416     if (!rot) {
417       rot = _rot;
418     }
419
420     prop = RNA_struct_find_property(op->ptr, "align");
421     int alignment = RNA_property_enum_get(op->ptr, prop);
422     bool alignment_set = RNA_property_is_set(op->ptr, prop);
423
424     if (RNA_struct_property_is_set(op->ptr, "rotation")) {
425       *is_view_aligned = false;
426     }
427     else if (alignment_set) {
428       *is_view_aligned = alignment == ALIGN_VIEW;
429     }
430     else {
431       *is_view_aligned = (U.flag & USER_ADD_VIEWALIGNED) != 0;
432       if (*is_view_aligned) {
433         RNA_property_enum_set(op->ptr, prop, ALIGN_VIEW);
434         alignment = ALIGN_VIEW;
435       }
436       else if (U.flag & USER_ADD_CURSORALIGNED) {
437         RNA_property_enum_set(op->ptr, prop, ALIGN_CURSOR);
438         alignment = ALIGN_CURSOR;
439       }
440     }
441
442     switch (alignment) {
443       case ALIGN_WORLD:
444         RNA_float_get_array(op->ptr, "rotation", rot);
445         break;
446       case ALIGN_VIEW:
447         ED_object_rotation_from_view(C, rot, view_align_axis);
448         RNA_float_set_array(op->ptr, "rotation", rot);
449         break;
450       case ALIGN_CURSOR: {
451         const Scene *scene = CTX_data_scene(C);
452         float tmat[3][3];
453         BKE_scene_cursor_rot_to_mat3(&scene->cursor, tmat);
454         mat3_normalized_to_eul(rot, tmat);
455         RNA_float_set_array(op->ptr, "rotation", rot);
456         break;
457       }
458     }
459   }
460
461   return true;
462 }
463
464 /* For object add primitive operators.
465  * Do not call undo push in this function (users of this function have to). */
466 Object *ED_object_add_type(bContext *C,
467                            int type,
468                            const char *name,
469                            const float loc[3],
470                            const float rot[3],
471                            bool enter_editmode,
472                            ushort local_view_bits)
473 {
474   Main *bmain = CTX_data_main(C);
475   Scene *scene = CTX_data_scene(C);
476   ViewLayer *view_layer = CTX_data_view_layer(C);
477   Object *ob;
478
479   /* for as long scene has editmode... */
480   if (CTX_data_edit_object(C)) {
481     ED_object_editmode_exit(C, EM_FREEDATA);
482   }
483
484   /* deselects all, sets active object */
485   ob = BKE_object_add(bmain, scene, view_layer, type, name);
486   BASACT(view_layer)->local_view_bits = local_view_bits;
487   /* editor level activate, notifiers */
488   ED_object_base_activate(C, view_layer->basact);
489
490   /* more editor stuff */
491   ED_object_base_init_transform(C, view_layer->basact, loc, rot);
492
493   /* TODO(sergey): This is weird to manually tag objects for update, better to
494    * use DEG_id_tag_update here perhaps.
495    */
496   DEG_id_type_tag(bmain, ID_OB);
497   DEG_relations_tag_update(bmain);
498   if (ob->data != NULL) {
499     DEG_id_tag_update_ex(bmain, (ID *)ob->data, ID_RECALC_EDITORS);
500   }
501
502   if (enter_editmode) {
503     ED_object_editmode_enter_ex(bmain, scene, ob, 0);
504   }
505
506   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
507
508   /* TODO(sergey): Use proper flag for tagging here. */
509   DEG_id_tag_update(&scene->id, 0);
510
511   return ob;
512 }
513
514 /* for object add operator */
515 static int object_add_exec(bContext *C, wmOperator *op)
516 {
517   Object *ob;
518   bool enter_editmode;
519   ushort local_view_bits;
520   float loc[3], rot[3], radius;
521
522   WM_operator_view3d_unit_defaults(C, op);
523   if (!ED_object_add_generic_get_opts(
524           C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL)) {
525     return OPERATOR_CANCELLED;
526   }
527   radius = RNA_float_get(op->ptr, "radius");
528   ob = ED_object_add_type(
529       C, RNA_enum_get(op->ptr, "type"), NULL, loc, rot, enter_editmode, local_view_bits);
530
531   if (ob->type == OB_LATTICE) {
532     /* lattice is a special case!
533      * we never want to scale the obdata since that is the rest-state */
534     copy_v3_fl(ob->scale, radius);
535   }
536   else {
537     BKE_object_obdata_size_init(ob, radius);
538   }
539
540   return OPERATOR_FINISHED;
541 }
542
543 void OBJECT_OT_add(wmOperatorType *ot)
544 {
545   /* identifiers */
546   ot->name = "Add Object";
547   ot->description = "Add an object to the scene";
548   ot->idname = "OBJECT_OT_add";
549
550   /* api callbacks */
551   ot->exec = object_add_exec;
552   ot->poll = ED_operator_objectmode;
553
554   /* flags */
555   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
556
557   /* properties */
558   ED_object_add_unit_props_radius(ot);
559   PropertyRNA *prop = RNA_def_enum(ot->srna, "type", rna_enum_object_type_items, 0, "Type", "");
560   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ID);
561
562   ED_object_add_generic_props(ot, true);
563 }
564
565 /** \} */
566
567 /* -------------------------------------------------------------------- */
568 /** \name Add Probe Operator
569  * \{ */
570
571 /* for object add operator */
572 static const char *get_lightprobe_defname(int type)
573 {
574   switch (type) {
575     case LIGHTPROBE_TYPE_GRID:
576       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "IrradianceVolume");
577     case LIGHTPROBE_TYPE_PLANAR:
578       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "ReflectionPlane");
579     case LIGHTPROBE_TYPE_CUBE:
580       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "ReflectionCubemap");
581     default:
582       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "LightProbe");
583   }
584 }
585
586 static int lightprobe_add_exec(bContext *C, wmOperator *op)
587 {
588   Object *ob;
589   LightProbe *probe;
590   int type;
591   bool enter_editmode;
592   ushort local_view_bits;
593   float loc[3], rot[3];
594   float radius;
595
596   WM_operator_view3d_unit_defaults(C, op);
597   if (!ED_object_add_generic_get_opts(
598           C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL)) {
599     return OPERATOR_CANCELLED;
600   }
601   type = RNA_enum_get(op->ptr, "type");
602   radius = RNA_float_get(op->ptr, "radius");
603
604   ob = ED_object_add_type(
605       C, OB_LIGHTPROBE, get_lightprobe_defname(type), loc, rot, false, local_view_bits);
606   copy_v3_fl(ob->scale, radius);
607
608   probe = (LightProbe *)ob->data;
609   probe->type = type;
610
611   switch (type) {
612     case LIGHTPROBE_TYPE_GRID:
613       probe->distinf = 0.3f;
614       probe->falloff = 1.0f;
615       probe->clipsta = 0.01f;
616       break;
617     case LIGHTPROBE_TYPE_PLANAR:
618       probe->distinf = 0.1f;
619       probe->falloff = 0.5f;
620       probe->clipsta = 0.001f;
621       ob->empty_drawsize = 0.5f;
622       break;
623     case LIGHTPROBE_TYPE_CUBE:
624       probe->attenuation_type = LIGHTPROBE_SHAPE_ELIPSOID;
625       break;
626     default:
627       BLI_assert(!"LightProbe type not configured.");
628       break;
629   }
630
631   DEG_relations_tag_update(CTX_data_main(C));
632
633   return OPERATOR_FINISHED;
634 }
635
636 void OBJECT_OT_lightprobe_add(wmOperatorType *ot)
637 {
638   /* identifiers */
639   ot->name = "Add Light Probe";
640   ot->description = "Add a light probe object";
641   ot->idname = "OBJECT_OT_lightprobe_add";
642
643   /* api callbacks */
644   ot->exec = lightprobe_add_exec;
645   ot->poll = ED_operator_objectmode;
646
647   /* flags */
648   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
649
650   /* properties */
651   ot->prop = RNA_def_enum(ot->srna, "type", lightprobe_type_items, 0, "Type", "");
652
653   ED_object_add_unit_props_radius(ot);
654   ED_object_add_generic_props(ot, true);
655 }
656
657 /** \} */
658
659 /* -------------------------------------------------------------------- */
660 /** \name Add Effector Operator
661  * \{ */
662
663 /* for object add operator */
664 static int effector_add_exec(bContext *C, wmOperator *op)
665 {
666   Object *ob;
667   int type;
668   bool enter_editmode;
669   ushort local_view_bits;
670   float loc[3], rot[3];
671   float mat[4][4];
672   float dia;
673
674   WM_operator_view3d_unit_defaults(C, op);
675   if (!ED_object_add_generic_get_opts(
676           C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL)) {
677     return OPERATOR_CANCELLED;
678   }
679   type = RNA_enum_get(op->ptr, "type");
680   dia = RNA_float_get(op->ptr, "radius");
681
682   if (type == PFIELD_GUIDE) {
683     Curve *cu;
684     const char *name = CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "CurveGuide");
685     ob = ED_object_add_type(C, OB_CURVE, name, loc, rot, false, local_view_bits);
686
687     cu = ob->data;
688     cu->flag |= CU_PATH | CU_3D;
689     ED_object_editmode_enter(C, 0);
690     ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
691     BLI_addtail(&cu->editnurb->nurbs,
692                 ED_curve_add_nurbs_primitive(C, ob, mat, CU_NURBS | CU_PRIM_PATH, dia));
693     if (!enter_editmode) {
694       ED_object_editmode_exit(C, EM_FREEDATA);
695     }
696   }
697   else {
698     const char *name = CTX_DATA_(BLT_I18NCONTEXT_ID_OBJECT, "Field");
699     ob = ED_object_add_type(C, OB_EMPTY, name, loc, rot, false, local_view_bits);
700     BKE_object_obdata_size_init(ob, dia);
701     if (ELEM(type, PFIELD_WIND, PFIELD_VORTEX)) {
702       ob->empty_drawtype = OB_SINGLE_ARROW;
703     }
704   }
705
706   ob->pd = BKE_partdeflect_new(type);
707
708   DEG_relations_tag_update(CTX_data_main(C));
709
710   return OPERATOR_FINISHED;
711 }
712
713 void OBJECT_OT_effector_add(wmOperatorType *ot)
714 {
715   /* identifiers */
716   ot->name = "Add Effector";
717   ot->description = "Add an empty object with a physics effector to the scene";
718   ot->idname = "OBJECT_OT_effector_add";
719
720   /* api callbacks */
721   ot->exec = effector_add_exec;
722   ot->poll = ED_operator_objectmode;
723
724   /* flags */
725   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
726
727   /* properties */
728   ot->prop = RNA_def_enum(ot->srna, "type", field_type_items, 0, "Type", "");
729
730   ED_object_add_unit_props_radius(ot);
731   ED_object_add_generic_props(ot, true);
732 }
733
734 /** \} */
735
736 /* -------------------------------------------------------------------- */
737 /** \name Add Camera Operator
738  * \{ */
739
740 static int object_camera_add_exec(bContext *C, wmOperator *op)
741 {
742   View3D *v3d = CTX_wm_view3d(C);
743   Scene *scene = CTX_data_scene(C);
744   Object *ob;
745   Camera *cam;
746   bool enter_editmode;
747   ushort local_view_bits;
748   float loc[3], rot[3];
749
750   /* force view align for cameras */
751   RNA_enum_set(op->ptr, "align", ALIGN_VIEW);
752
753   if (!ED_object_add_generic_get_opts(
754           C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL)) {
755     return OPERATOR_CANCELLED;
756   }
757   ob = ED_object_add_type(C, OB_CAMERA, NULL, loc, rot, false, local_view_bits);
758
759   if (v3d) {
760     if (v3d->camera == NULL) {
761       v3d->camera = ob;
762     }
763     if (v3d->scenelock && scene->camera == NULL) {
764       scene->camera = ob;
765     }
766   }
767
768   cam = ob->data;
769   cam->drawsize = v3d ? ED_view3d_grid_scale(scene, v3d, NULL) : ED_scene_grid_scale(scene, NULL);
770
771   return OPERATOR_FINISHED;
772 }
773
774 void OBJECT_OT_camera_add(wmOperatorType *ot)
775 {
776   PropertyRNA *prop;
777
778   /* identifiers */
779   ot->name = "Add Camera";
780   ot->description = "Add a camera object to the scene";
781   ot->idname = "OBJECT_OT_camera_add";
782
783   /* api callbacks */
784   ot->exec = object_camera_add_exec;
785   ot->poll = ED_operator_objectmode;
786
787   /* flags */
788   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
789
790   ED_object_add_generic_props(ot, true);
791
792   /* hide this for cameras, default */
793   prop = RNA_struct_type_find_property(ot->srna, "align");
794   RNA_def_property_flag(prop, PROP_HIDDEN);
795 }
796
797 /** \} */
798
799 /* -------------------------------------------------------------------- */
800 /** \name Add Metaball Operator
801  * \{ */
802
803 static int object_metaball_add_exec(bContext *C, wmOperator *op)
804 {
805   Object *obedit = CTX_data_edit_object(C);
806   bool newob = false;
807   bool enter_editmode;
808   ushort local_view_bits;
809   float loc[3], rot[3];
810   float mat[4][4];
811   float dia;
812
813   WM_operator_view3d_unit_defaults(C, op);
814   if (!ED_object_add_generic_get_opts(
815           C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL)) {
816     return OPERATOR_CANCELLED;
817   }
818   if (obedit == NULL || obedit->type != OB_MBALL) {
819     obedit = ED_object_add_type(C, OB_MBALL, NULL, loc, rot, true, local_view_bits);
820     newob = true;
821   }
822   else {
823     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
824   }
825
826   ED_object_new_primitive_matrix(C, obedit, loc, rot, mat);
827   dia = RNA_float_get(op->ptr, "radius");
828
829   ED_mball_add_primitive(C, obedit, mat, dia, RNA_enum_get(op->ptr, "type"));
830
831   /* userdef */
832   if (newob && !enter_editmode) {
833     ED_object_editmode_exit(C, EM_FREEDATA);
834   }
835
836   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
837
838   return OPERATOR_FINISHED;
839 }
840
841 void OBJECT_OT_metaball_add(wmOperatorType *ot)
842 {
843   /* identifiers */
844   ot->name = "Add Metaball";
845   ot->description = "Add an metaball object to the scene";
846   ot->idname = "OBJECT_OT_metaball_add";
847
848   /* api callbacks */
849   ot->invoke = WM_menu_invoke;
850   ot->exec = object_metaball_add_exec;
851   ot->poll = ED_operator_scene_editable;
852
853   /* flags */
854   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
855
856   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_metaelem_type_items, 0, "Primitive", "");
857
858   ED_object_add_unit_props_radius(ot);
859   ED_object_add_generic_props(ot, true);
860 }
861
862 /** \} */
863
864 /* -------------------------------------------------------------------- */
865 /** \name Add Text Operator
866  * \{ */
867
868 static int object_add_text_exec(bContext *C, wmOperator *op)
869 {
870   Object *obedit = CTX_data_edit_object(C);
871   bool enter_editmode;
872   ushort local_view_bits;
873   float loc[3], rot[3];
874
875   WM_operator_view3d_unit_defaults(C, op);
876   if (!ED_object_add_generic_get_opts(
877           C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL)) {
878     return OPERATOR_CANCELLED;
879   }
880   if (obedit && obedit->type == OB_FONT) {
881     return OPERATOR_CANCELLED;
882   }
883
884   obedit = ED_object_add_type(C, OB_FONT, NULL, loc, rot, enter_editmode, local_view_bits);
885   BKE_object_obdata_size_init(obedit, RNA_float_get(op->ptr, "radius"));
886
887   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
888
889   return OPERATOR_FINISHED;
890 }
891
892 void OBJECT_OT_text_add(wmOperatorType *ot)
893 {
894   /* identifiers */
895   ot->name = "Add Text";
896   ot->description = "Add a text object to the scene";
897   ot->idname = "OBJECT_OT_text_add";
898
899   /* api callbacks */
900   ot->exec = object_add_text_exec;
901   ot->poll = ED_operator_objectmode;
902
903   /* flags */
904   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
905
906   /* properties */
907   ED_object_add_unit_props_radius(ot);
908   ED_object_add_generic_props(ot, true);
909 }
910
911 /** \} */
912
913 /* -------------------------------------------------------------------- */
914 /** \name Add Armature Operator
915  * \{ */
916
917 static int object_armature_add_exec(bContext *C, wmOperator *op)
918 {
919   Object *obedit = CTX_data_edit_object(C);
920   RegionView3D *rv3d = CTX_wm_region_view3d(C);
921   bool newob = false;
922   bool enter_editmode;
923   ushort local_view_bits;
924   float loc[3], rot[3], dia;
925   bool view_aligned = rv3d && (U.flag & USER_ADD_VIEWALIGNED);
926
927   WM_operator_view3d_unit_defaults(C, op);
928   if (!ED_object_add_generic_get_opts(
929           C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL)) {
930     return OPERATOR_CANCELLED;
931   }
932   if ((obedit == NULL) || (obedit->type != OB_ARMATURE)) {
933     obedit = ED_object_add_type(C, OB_ARMATURE, NULL, loc, rot, true, local_view_bits);
934     ED_object_editmode_enter(C, 0);
935     newob = true;
936   }
937   else {
938     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
939   }
940
941   if (obedit == NULL) {
942     BKE_report(op->reports, RPT_ERROR, "Cannot create editmode armature");
943     return OPERATOR_CANCELLED;
944   }
945
946   dia = RNA_float_get(op->ptr, "radius");
947   ED_armature_ebone_add_primitive(obedit, dia, view_aligned);
948
949   /* userdef */
950   if (newob && !enter_editmode) {
951     ED_object_editmode_exit(C, EM_FREEDATA);
952   }
953
954   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
955
956   return OPERATOR_FINISHED;
957 }
958
959 void OBJECT_OT_armature_add(wmOperatorType *ot)
960 {
961   /* identifiers */
962   ot->name = "Add Armature";
963   ot->description = "Add an armature object to the scene";
964   ot->idname = "OBJECT_OT_armature_add";
965
966   /* api callbacks */
967   ot->exec = object_armature_add_exec;
968   ot->poll = ED_operator_objectmode;
969
970   /* flags */
971   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
972
973   /* properties */
974   ED_object_add_unit_props_radius(ot);
975   ED_object_add_generic_props(ot, true);
976 }
977
978 /** \} */
979
980 /* -------------------------------------------------------------------- */
981 /** \name Add Empty Operator
982  * \{ */
983
984 static int object_empty_add_exec(bContext *C, wmOperator *op)
985 {
986   Object *ob;
987   int type = RNA_enum_get(op->ptr, "type");
988   ushort local_view_bits;
989   float loc[3], rot[3];
990
991   WM_operator_view3d_unit_defaults(C, op);
992   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, &local_view_bits, NULL)) {
993     return OPERATOR_CANCELLED;
994   }
995   ob = ED_object_add_type(C, OB_EMPTY, NULL, loc, rot, false, local_view_bits);
996
997   BKE_object_empty_draw_type_set(ob, type);
998   BKE_object_obdata_size_init(ob, RNA_float_get(op->ptr, "radius"));
999
1000   return OPERATOR_FINISHED;
1001 }
1002
1003 void OBJECT_OT_empty_add(wmOperatorType *ot)
1004 {
1005   /* identifiers */
1006   ot->name = "Add Empty";
1007   ot->description = "Add an empty object to the scene";
1008   ot->idname = "OBJECT_OT_empty_add";
1009
1010   /* api callbacks */
1011   ot->invoke = WM_menu_invoke;
1012   ot->exec = object_empty_add_exec;
1013   ot->poll = ED_operator_objectmode;
1014
1015   /* flags */
1016   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1017
1018   /* properties */
1019   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_object_empty_drawtype_items, 0, "Type", "");
1020
1021   ED_object_add_unit_props_radius(ot);
1022   ED_object_add_generic_props(ot, false);
1023 }
1024
1025 static int empty_drop_named_image_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1026 {
1027   Scene *scene = CTX_data_scene(C);
1028
1029   Image *ima = NULL;
1030
1031   ima = (Image *)WM_operator_drop_load_path(C, op, ID_IM);
1032   if (!ima) {
1033     return OPERATOR_CANCELLED;
1034   }
1035   /* handled below */
1036   id_us_min((ID *)ima);
1037
1038   Object *ob = NULL;
1039   Object *ob_cursor = ED_view3d_give_object_under_cursor(C, event->mval);
1040
1041   /* either change empty under cursor or create a new empty */
1042   if (ob_cursor && ob_cursor->type == OB_EMPTY) {
1043     WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1044     DEG_id_tag_update((ID *)ob_cursor, ID_RECALC_TRANSFORM);
1045     ob = ob_cursor;
1046   }
1047   else {
1048     /* add new empty */
1049     ushort local_view_bits;
1050     float rot[3];
1051
1052     if (!ED_object_add_generic_get_opts(C, op, 'Z', NULL, rot, NULL, &local_view_bits, NULL)) {
1053       return OPERATOR_CANCELLED;
1054     }
1055     ob = ED_object_add_type(C, OB_EMPTY, NULL, NULL, rot, false, local_view_bits);
1056
1057     ED_object_location_from_view(C, ob->loc);
1058     ED_view3d_cursor3d_position(C, event->mval, false, ob->loc);
1059     ED_object_rotation_from_view(C, ob->rot, 'Z');
1060     ob->empty_drawsize = 5.0f;
1061   }
1062
1063   BKE_object_empty_draw_type_set(ob, OB_EMPTY_IMAGE);
1064
1065   id_us_min(ob->data);
1066   ob->data = ima;
1067   id_us_plus(ob->data);
1068
1069   return OPERATOR_FINISHED;
1070 }
1071
1072 void OBJECT_OT_drop_named_image(wmOperatorType *ot)
1073 {
1074   PropertyRNA *prop;
1075
1076   /* identifiers */
1077   ot->name = "Add Empty Image/Drop Image To Empty";
1078   ot->description = "Add an empty image type to scene with data";
1079   ot->idname = "OBJECT_OT_drop_named_image";
1080
1081   /* api callbacks */
1082   ot->invoke = empty_drop_named_image_invoke;
1083   ot->poll = ED_operator_objectmode;
1084
1085   /* flags */
1086   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1087
1088   /* properties */
1089   prop = RNA_def_string(ot->srna, "filepath", NULL, FILE_MAX, "Filepath", "Path to image file");
1090   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1091   RNA_def_boolean(ot->srna,
1092                   "relative_path",
1093                   true,
1094                   "Relative Path",
1095                   "Select the file relative to the blend file");
1096   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1097   prop = RNA_def_string(ot->srna, "name", NULL, MAX_ID_NAME - 2, "Name", "Image name to assign");
1098   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1099   ED_object_add_generic_props(ot, false);
1100 }
1101
1102 /** \} */
1103
1104 /* -------------------------------------------------------------------- */
1105 /** \name Add Gpencil Operator
1106  * \{ */
1107
1108 static bool object_gpencil_add_poll(bContext *C)
1109 {
1110   Scene *scene = CTX_data_scene(C);
1111   Object *obact = CTX_data_active_object(C);
1112
1113   if ((scene == NULL) || (ID_IS_LINKED(scene))) {
1114     return false;
1115   }
1116
1117   if (obact && obact->type == OB_GPENCIL) {
1118     if (obact->mode != OB_MODE_OBJECT) {
1119       return false;
1120     }
1121   }
1122
1123   return true;
1124 }
1125
1126 static int object_gpencil_add_exec(bContext *C, wmOperator *op)
1127 {
1128   Object *ob = CTX_data_active_object(C);
1129   bGPdata *gpd = (ob && (ob->type == OB_GPENCIL)) ? ob->data : NULL;
1130
1131   const int type = RNA_enum_get(op->ptr, "type");
1132
1133   ushort local_view_bits;
1134   float loc[3], rot[3];
1135   bool newob = false;
1136
1137   /* Note: We use 'Y' here (not 'Z'), as */
1138   WM_operator_view3d_unit_defaults(C, op);
1139   if (!ED_object_add_generic_get_opts(C, op, 'Y', loc, rot, NULL, &local_view_bits, NULL)) {
1140     return OPERATOR_CANCELLED;
1141   }
1142   /* add new object if not currently editing a GP object,
1143    * or if "empty" was chosen (i.e. user wants a blank GP canvas)
1144    */
1145   if ((gpd == NULL) || (GPENCIL_ANY_MODE(gpd) == false) || (type == GP_EMPTY)) {
1146     const char *ob_name = NULL;
1147     switch (type) {
1148       case GP_MONKEY: {
1149         ob_name = "Suzanne";
1150         break;
1151       }
1152       case GP_STROKE: {
1153         ob_name = "Stroke";
1154         break;
1155       }
1156       default: {
1157         break;
1158       }
1159     }
1160
1161     ob = ED_object_add_type(C, OB_GPENCIL, ob_name, loc, rot, true, local_view_bits);
1162     gpd = ob->data;
1163     newob = true;
1164   }
1165   else {
1166     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1167     WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_ADDED, NULL);
1168   }
1169
1170   /* create relevant geometry */
1171   switch (type) {
1172     case GP_STROKE: {
1173       float radius = RNA_float_get(op->ptr, "radius");
1174       float mat[4][4];
1175
1176       ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
1177       mul_v3_fl(mat[0], radius);
1178       mul_v3_fl(mat[1], radius);
1179       mul_v3_fl(mat[2], radius);
1180
1181       ED_gpencil_create_stroke(C, ob, mat);
1182       break;
1183     }
1184     case GP_MONKEY: {
1185       float radius = RNA_float_get(op->ptr, "radius");
1186       float mat[4][4];
1187
1188       ED_object_new_primitive_matrix(C, ob, loc, rot, mat);
1189       mul_v3_fl(mat[0], radius);
1190       mul_v3_fl(mat[1], radius);
1191       mul_v3_fl(mat[2], radius);
1192
1193       ED_gpencil_create_monkey(C, ob, mat);
1194       break;
1195     }
1196     case GP_EMPTY:
1197       /* do nothing */
1198       break;
1199
1200     default:
1201       BKE_report(op->reports, RPT_WARNING, "Not implemented");
1202       break;
1203   }
1204
1205   /* if this is a new object, initialise default stuff (colors, etc.) */
1206   if (newob) {
1207     /* set default viewport color to black */
1208     copy_v3_fl(ob->color, 0.0f);
1209
1210     ED_gpencil_add_defaults(C, ob);
1211   }
1212
1213   return OPERATOR_FINISHED;
1214 }
1215
1216 void OBJECT_OT_gpencil_add(wmOperatorType *ot)
1217 {
1218   /* identifiers */
1219   ot->name = "Add Grease Pencil";
1220   ot->description = "Add a Grease Pencil object to the scene";
1221   ot->idname = "OBJECT_OT_gpencil_add";
1222
1223   /* api callbacks */
1224   ot->invoke = WM_menu_invoke;
1225   ot->exec = object_gpencil_add_exec;
1226   ot->poll = object_gpencil_add_poll;
1227
1228   /* flags */
1229   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1230
1231   /* properties */
1232   ED_object_add_unit_props_radius(ot);
1233   ED_object_add_generic_props(ot, false);
1234
1235   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_object_gpencil_type_items, 0, "Type", "");
1236 }
1237
1238 /** \} */
1239
1240 /* -------------------------------------------------------------------- */
1241 /** \name Add Light Operator
1242  * \{ */
1243
1244 static const char *get_light_defname(int type)
1245 {
1246   switch (type) {
1247     case LA_LOCAL:
1248       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Point");
1249     case LA_SUN:
1250       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Sun");
1251     case LA_SPOT:
1252       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Spot");
1253     case LA_AREA:
1254       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Area");
1255     default:
1256       return CTX_DATA_(BLT_I18NCONTEXT_ID_LIGHT, "Light");
1257   }
1258 }
1259
1260 static int object_light_add_exec(bContext *C, wmOperator *op)
1261 {
1262   Object *ob;
1263   Light *la;
1264   int type = RNA_enum_get(op->ptr, "type");
1265   ushort local_view_bits;
1266   float loc[3], rot[3];
1267
1268   WM_operator_view3d_unit_defaults(C, op);
1269   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, &local_view_bits, NULL)) {
1270     return OPERATOR_CANCELLED;
1271   }
1272   ob = ED_object_add_type(C, OB_LAMP, get_light_defname(type), loc, rot, false, local_view_bits);
1273
1274   float size = RNA_float_get(op->ptr, "radius");
1275   /* Better defaults for light size. */
1276   switch (type) {
1277     case LA_LOCAL:
1278     case LA_SPOT:
1279       break;
1280     case LA_AREA:
1281       size *= 4.0f;
1282       break;
1283     default:
1284       size *= 0.5f;
1285       break;
1286   }
1287   BKE_object_obdata_size_init(ob, size);
1288
1289   la = (Light *)ob->data;
1290   la->type = type;
1291
1292   if (type == LA_SUN) {
1293     la->energy = 1.0f;
1294   }
1295
1296   return OPERATOR_FINISHED;
1297 }
1298
1299 void OBJECT_OT_light_add(wmOperatorType *ot)
1300 {
1301   /* identifiers */
1302   ot->name = "Add Light";
1303   ot->description = "Add a light object to the scene";
1304   ot->idname = "OBJECT_OT_light_add";
1305
1306   /* api callbacks */
1307   ot->invoke = WM_menu_invoke;
1308   ot->exec = object_light_add_exec;
1309   ot->poll = ED_operator_objectmode;
1310
1311   /* flags */
1312   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1313
1314   /* properties */
1315   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_light_type_items, 0, "Type", "");
1316   RNA_def_property_translation_context(ot->prop, BLT_I18NCONTEXT_ID_LIGHT);
1317
1318   ED_object_add_unit_props_radius(ot);
1319   ED_object_add_generic_props(ot, false);
1320 }
1321
1322 /** \} */
1323
1324 /* -------------------------------------------------------------------- */
1325 /** \name Add Collection Instance Operator
1326  * \{ */
1327
1328 static int collection_instance_add_exec(bContext *C, wmOperator *op)
1329 {
1330   Main *bmain = CTX_data_main(C);
1331   Collection *collection;
1332   ushort local_view_bits;
1333   float loc[3], rot[3];
1334
1335   if (RNA_struct_property_is_set(op->ptr, "name")) {
1336     char name[MAX_ID_NAME - 2];
1337
1338     RNA_string_get(op->ptr, "name", name);
1339     collection = (Collection *)BKE_libblock_find_name(bmain, ID_GR, name);
1340
1341     if (0 == RNA_struct_property_is_set(op->ptr, "location")) {
1342       const wmEvent *event = CTX_wm_window(C)->eventstate;
1343       ARegion *ar = CTX_wm_region(C);
1344       const int mval[2] = {event->x - ar->winrct.xmin, event->y - ar->winrct.ymin};
1345       ED_object_location_from_view(C, loc);
1346       ED_view3d_cursor3d_position(C, mval, false, loc);
1347       RNA_float_set_array(op->ptr, "location", loc);
1348     }
1349   }
1350   else {
1351     collection = BLI_findlink(&CTX_data_main(C)->collections, RNA_enum_get(op->ptr, "collection"));
1352   }
1353
1354   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, &local_view_bits, NULL)) {
1355     return OPERATOR_CANCELLED;
1356   }
1357   if (collection) {
1358     Scene *scene = CTX_data_scene(C);
1359     ViewLayer *view_layer = CTX_data_view_layer(C);
1360
1361     /* Avoid dependency cycles. */
1362     LayerCollection *active_lc = BKE_layer_collection_get_active(view_layer);
1363     while (BKE_collection_find_cycle(active_lc->collection, collection)) {
1364       active_lc = BKE_layer_collection_activate_parent(view_layer, active_lc);
1365     }
1366
1367     Object *ob = ED_object_add_type(
1368         C, OB_EMPTY, collection->id.name + 2, loc, rot, false, local_view_bits);
1369     ob->instance_collection = collection;
1370     ob->transflag |= OB_DUPLICOLLECTION;
1371     id_us_plus(&collection->id);
1372
1373     /* works without this except if you try render right after, see: 22027 */
1374     DEG_relations_tag_update(bmain);
1375     DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
1376     WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1377
1378     return OPERATOR_FINISHED;
1379   }
1380
1381   return OPERATOR_CANCELLED;
1382 }
1383
1384 /* only used as menu */
1385 void OBJECT_OT_collection_instance_add(wmOperatorType *ot)
1386 {
1387   PropertyRNA *prop;
1388
1389   /* identifiers */
1390   ot->name = "Add Collection Instance";
1391   ot->description = "Add a collection instance";
1392   ot->idname = "OBJECT_OT_collection_instance_add";
1393
1394   /* api callbacks */
1395   ot->invoke = WM_enum_search_invoke;
1396   ot->exec = collection_instance_add_exec;
1397   ot->poll = ED_operator_objectmode;
1398
1399   /* flags */
1400   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1401
1402   /* properties */
1403   RNA_def_string(
1404       ot->srna, "name", "Collection", MAX_ID_NAME - 2, "Name", "Collection name to add");
1405   prop = RNA_def_enum(ot->srna, "collection", DummyRNA_NULL_items, 0, "Collection", "");
1406   RNA_def_enum_funcs(prop, RNA_collection_itemf);
1407   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
1408   ot->prop = prop;
1409   ED_object_add_generic_props(ot, false);
1410 }
1411
1412 /** \} */
1413
1414 /* -------------------------------------------------------------------- */
1415 /** \name Add Speaker Operator
1416  * \{ */
1417
1418 static int object_speaker_add_exec(bContext *C, wmOperator *op)
1419 {
1420   Object *ob;
1421   ushort local_view_bits;
1422   float loc[3], rot[3];
1423   Scene *scene = CTX_data_scene(C);
1424
1425   if (!ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, NULL, &local_view_bits, NULL)) {
1426     return OPERATOR_CANCELLED;
1427   }
1428   ob = ED_object_add_type(C, OB_SPEAKER, NULL, loc, rot, false, local_view_bits);
1429
1430   /* to make it easier to start using this immediately in NLA, a default sound clip is created
1431    * ready to be moved around to retime the sound and/or make new sound clips
1432    */
1433   {
1434     /* create new data for NLA hierarchy */
1435     AnimData *adt = BKE_animdata_add_id(&ob->id);
1436     NlaTrack *nlt = BKE_nlatrack_add(adt, NULL);
1437     NlaStrip *strip = BKE_nla_add_soundstrip(scene, ob->data);
1438     strip->start = CFRA;
1439     strip->end += strip->start;
1440
1441     /* hook them up */
1442     BKE_nlatrack_add_strip(nlt, strip);
1443
1444     /* auto-name the strip, and give the track an interesting name  */
1445     BLI_strncpy(nlt->name, DATA_("SoundTrack"), sizeof(nlt->name));
1446     BKE_nlastrip_validate_name(adt, strip);
1447
1448     WM_event_add_notifier(C, NC_ANIMATION | ND_NLA | NA_EDITED, NULL);
1449   }
1450
1451   return OPERATOR_FINISHED;
1452 }
1453
1454 void OBJECT_OT_speaker_add(wmOperatorType *ot)
1455 {
1456   /* identifiers */
1457   ot->name = "Add Speaker";
1458   ot->description = "Add a speaker object to the scene";
1459   ot->idname = "OBJECT_OT_speaker_add";
1460
1461   /* api callbacks */
1462   ot->exec = object_speaker_add_exec;
1463   ot->poll = ED_operator_objectmode;
1464
1465   /* flags */
1466   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1467
1468   ED_object_add_generic_props(ot, true);
1469 }
1470
1471 /** \} */
1472
1473 /* -------------------------------------------------------------------- */
1474 /** \name Delete Object Operator
1475  * \{ */
1476
1477 /* remove base from a specific scene */
1478 /* note: now unlinks constraints as well */
1479 void ED_object_base_free_and_unlink(Main *bmain, Scene *scene, Object *ob)
1480 {
1481   if (BKE_library_ID_is_indirectly_used(bmain, ob) && ID_REAL_USERS(ob) <= 1 &&
1482       ID_EXTRA_USERS(ob) == 0) {
1483     /* We cannot delete indirectly used object... */
1484     printf(
1485         "WARNING, undeletable object '%s', should have been catched before reaching this "
1486         "function!",
1487         ob->id.name + 2);
1488     return;
1489   }
1490
1491   DEG_id_tag_update_ex(bmain, &ob->id, ID_RECALC_BASE_FLAGS);
1492
1493   BKE_scene_collections_object_remove(bmain, scene, ob, true);
1494 }
1495
1496 static int object_delete_exec(bContext *C, wmOperator *op)
1497 {
1498   Main *bmain = CTX_data_main(C);
1499   Scene *scene = CTX_data_scene(C);
1500   wmWindowManager *wm = CTX_wm_manager(C);
1501   wmWindow *win;
1502   const bool use_global = RNA_boolean_get(op->ptr, "use_global");
1503   uint changed_count = 0;
1504
1505   if (CTX_data_edit_object(C)) {
1506     return OPERATOR_CANCELLED;
1507   }
1508
1509   CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
1510     const bool is_indirectly_used = BKE_library_ID_is_indirectly_used(bmain, ob);
1511     if (ob->id.tag & LIB_TAG_INDIRECT) {
1512       /* Can this case ever happen? */
1513       BKE_reportf(op->reports,
1514                   RPT_WARNING,
1515                   "Cannot delete indirectly linked object '%s'",
1516                   ob->id.name + 2);
1517       continue;
1518     }
1519     else if (is_indirectly_used && ID_REAL_USERS(ob) <= 1 && ID_EXTRA_USERS(ob) == 0) {
1520       BKE_reportf(op->reports,
1521                   RPT_WARNING,
1522                   "Cannot delete object '%s' from scene '%s', indirectly used objects need at "
1523                   "least one user",
1524                   ob->id.name + 2,
1525                   scene->id.name + 2);
1526       continue;
1527     }
1528
1529     /* if grease pencil object, set cache as dirty */
1530     if (ob->type == OB_GPENCIL) {
1531       bGPdata *gpd = (bGPdata *)ob->data;
1532       DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
1533     }
1534
1535     /* This is sort of a quick hack to address T51243 -
1536      * Proper thing to do here would be to nuke most of all this custom scene/object/base handling,
1537      * and use generic lib remap/query for that.
1538      * But this is for later (aka 2.8, once layers & co are settled and working).
1539      */
1540     if (use_global && ob->id.lib == NULL) {
1541       /* We want to nuke the object, let's nuke it the easy way (not for linked data though)... */
1542       BKE_id_delete(bmain, &ob->id);
1543       changed_count += 1;
1544       continue;
1545     }
1546
1547     /* remove from Grease Pencil parent */
1548     /* XXX This is likely not correct?
1549      *     Will also remove parent from grease pencil from other scenes,
1550      *     even when use_global is false... */
1551     for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1552       for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1553         if (gpl->parent != NULL) {
1554           if (gpl->parent == ob) {
1555             gpl->parent = NULL;
1556           }
1557         }
1558       }
1559     }
1560
1561     /* remove from current scene only */
1562     ED_object_base_free_and_unlink(bmain, scene, ob);
1563     changed_count += 1;
1564
1565     if (use_global) {
1566       Scene *scene_iter;
1567       for (scene_iter = bmain->scenes.first; scene_iter; scene_iter = scene_iter->id.next) {
1568         if (scene_iter != scene && !ID_IS_LINKED(scene_iter)) {
1569           if (is_indirectly_used && ID_REAL_USERS(ob) <= 1 && ID_EXTRA_USERS(ob) == 0) {
1570             BKE_reportf(op->reports,
1571                         RPT_WARNING,
1572                         "Cannot delete object '%s' from scene '%s', indirectly used objects need "
1573                         "at least one user",
1574                         ob->id.name + 2,
1575                         scene_iter->id.name + 2);
1576             break;
1577           }
1578           ED_object_base_free_and_unlink(bmain, scene_iter, ob);
1579         }
1580       }
1581     }
1582     /* end global */
1583   }
1584   CTX_DATA_END;
1585
1586   BKE_reportf(op->reports, RPT_INFO, "Deleted %u object(s)", changed_count);
1587
1588   if (changed_count == 0) {
1589     return OPERATOR_CANCELLED;
1590   }
1591
1592   /* delete has to handle all open scenes */
1593   BKE_main_id_tag_listbase(&bmain->scenes, LIB_TAG_DOIT, true);
1594   for (win = wm->windows.first; win; win = win->next) {
1595     scene = WM_window_get_active_scene(win);
1596
1597     if (scene->id.tag & LIB_TAG_DOIT) {
1598       scene->id.tag &= ~LIB_TAG_DOIT;
1599
1600       DEG_relations_tag_update(bmain);
1601
1602       DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
1603       WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1604       WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
1605     }
1606   }
1607
1608   return OPERATOR_FINISHED;
1609 }
1610
1611 void OBJECT_OT_delete(wmOperatorType *ot)
1612 {
1613   /* identifiers */
1614   ot->name = "Delete";
1615   ot->description = "Delete selected objects";
1616   ot->idname = "OBJECT_OT_delete";
1617
1618   /* api callbacks */
1619   ot->invoke = WM_operator_confirm_or_exec;
1620   ot->exec = object_delete_exec;
1621   ot->poll = ED_operator_objectmode;
1622
1623   /* flags */
1624   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1625
1626   PropertyRNA *prop;
1627   prop = RNA_def_boolean(
1628       ot->srna, "use_global", 0, "Delete Globally", "Remove object from all scenes");
1629   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1630   WM_operator_properties_confirm_or_exec(ot);
1631 }
1632
1633 /** \} */
1634
1635 /* -------------------------------------------------------------------- */
1636 /** \name Copy Object Utilities
1637  * \{ */
1638
1639 /* after copying objects, copied data should get new pointers */
1640 static void copy_object_set_idnew(bContext *C)
1641 {
1642   Main *bmain = CTX_data_main(C);
1643
1644   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1645     BKE_libblock_relink_to_newid(&ob->id);
1646   }
1647   CTX_DATA_END;
1648
1649   BKE_main_id_clear_newpoins(bmain);
1650 }
1651
1652 /** \} */
1653
1654 /* -------------------------------------------------------------------- */
1655 /** \name Make Instanced Objects Real Operator
1656  * \{ */
1657
1658 /**
1659  * \note regarding hashing dupli-objects when using OB_DUPLICOLLECTION,
1660  * skip the first member of #DupliObject.persistent_id
1661  * since its a unique index and we only want to know if the group objects are from the same
1662  * dupli-group instance.
1663  */
1664 static unsigned int dupliobject_group_hash(const void *ptr)
1665 {
1666   const DupliObject *dob = ptr;
1667   unsigned int hash = BLI_ghashutil_ptrhash(dob->ob);
1668   unsigned int i;
1669   for (i = 1; (i < MAX_DUPLI_RECUR) && dob->persistent_id[i] != INT_MAX; i++) {
1670     hash ^= (dob->persistent_id[i] ^ i);
1671   }
1672   return hash;
1673 }
1674
1675 /**
1676  * \note regarding hashing dupli-objects when NOT using OB_DUPLICOLLECTION,
1677  * include the first member of #DupliObject.persistent_id
1678  * since its the index of the vertex/face the object is instantiated on and we want to identify
1679  * objects on the same vertex/face.
1680  */
1681 static unsigned int dupliobject_hash(const void *ptr)
1682 {
1683   const DupliObject *dob = ptr;
1684   unsigned int hash = BLI_ghashutil_ptrhash(dob->ob);
1685   hash ^= (dob->persistent_id[0] ^ 0);
1686   return hash;
1687 }
1688
1689 /* Compare function that matches dupliobject_group_hash */
1690 static bool dupliobject_group_cmp(const void *a_, const void *b_)
1691 {
1692   const DupliObject *a = a_;
1693   const DupliObject *b = b_;
1694   unsigned int i;
1695
1696   if (a->ob != b->ob) {
1697     return true;
1698   }
1699
1700   for (i = 1; (i < MAX_DUPLI_RECUR); i++) {
1701     if (a->persistent_id[i] != b->persistent_id[i]) {
1702       return true;
1703     }
1704     else if (a->persistent_id[i] == INT_MAX) {
1705       break;
1706     }
1707   }
1708
1709   /* matching */
1710   return false;
1711 }
1712
1713 /* Compare function that matches dupliobject_hash */
1714 static bool dupliobject_cmp(const void *a_, const void *b_)
1715 {
1716   const DupliObject *a = a_;
1717   const DupliObject *b = b_;
1718
1719   if (a->ob != b->ob) {
1720     return true;
1721   }
1722
1723   if (a->persistent_id[0] != b->persistent_id[0]) {
1724     return true;
1725   }
1726
1727   /* matching */
1728   return false;
1729 }
1730
1731 static void make_object_duplilist_real(
1732     bContext *C, Scene *scene, Base *base, const bool use_base_parent, const bool use_hierarchy)
1733 {
1734   Main *bmain = CTX_data_main(C);
1735   ViewLayer *view_layer = CTX_data_view_layer(C);
1736   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1737   ListBase *lb_duplis;
1738   DupliObject *dob;
1739   GHash *dupli_gh, *parent_gh = NULL;
1740
1741   if (!(base->object->transflag & OB_DUPLI)) {
1742     return;
1743   }
1744
1745   Object *object_eval = DEG_get_evaluated_object(depsgraph, base->object);
1746   lb_duplis = object_duplilist(depsgraph, scene, object_eval);
1747
1748   dupli_gh = BLI_ghash_ptr_new(__func__);
1749   if (use_hierarchy) {
1750     if (base->object->transflag & OB_DUPLICOLLECTION) {
1751       parent_gh = BLI_ghash_new(dupliobject_group_hash, dupliobject_group_cmp, __func__);
1752     }
1753     else {
1754       parent_gh = BLI_ghash_new(dupliobject_hash, dupliobject_cmp, __func__);
1755     }
1756   }
1757
1758   for (dob = lb_duplis->first; dob; dob = dob->next) {
1759     Object *ob_src = DEG_get_original_object(dob->ob);
1760     Object *ob_dst = ID_NEW_SET(ob_src, BKE_object_copy(bmain, ob_src));
1761     Base *base_dst;
1762
1763     /* font duplis can have a totcol without material, we get them from parent
1764      * should be implemented better...
1765      */
1766     if (ob_dst->mat == NULL) {
1767       ob_dst->totcol = 0;
1768     }
1769
1770     BKE_collection_object_add_from(bmain, scene, base->object, ob_dst);
1771     base_dst = BKE_view_layer_base_find(view_layer, ob_dst);
1772     BLI_assert(base_dst != NULL);
1773
1774     BKE_scene_object_base_flag_sync_from_base(base_dst);
1775
1776     /* make sure apply works */
1777     BKE_animdata_free(&ob_dst->id, true);
1778     ob_dst->adt = NULL;
1779
1780     /* Proxies are not to be copied. */
1781     ob_dst->proxy_from = NULL;
1782     ob_dst->proxy_group = NULL;
1783     ob_dst->proxy = NULL;
1784
1785     ob_dst->parent = NULL;
1786     BKE_constraints_free(&ob_dst->constraints);
1787     ob_dst->runtime.curve_cache = NULL;
1788     ob_dst->transflag &= ~OB_DUPLI;
1789
1790     copy_m4_m4(ob_dst->obmat, dob->mat);
1791     BKE_object_apply_mat4(ob_dst, ob_dst->obmat, false, false);
1792
1793     BLI_ghash_insert(dupli_gh, dob, ob_dst);
1794     if (parent_gh) {
1795       void **val;
1796       /* Due to nature of hash/comparison of this ghash, a lot of duplis may be considered as
1797        * 'the same', this avoids trying to insert same key several time and
1798        * raise asserts in debug builds... */
1799       if (!BLI_ghash_ensure_p(parent_gh, dob, &val)) {
1800         *val = ob_dst;
1801       }
1802     }
1803   }
1804
1805   for (dob = lb_duplis->first; dob; dob = dob->next) {
1806     Object *ob_src = dob->ob;
1807     Object *ob_dst = BLI_ghash_lookup(dupli_gh, dob);
1808
1809     /* Remap new object to itself, and clear again newid pointer of orig object. */
1810     BKE_libblock_relink_to_newid(&ob_dst->id);
1811
1812     DEG_id_tag_update(&ob_dst->id, ID_RECALC_GEOMETRY);
1813
1814     if (use_hierarchy) {
1815       /* original parents */
1816       Object *ob_src_par = ob_src->parent;
1817       Object *ob_dst_par = NULL;
1818
1819       /* find parent that was also made real */
1820       if (ob_src_par) {
1821         /* OK to keep most of the members uninitialized,
1822          * they won't be read, this is simply for a hash lookup. */
1823         DupliObject dob_key;
1824         dob_key.ob = ob_src_par;
1825         if (base->object->transflag & OB_DUPLICOLLECTION) {
1826           memcpy(&dob_key.persistent_id[1],
1827                  &dob->persistent_id[1],
1828                  sizeof(dob->persistent_id[1]) * (MAX_DUPLI_RECUR - 1));
1829         }
1830         else {
1831           dob_key.persistent_id[0] = dob->persistent_id[0];
1832         }
1833         ob_dst_par = BLI_ghash_lookup(parent_gh, &dob_key);
1834       }
1835
1836       if (ob_dst_par) {
1837         /* allow for all possible parent types */
1838         ob_dst->partype = ob_src->partype;
1839         BLI_strncpy(ob_dst->parsubstr, ob_src->parsubstr, sizeof(ob_dst->parsubstr));
1840         ob_dst->par1 = ob_src->par1;
1841         ob_dst->par2 = ob_src->par2;
1842         ob_dst->par3 = ob_src->par3;
1843
1844         copy_m4_m4(ob_dst->parentinv, ob_src->parentinv);
1845
1846         ob_dst->parent = ob_dst_par;
1847       }
1848       else if (use_base_parent) {
1849         ob_dst->parent = base->object;
1850         ob_dst->partype = PAROBJECT;
1851       }
1852     }
1853     else if (use_base_parent) {
1854       /* since we are ignoring the internal hierarchy - parent all to the
1855        * base object */
1856       ob_dst->parent = base->object;
1857       ob_dst->partype = PAROBJECT;
1858     }
1859
1860     if (ob_dst->parent) {
1861       /* note, this may be the parent of other objects, but it should
1862        * still work out ok */
1863       BKE_object_apply_mat4(ob_dst, dob->mat, false, true);
1864
1865       /* to set ob_dst->orig and in case there's any other discrepancies */
1866       DEG_id_tag_update(&ob_dst->id, ID_RECALC_TRANSFORM);
1867     }
1868   }
1869
1870   if (base->object->transflag & OB_DUPLICOLLECTION && base->object->instance_collection) {
1871     for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
1872       if (ob->proxy_group == base->object) {
1873         ob->proxy = NULL;
1874         ob->proxy_from = NULL;
1875         DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
1876       }
1877     }
1878   }
1879
1880   BLI_ghash_free(dupli_gh, NULL, NULL);
1881   if (parent_gh) {
1882     BLI_ghash_free(parent_gh, NULL, NULL);
1883   }
1884
1885   free_object_duplilist(lb_duplis);
1886
1887   BKE_main_id_clear_newpoins(bmain);
1888
1889   base->object->transflag &= ~OB_DUPLI;
1890   DEG_id_tag_update(&base->object->id, ID_RECALC_COPY_ON_WRITE);
1891 }
1892
1893 static int object_duplicates_make_real_exec(bContext *C, wmOperator *op)
1894 {
1895   Main *bmain = CTX_data_main(C);
1896   Scene *scene = CTX_data_scene(C);
1897
1898   const bool use_base_parent = RNA_boolean_get(op->ptr, "use_base_parent");
1899   const bool use_hierarchy = RNA_boolean_get(op->ptr, "use_hierarchy");
1900
1901   BKE_main_id_clear_newpoins(bmain);
1902
1903   CTX_DATA_BEGIN (C, Base *, base, selected_editable_bases) {
1904     make_object_duplilist_real(C, scene, base, use_base_parent, use_hierarchy);
1905
1906     /* dependencies were changed */
1907     WM_event_add_notifier(C, NC_OBJECT | ND_PARENT, base->object);
1908   }
1909   CTX_DATA_END;
1910
1911   DEG_relations_tag_update(bmain);
1912   WM_event_add_notifier(C, NC_SCENE, scene);
1913   WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
1914
1915   return OPERATOR_FINISHED;
1916 }
1917
1918 void OBJECT_OT_duplicates_make_real(wmOperatorType *ot)
1919 {
1920   /* identifiers */
1921   ot->name = "Make Duplicates Real";
1922   ot->description = "Make dupli objects attached to this object real";
1923   ot->idname = "OBJECT_OT_duplicates_make_real";
1924
1925   /* api callbacks */
1926   ot->exec = object_duplicates_make_real_exec;
1927
1928   ot->poll = ED_operator_objectmode;
1929
1930   /* flags */
1931   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_USE_EVAL_DATA;
1932
1933   RNA_def_boolean(ot->srna,
1934                   "use_base_parent",
1935                   0,
1936                   "Parent",
1937                   "Parent newly created objects to the original duplicator");
1938   RNA_def_boolean(
1939       ot->srna, "use_hierarchy", 0, "Keep Hierarchy", "Maintain parent child relationships");
1940 }
1941
1942 /** \} */
1943
1944 /* -------------------------------------------------------------------- */
1945 /** \name Data Convert Operator
1946  * \{ */
1947
1948 static const EnumPropertyItem convert_target_items[] = {
1949     {OB_CURVE, "CURVE", ICON_OUTLINER_OB_CURVE, "Curve from Mesh/Text", ""},
1950     {OB_MESH, "MESH", ICON_OUTLINER_OB_MESH, "Mesh from Curve/Meta/Surf/Text", ""},
1951     {0, NULL, 0, NULL, NULL},
1952 };
1953
1954 static void convert_ensure_curve_cache(Depsgraph *depsgraph, Scene *scene, Object *ob)
1955 {
1956   if (ob->runtime.curve_cache == NULL) {
1957     /* Force creation. This is normally not needed but on operator
1958      * redo we might end up with an object which isn't evaluated yet.
1959      * Also happens in case we are working on a copy of the object
1960      * (all its caches have been nuked then).
1961      */
1962     if (ELEM(ob->type, OB_SURF, OB_CURVE, OB_FONT)) {
1963       /* We need 'for render' ON here, to enable computing bevel dipslist if needed.
1964        * Also makes sense anyway, we would not want e.g. to loose hidden parts etc. */
1965       BKE_displist_make_curveTypes(depsgraph, scene, ob, true, false);
1966     }
1967     else if (ob->type == OB_MBALL) {
1968       BKE_displist_make_mball(depsgraph, scene, ob);
1969     }
1970   }
1971 }
1972
1973 static void curvetomesh(Main *bmain, Depsgraph *depsgraph, Object *ob)
1974 {
1975   Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
1976   Curve *curve = ob->data;
1977   Mesh *mesh = BKE_mesh_new_from_object_to_bmain(bmain, depsgraph, object_eval, true);
1978   BKE_object_free_modifiers(ob, 0);
1979   /* Replace curve used by the object itself. */
1980   ob->data = mesh;
1981   ob->type = OB_MESH;
1982   id_us_min(&curve->id);
1983   id_us_plus(&mesh->id);
1984   /* Change objects which are using same curve.
1985    * A bit annoying, but:
1986    * - It's possible to have multiple curve objects selected which are sharing the same curve
1987    *   datablock. We don't want mesh to be created for every of those objects.
1988    * - This is how conversion worked for a long long time. */
1989   LISTBASE_FOREACH (Object *, other_object, &bmain->objects) {
1990     if (other_object->data == curve) {
1991       other_object->type = OB_MESH;
1992
1993       id_us_min((ID *)other_object->data);
1994       other_object->data = ob->data;
1995       id_us_plus((ID *)other_object->data);
1996     }
1997   }
1998 }
1999
2000 static bool convert_poll(bContext *C)
2001 {
2002   Scene *scene = CTX_data_scene(C);
2003   Base *base_act = CTX_data_active_base(C);
2004   Object *obact = base_act ? base_act->object : NULL;
2005
2006   return (!ID_IS_LINKED(scene) && obact && (BKE_object_is_in_editmode(obact) == false) &&
2007           (base_act->flag & BASE_SELECTED) && !ID_IS_LINKED(obact));
2008 }
2009
2010 /* Helper for convert_exec */
2011 static Base *duplibase_for_convert(
2012     Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base, Object *ob)
2013 {
2014   Object *obn;
2015   Base *basen;
2016
2017   if (ob == NULL) {
2018     ob = base->object;
2019   }
2020
2021   obn = BKE_object_copy(bmain, ob);
2022   DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
2023   BKE_collection_object_add_from(bmain, scene, ob, obn);
2024
2025   basen = BKE_view_layer_base_find(view_layer, obn);
2026   ED_object_base_select(basen, BA_SELECT);
2027   ED_object_base_select(basen, BA_DESELECT);
2028   return basen;
2029 }
2030
2031 static int convert_exec(bContext *C, wmOperator *op)
2032 {
2033   Main *bmain = CTX_data_main(C);
2034   Depsgraph *depsgraph = CTX_data_depsgraph(C);
2035   Scene *scene = CTX_data_scene(C);
2036   ViewLayer *view_layer = CTX_data_view_layer(C);
2037   Base *basen = NULL, *basact = NULL;
2038   Object *ob1, *obact = CTX_data_active_object(C);
2039   Curve *cu;
2040   Nurb *nu;
2041   MetaBall *mb;
2042   Mesh *me;
2043   const short target = RNA_enum_get(op->ptr, "target");
2044   bool keep_original = RNA_boolean_get(op->ptr, "keep_original");
2045   int a, mballConverted = 0;
2046
2047   /* don't forget multiple users! */
2048
2049   {
2050     FOREACH_SCENE_OBJECT_BEGIN (scene, ob) {
2051       ob->flag &= ~OB_DONE;
2052
2053       /* flag data that's not been edited (only needed for !keep_original) */
2054       if (ob->data) {
2055         ((ID *)ob->data)->tag |= LIB_TAG_DOIT;
2056       }
2057
2058       /* possible metaball basis is not in this scene */
2059       if (ob->type == OB_MBALL && target == OB_MESH) {
2060         if (BKE_mball_is_basis(ob) == false) {
2061           Object *ob_basis;
2062           ob_basis = BKE_mball_basis_find(scene, ob);
2063           if (ob_basis) {
2064             ob_basis->flag &= ~OB_DONE;
2065           }
2066         }
2067       }
2068     }
2069     FOREACH_SCENE_OBJECT_END;
2070   }
2071
2072   ListBase selected_editable_bases;
2073   CTX_data_selected_editable_bases(C, &selected_editable_bases);
2074
2075   /* Ensure we get all meshes calculated with a sufficient data-mask,
2076    * needed since re-evaluating single modifiers causes bugs if they depend
2077    * on other objects data masks too, see: T50950. */
2078   {
2079     for (CollectionPointerLink *link = selected_editable_bases.first; link; link = link->next) {
2080       Base *base = link->ptr.data;
2081       Object *ob = base->object;
2082
2083       /* The way object type conversion works currently (enforcing conversion of *all* objects
2084        * using converted object-data, even some un-selected/hidden/another scene ones,
2085        * sounds totally bad to me.
2086        * However, changing this is more design than bug-fix, not to mention convoluted code below,
2087        * so that will be for later.
2088        * But at the very least, do not do that with linked IDs! */
2089       if ((ID_IS_LINKED(ob) || (ob->data && ID_IS_LINKED(ob->data))) && !keep_original) {
2090         keep_original = true;
2091         BKE_report(
2092             op->reports,
2093             RPT_INFO,
2094             "Converting some linked object/object data, enforcing 'Keep Original' option to True");
2095       }
2096
2097       DEG_id_tag_update(&base->object->id, ID_RECALC_GEOMETRY);
2098     }
2099
2100     CustomData_MeshMasks customdata_mask_prev = scene->customdata_mask;
2101     CustomData_MeshMasks_update(&scene->customdata_mask, &CD_MASK_MESH);
2102     BKE_scene_graph_update_tagged(depsgraph, bmain);
2103     scene->customdata_mask = customdata_mask_prev;
2104   }
2105
2106   for (CollectionPointerLink *link = selected_editable_bases.first; link; link = link->next) {
2107     Object *newob = NULL;
2108     Base *base = link->ptr.data;
2109     Object *ob = base->object;
2110
2111     if (ob->flag & OB_DONE || !IS_TAGGED(ob->data)) {
2112       if (ob->type != target) {
2113         base->flag &= ~SELECT;
2114         ob->flag &= ~SELECT;
2115       }
2116
2117       /* obdata already modified */
2118       if (!IS_TAGGED(ob->data)) {
2119         /* When 2 objects with linked data are selected, converting both
2120          * would keep modifiers on all but the converted object [#26003] */
2121         if (ob->type == OB_MESH) {
2122           BKE_object_free_modifiers(ob, 0); /* after derivedmesh calls! */
2123         }
2124         if (ob->type == OB_GPENCIL) {
2125           BKE_object_free_modifiers(ob, 0); /* after derivedmesh calls! */
2126           BKE_object_free_shaderfx(ob, 0);
2127         }
2128       }
2129     }
2130     else if (ob->type == OB_MESH && target == OB_CURVE) {
2131       ob->flag |= OB_DONE;
2132
2133       if (keep_original) {
2134         basen = duplibase_for_convert(bmain, scene, view_layer, base, NULL);
2135         newob = basen->object;
2136
2137         /* decrement original mesh's usage count  */
2138         me = newob->data;
2139         id_us_min(&me->id);
2140
2141         /* make a new copy of the mesh */
2142         newob->data = BKE_mesh_copy(bmain, me);
2143       }
2144       else {
2145         newob = ob;
2146       }
2147
2148       BKE_mesh_to_curve(bmain, depsgraph, scene, newob);
2149
2150       if (newob->type == OB_CURVE) {
2151         BKE_object_free_modifiers(newob, 0); /* after derivedmesh calls! */
2152         ED_rigidbody_object_remove(bmain, scene, newob);
2153       }
2154     }
2155     else if (ob->type == OB_MESH) {
2156       ob->flag |= OB_DONE;
2157
2158       if (keep_original) {
2159         basen = duplibase_for_convert(bmain, scene, view_layer, base, NULL);
2160         newob = basen->object;
2161
2162         /* decrement original mesh's usage count  */
2163         me = newob->data;
2164         id_us_min(&me->id);
2165
2166         /* make a new copy of the mesh */
2167         newob->data = BKE_mesh_copy(bmain, me);
2168       }
2169       else {
2170         newob = ob;
2171         DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
2172       }
2173
2174       /* make new mesh data from the original copy */
2175       /* note: get the mesh from the original, not from the copy in some
2176        * cases this doesn't give correct results (when MDEF is used for eg)
2177        */
2178       Scene *scene_eval = (Scene *)DEG_get_evaluated_id(depsgraph, &scene->id);
2179       Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
2180       Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_MESH);
2181       me_eval = BKE_mesh_copy_for_eval(me_eval, false);
2182       BKE_mesh_nomain_to_mesh(me_eval, newob->data, newob, &CD_MASK_MESH, true);
2183       BKE_object_free_modifiers(newob, 0); /* after derivedmesh calls! */
2184     }
2185     else if (ob->type == OB_FONT) {
2186       ob->flag |= OB_DONE;
2187
2188       if (keep_original) {
2189         basen = duplibase_for_convert(bmain, scene, view_layer, base, NULL);
2190         newob = basen->object;
2191
2192         /* decrement original curve's usage count  */
2193         id_us_min(&((Curve *)newob->data)->id);
2194
2195         /* make a new copy of the curve */
2196         newob->data = BKE_curve_copy(bmain, ob->data);
2197       }
2198       else {
2199         newob = ob;
2200       }
2201
2202       cu = newob->data;
2203
2204       /* TODO(sergey): Ideally DAG will create nurbs list for a curve data
2205        *               datablock, but for until we've got granular update
2206        *               lets take care by selves.
2207        */
2208       /* XXX This may fail/crash, since BKE_vfont_to_curve()
2209        * accesses evaluated data in some cases (bastien). */
2210       BKE_vfont_to_curve(newob, FO_EDIT);
2211
2212       newob->type = OB_CURVE;
2213       cu->type = OB_CURVE;
2214
2215       if (cu->vfont) {
2216         id_us_min(&cu->vfont->id);
2217         cu->vfont = NULL;
2218       }
2219       if (cu->vfontb) {
2220         id_us_min(&cu->vfontb->id);
2221         cu->vfontb = NULL;
2222       }
2223       if (cu->vfonti) {
2224         id_us_min(&cu->vfonti->id);
2225         cu->vfonti = NULL;
2226       }
2227       if (cu->vfontbi) {
2228         id_us_min(&cu->vfontbi->id);
2229         cu->vfontbi = NULL;
2230       }
2231
2232       if (!keep_original) {
2233         /* other users */
2234         if (cu->id.us > 1) {
2235           for (ob1 = bmain->objects.first; ob1; ob1 = ob1->id.next) {
2236             if (ob1->data == ob->data) {
2237               ob1->type = OB_CURVE;
2238               DEG_id_tag_update(&ob1->id,
2239                                 ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION);
2240             }
2241           }
2242         }
2243       }
2244
2245       for (nu = cu->nurb.first; nu; nu = nu->next) {
2246         nu->charidx = 0;
2247       }
2248
2249       cu->flag &= ~CU_3D;
2250       BKE_curve_curve_dimension_update(cu);
2251
2252       if (target == OB_MESH) {
2253         curvetomesh(bmain, depsgraph, newob);
2254
2255         /* meshes doesn't use displist */
2256         BKE_object_free_curve_cache(newob);
2257       }
2258     }
2259     else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
2260       ob->flag |= OB_DONE;
2261
2262       if (target == OB_MESH) {
2263         if (keep_original) {
2264           basen = duplibase_for_convert(bmain, scene, view_layer, base, NULL);
2265           newob = basen->object;
2266
2267           /* decrement original curve's usage count  */
2268           id_us_min(&((Curve *)newob->data)->id);
2269
2270           /* make a new copy of the curve */
2271           newob->data = BKE_curve_copy(bmain, ob->data);
2272         }
2273         else {
2274           newob = ob;
2275         }
2276
2277         curvetomesh(bmain, depsgraph, newob);
2278
2279         /* meshes doesn't use displist */
2280         BKE_object_free_curve_cache(newob);
2281       }
2282     }
2283     else if (ob->type == OB_MBALL && target == OB_MESH) {
2284       Object *baseob;
2285
2286       base->flag &= ~BASE_SELECTED;
2287       ob->base_flag &= ~BASE_SELECTED;
2288
2289       baseob = BKE_mball_basis_find(scene, ob);
2290
2291       if (ob != baseob) {
2292         /* if motherball is converting it would be marked as done later */
2293         ob->flag |= OB_DONE;
2294       }
2295
2296       if (!(baseob->flag & OB_DONE)) {
2297         baseob->flag |= OB_DONE;
2298
2299         basen = duplibase_for_convert(bmain, scene, view_layer, base, baseob);
2300         newob = basen->object;
2301
2302         mb = newob->data;
2303         id_us_min(&mb->id);
2304
2305         newob->data = BKE_mesh_add(bmain, "Mesh");
2306         newob->type = OB_MESH;
2307
2308         me = newob->data;
2309         me->totcol = mb->totcol;
2310         if (newob->totcol) {
2311           me->mat = MEM_dupallocN(mb->mat);
2312           for (a = 0; a < newob->totcol; a++) {
2313             id_us_plus((ID *)me->mat[a]);
2314           }
2315         }
2316
2317         convert_ensure_curve_cache(depsgraph, scene, baseob);
2318         BKE_mesh_from_metaball(&baseob->runtime.curve_cache->disp, newob->data);
2319
2320         if (obact->type == OB_MBALL) {
2321           basact = basen;
2322         }
2323
2324         mballConverted = 1;
2325       }
2326     }
2327     else {
2328       continue;
2329     }
2330
2331     /* Ensure new object has consistent material data with its new obdata. */
2332     if (newob) {
2333       test_object_materials(bmain, newob, newob->data);
2334     }
2335
2336     /* tag obdata if it was been changed */
2337
2338     /* If the original object is active then make this object active */
2339     if (basen) {
2340       if (ob == obact) {
2341         /* store new active base to update BASACT */
2342         basact = basen;
2343       }
2344
2345       if (keep_original) {
2346         ED_object_base_select(base, BA_DESELECT);
2347         ED_object_base_select(basen, BA_SELECT);
2348       }
2349
2350       basen = NULL;
2351     }
2352
2353     if (!keep_original && (ob->flag & OB_DONE)) {
2354       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
2355       ((ID *)ob->data)->tag &= ~LIB_TAG_DOIT; /* flag not to convert this datablock again */
2356     }
2357   }
2358   BLI_freelistN(&selected_editable_bases);
2359
2360   if (!keep_original) {
2361     if (mballConverted) {
2362       FOREACH_SCENE_OBJECT_BEGIN (scene, ob_mball) {
2363         if (ob_mball->type == OB_MBALL) {
2364           if (ob_mball->flag & OB_DONE) {
2365             Object *ob_basis = NULL;
2366             if (BKE_mball_is_basis(ob_mball) ||
2367                 ((ob_basis = BKE_mball_basis_find(scene, ob_mball)) &&
2368                  (ob_basis->flag & OB_DONE))) {
2369               ED_object_base_free_and_unlink(bmain, scene, ob_mball);
2370             }
2371           }
2372         }
2373       }
2374       FOREACH_SCENE_OBJECT_END;
2375     }
2376   }
2377
2378   // XXX  ED_object_editmode_enter(C, 0);
2379   // XXX  exit_editmode(C, EM_FREEDATA|); /* freedata, but no undo */
2380
2381   if (basact) {
2382     /* active base was changed */
2383     ED_object_base_activate(C, basact);
2384     BASACT(view_layer) = basact;
2385   }
2386   else if (BASACT(view_layer)->object->flag & OB_DONE) {
2387     WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, BASACT(view_layer)->object);
2388     WM_event_add_notifier(C, NC_OBJECT | ND_DATA, BASACT(view_layer)->object);
2389   }
2390
2391   DEG_relations_tag_update(bmain);
2392   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
2393   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, scene);
2394   WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
2395
2396   return OPERATOR_FINISHED;
2397 }
2398
2399 void OBJECT_OT_convert(wmOperatorType *ot)
2400 {
2401   /* identifiers */
2402   ot->name = "Convert to";
2403   ot->description = "Convert selected objects to another type";
2404   ot->idname = "OBJECT_OT_convert";
2405
2406   /* api callbacks */
2407   ot->invoke = WM_menu_invoke;
2408   ot->exec = convert_exec;
2409   ot->poll = convert_poll;
2410
2411   /* flags */
2412   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2413
2414   /* properties */
2415   ot->prop = RNA_def_enum(
2416       ot->srna, "target", convert_target_items, OB_MESH, "Target", "Type of object to convert to");
2417   RNA_def_boolean(ot->srna,
2418                   "keep_original",
2419                   0,
2420                   "Keep Original",
2421                   "Keep original objects instead of replacing them");
2422 }
2423
2424 /** \} */
2425
2426 /* -------------------------------------------------------------------- */
2427 /** \name Duplicate Object Operator
2428  * \{ */
2429
2430 /*
2431  * dupflag: a flag made from constants declared in DNA_userdef_types.h
2432  * The flag tells adduplicate() whether to copy data linked to the object,
2433  * or to reference the existing data.
2434  * U.dupflag for default operations or you can construct a flag as python does
2435  * if the dupflag is 0 then no data will be copied (linked duplicate). */
2436
2437 /* used below, assumes id.new is correct */
2438 /* leaves selection of base/object unaltered */
2439 /* Does set ID->newid pointers. */
2440 static Base *object_add_duplicate_internal(
2441     Main *bmain, Scene *scene, ViewLayer *view_layer, Object *ob, int dupflag)
2442 {
2443   Base *base, *basen = NULL;
2444   Object *obn;
2445
2446   if (ob->mode & OB_MODE_POSE) {
2447     /* nothing? */
2448   }
2449   else {
2450     obn = ID_NEW_SET(ob, BKE_object_duplicate(bmain, ob, dupflag));
2451     DEG_id_tag_update(&obn->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
2452
2453     base = BKE_view_layer_base_find(view_layer, ob);
2454     if ((base != NULL) && (base->flag & BASE_VISIBLE)) {
2455       BKE_collection_object_add_from(bmain, scene, ob, obn);
2456     }
2457     else {
2458       LayerCollection *layer_collection = BKE_layer_collection_get_active(view_layer);
2459       BKE_collection_object_add(bmain, layer_collection->collection, obn);
2460     }
2461
2462     basen = BKE_view_layer_base_find(view_layer, obn);
2463     if (base != NULL) {
2464       basen->local_view_bits = base->local_view_bits;
2465     }
2466
2467     /* 1) duplis should end up in same collection as the original
2468      * 2) Rigid Body sim participants MUST always be part of a collection...
2469      */
2470     // XXX: is 2) really a good measure here?
2471     if (ob->rigidbody_object || ob->rigidbody_constraint) {
2472       Collection *collection;
2473       for (collection = bmain->collections.first; collection; collection = collection->id.next) {
2474         if (BKE_collection_has_object(collection, ob)) {
2475           BKE_collection_object_add(bmain, collection, obn);
2476         }
2477       }
2478     }
2479   }
2480   return basen;
2481 }
2482
2483 /* single object duplicate, if dupflag==0, fully linked, else it uses the flags given */
2484 /* leaves selection of base/object unaltered.
2485  * note: don't call this within a loop since clear_* funcs loop over the entire database.
2486  * note: caller must do DAG_relations_tag_update(bmain);
2487  *       this is not done automatic since we may duplicate many objects in a batch */
2488 Base *ED_object_add_duplicate(
2489     Main *bmain, Scene *scene, ViewLayer *view_layer, Base *base, int dupflag)
2490 {
2491   Base *basen;
2492   Object *ob;
2493
2494   basen = object_add_duplicate_internal(bmain, scene, view_layer, base->object, dupflag);
2495   if (basen == NULL) {
2496     return NULL;
2497   }
2498
2499   ob = basen->object;
2500
2501   /* link own references to the newly duplicated data [#26816] */
2502   BKE_libblock_relink_to_newid(&ob->id);
2503
2504   /* DAG_relations_tag_update(bmain); */ /* caller must do */
2505
2506   if (ob->data != NULL) {
2507     DEG_id_tag_update_ex(bmain, (ID *)ob->data, ID_RECALC_EDITORS);
2508   }
2509
2510   BKE_main_id_clear_newpoins(bmain);
2511
2512   return basen;
2513 }
2514
2515 /* contextual operator dupli */
2516 static int duplicate_exec(bContext *C, wmOperator *op)
2517 {
2518   Main *bmain = CTX_data_main(C);
2519   Scene *scene = CTX_data_scene(C);
2520   ViewLayer *view_layer = CTX_data_view_layer(C);
2521   const bool linked = RNA_boolean_get(op->ptr, "linked");
2522   int dupflag = (linked) ? 0 : U.dupflag;
2523
2524   CTX_DATA_BEGIN (C, Base *, base, selected_bases) {
2525     Base *basen = object_add_duplicate_internal(bmain, scene, view_layer, base->object, dupflag);
2526
2527     /* note that this is safe to do with this context iterator,
2528      * the list is made in advance */
2529     ED_object_base_select(base, BA_DESELECT);
2530     ED_object_base_select(basen, BA_SELECT);
2531
2532     if (basen == NULL) {
2533       continue;
2534     }
2535
2536     /* new object becomes active */
2537     if (BASACT(view_layer) == base) {
2538       ED_object_base_activate(C, basen);
2539     }
2540
2541     if (basen->object->data) {
2542       DEG_id_tag_update(basen->object->data, 0);
2543     }
2544   }
2545   CTX_DATA_END;
2546
2547   copy_object_set_idnew(C);
2548
2549   DEG_relations_tag_update(bmain);
2550   DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE | ID_RECALC_SELECT);
2551
2552   WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
2553
2554   return OPERATOR_FINISHED;
2555 }
2556
2557 void OBJECT_OT_duplicate(wmOperatorType *ot)
2558 {
2559   PropertyRNA *prop;
2560
2561   /* identifiers */
2562   ot->name = "Duplicate Objects";
2563   ot->description = "Duplicate selected objects";
2564   ot->idname = "OBJECT_OT_duplicate";
2565
2566   /* api callbacks */
2567   ot->exec = duplicate_exec;
2568   ot->poll = ED_operator_objectmode;
2569
2570   /* flags */
2571   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2572
2573   /* to give to transform */
2574   prop = RNA_def_boolean(ot->srna,
2575                          "linked",
2576                          0,
2577                          "Linked",
2578                          "Duplicate object but not object data, linking to the original data");
2579   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
2580
2581   prop = RNA_def_enum(
2582       ot->srna, "mode", rna_enum_transform_mode_types, TFM_TRANSLATION, "Mode", "");
2583   RNA_def_property_flag(prop, PROP_HIDDEN);
2584 }
2585
2586 /** \} */
2587
2588 /* -------------------------------------------------------------------- */
2589 /** \name Add Named Object Operator
2590  *
2591  * Use for for drag & drop.
2592  * \{ */
2593
2594 static int add_named_exec(bContext *C, wmOperator *op)
2595 {
2596   wmWindow *win = CTX_wm_window(C);
2597   const wmEvent *event = win ? win->eventstate : NULL;
2598   Main *bmain = CTX_data_main(C);
2599   Scene *scene = CTX_data_scene(C);
2600   ViewLayer *view_layer = CTX_data_view_layer(C);
2601   Base *basen;
2602   Object *ob;
2603   const bool linked = RNA_boolean_get(op->ptr, "linked");
2604   int dupflag = (linked) ? 0 : U.dupflag;
2605   char name[MAX_ID_NAME - 2];
2606
2607   /* find object, create fake base */
2608   RNA_string_get(op->ptr, "name", name);
2609   ob = (Object *)BKE_libblock_find_name(bmain, ID_OB, name);
2610
2611   if (ob == NULL) {
2612     BKE_report(op->reports, RPT_ERROR, "Object not found");
2613     return OPERATOR_CANCELLED;
2614   }
2615
2616   /* prepare dupli */
2617   basen = object_add_duplicate_internal(bmain, scene, view_layer, ob, dupflag);
2618
2619   if (basen == NULL) {
2620     BKE_report(op->reports, RPT_ERROR, "Object could not be duplicated");
2621     return OPERATOR_CANCELLED;
2622   }
2623
2624   basen->object->restrictflag &= ~OB_RESTRICT_VIEWPORT;
2625
2626   if (event) {
2627     ARegion *ar = CTX_wm_region(C);
2628     const int mval[2] = {event->x - ar->winrct.xmin, event->y - ar->winrct.ymin};
2629     ED_object_location_from_view(C, basen->object->loc);
2630     ED_view3d_cursor3d_position(C, mval, false, basen->object->loc);
2631   }
2632
2633   ED_object_base_select(basen, BA_SELECT);
2634   ED_object_base_activate(C, basen);
2635
2636   copy_object_set_idnew(C);
2637
2638   /* TODO(sergey): Only update relations for the current scene. */
2639   DEG_relations_tag_update(bmain);
2640
2641   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
2642   WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
2643   WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
2644
2645   return OPERATOR_FINISHED;
2646 }
2647
2648 void OBJECT_OT_add_named(wmOperatorType *ot)
2649 {
2650   /* identifiers */
2651   ot->name = "Add Named Object";
2652   ot->description = "Add named object";
2653   ot->idname = "OBJECT_OT_add_named";
2654
2655   /* api callbacks */
2656   ot->exec = add_named_exec;
2657   ot->poll = ED_operator_objectmode;
2658
2659   /* flags */
2660   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2661
2662   RNA_def_boolean(ot->srna,
2663                   "linked",
2664                   0,
2665                   "Linked",
2666                   "Duplicate object but not object data, linking to the original data");
2667   RNA_def_string(ot->srna, "name", NULL, MAX_ID_NAME - 2, "Name", "Object name to add");
2668 }
2669
2670 /** \} */
2671
2672 /* -------------------------------------------------------------------- */
2673 /** \name Join Object Operator
2674  *
2675  * \{ */
2676
2677 static bool join_poll(bContext *C)
2678 {
2679   Object *ob = CTX_data_active_object(C);
2680
2681   if (!ob || ID_IS_LINKED(ob)) {
2682     return 0;
2683   }
2684
2685   if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_ARMATURE, OB_GPENCIL)) {
2686     return ED_operator_screenactive(C);
2687   }
2688   else {
2689     return 0;
2690   }
2691 }
2692
2693 static int join_exec(bContext *C, wmOperator *op)
2694 {
2695   Object *ob = CTX_data_active_object(C);
2696
2697   if (ob->mode & OB_MODE_EDIT) {
2698     BKE_report(op->reports, RPT_ERROR, "This data does not support joining in edit mode");
2699     return OPERATOR_CANCELLED;
2700   }
2701   else if (BKE_object_obdata_is_libdata(ob)) {
2702     BKE_report(op->reports, RPT_ERROR, "Cannot edit external library data");
2703     return OPERATOR_CANCELLED;
2704   }
2705   else if (ob->type == OB_GPENCIL) {
2706     bGPdata *gpd = (bGPdata *)ob->data;
2707     if ((!gpd) || GPENCIL_ANY_MODE(gpd)) {
2708       BKE_report(op->reports, RPT_ERROR, "This data does not support joining in this mode");
2709       return OPERATOR_CANCELLED;
2710     }
2711   }
2712
2713   if (ob->type == OB_MESH) {
2714     return join_mesh_exec(C, op);
2715   }
2716   else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
2717     return join_curve_exec(C, op);
2718   }
2719   else if (ob->type == OB_ARMATURE) {
2720     return join_armature_exec(C, op);
2721   }
2722   else if (ob->type == OB_GPENCIL) {
2723     return ED_gpencil_join_objects_exec(C, op);
2724   }
2725
2726   return OPERATOR_CANCELLED;
2727 }
2728
2729 void OBJECT_OT_join(wmOperatorType *ot)
2730 {
2731   /* identifiers */
2732   ot->name = "Join";
2733   ot->description = "Join selected objects into active object";
2734   ot->idname = "OBJECT_OT_join";
2735
2736   /* api callbacks */
2737   ot->exec = join_exec;
2738   ot->poll = join_poll;
2739
2740   /* flags */
2741   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2742 }
2743
2744 /** \} */
2745
2746 /* -------------------------------------------------------------------- */
2747 /** \name Join as Shape Key Operator
2748  * \{ */
2749
2750 static bool join_shapes_poll(bContext *C)
2751 {
2752   Object *ob = CTX_data_active_object(C);
2753
2754   if (!ob || ID_IS_LINKED(ob)) {
2755     return 0;
2756   }
2757
2758   /* only meshes supported at the moment */
2759   if (ob->type == OB_MESH) {
2760     return ED_operator_screenactive(C);
2761   }
2762   else {
2763     return 0;
2764   }
2765 }
2766
2767 static int join_shapes_exec(bContext *C, wmOperator *op)
2768 {
2769   Object *ob = CTX_data_active_object(C);
2770
2771   if (ob->mode & OB_MODE_EDIT) {
2772     BKE_report(op->reports, RPT_ERROR, "This data does not support joining in edit mode");
2773     return OPERATOR_CANCELLED;
2774   }
2775   else if (BKE_object_obdata_is_libdata(ob)) {
2776     BKE_report(op->reports, RPT_ERROR, "Cannot edit external library data");
2777     return OPERATOR_CANCELLED;
2778   }
2779
2780   if (ob->type == OB_MESH) {
2781     return join_mesh_shapes_exec(C, op);
2782   }
2783
2784   return OPERATOR_CANCELLED;
2785 }
2786
2787 void OBJECT_OT_join_shapes(wmOperatorType *ot)
2788 {
2789   /* identifiers */
2790   ot->name = "Join as Shapes";
2791   ot->description = "Merge selected objects to shapes of active object";
2792   ot->idname = "OBJECT_OT_join_shapes";
2793
2794   /* api callbacks */
2795   ot->exec = join_shapes_exec;
2796   ot->poll = join_shapes_poll;
2797
2798   /* flags */
2799   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2800 }
2801
2802 /** \} */