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