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