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