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