Merge branch 'blender2.7'
[blender.git] / source / blender / editors / mesh / editmesh_add.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2004 by Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Joseph Eagar
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/mesh/editmesh_add.c
29  *  \ingroup edmesh
30  */
31
32 #include "DNA_meshdata_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_scene_types.h"
35
36 #include "BLI_math.h"
37
38 #include "BLT_translation.h"
39
40 #include "BKE_context.h"
41 #include "BKE_editmesh.h"
42
43 #include "RNA_define.h"
44 #include "RNA_access.h"
45
46 #include "WM_api.h"
47 #include "WM_types.h"
48
49 #include "ED_mesh.h"
50 #include "ED_screen.h"
51 #include "ED_object.h"
52 #include "ED_uvedit.h"
53
54 #include "mesh_intern.h"  /* own include */
55
56
57 #define MESH_ADD_VERTS_MAXI 10000000
58
59
60 /* ********* add primitive operators ************* */
61
62 typedef struct MakePrimitiveData {
63         float mat[4][4];
64         bool was_editmode;
65 } MakePrimitiveData;
66
67 static Object *make_prim_init(
68         bContext *C, const char *idname,
69         const float loc[3], const float rot[3], ushort local_view_bits,
70         MakePrimitiveData *r_creation_data)
71 {
72         Object *obedit = CTX_data_edit_object(C);
73
74         r_creation_data->was_editmode = false;
75         if (obedit == NULL || obedit->type != OB_MESH) {
76                 obedit = ED_object_add_type(C, OB_MESH, idname, loc, rot, false, local_view_bits);
77
78                 /* create editmode */
79                 ED_object_editmode_enter(C, EM_IGNORE_LAYER); /* rare cases the active layer is messed up */
80                 r_creation_data->was_editmode = true;
81         }
82
83         ED_object_new_primitive_matrix(C, obedit, loc, rot, r_creation_data->mat);
84
85         return obedit;
86 }
87
88 static void make_prim_finish(bContext *C, Object *obedit, const MakePrimitiveData *creation_data, int enter_editmode)
89 {
90         BMEditMesh *em = BKE_editmesh_from_object(obedit);
91         const bool exit_editmode = ((creation_data->was_editmode == true) && (enter_editmode == false));
92
93         /* Primitive has all verts selected, use vert select flush
94          * to push this up to edges & faces. */
95         EDBM_selectmode_flush_ex(em, SCE_SELECT_VERTEX);
96
97         /* only recalc editmode tessface if we are staying in editmode */
98         EDBM_update_generic(em, !exit_editmode, true);
99
100         /* userdef */
101         if (exit_editmode) {
102                 ED_object_editmode_exit(C, EM_FREEDATA);
103         }
104         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
105 }
106
107 static int add_primitive_plane_exec(bContext *C, wmOperator *op)
108 {
109         MakePrimitiveData creation_data;
110         Object *obedit;
111         BMEditMesh *em;
112         float loc[3], rot[3];
113         bool enter_editmode;
114         ushort local_view_bits;
115         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
116
117         WM_operator_view3d_unit_defaults(C, op);
118         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
119         obedit = make_prim_init(
120                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Plane"),
121                 loc, rot, local_view_bits, &creation_data);
122         em = BKE_editmesh_from_object(obedit);
123
124         if (calc_uvs) {
125                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
126         }
127
128         if (!EDBM_op_call_and_selectf(
129                 em, op, "verts.out", false,
130                 "create_grid x_segments=%i y_segments=%i size=%f matrix=%m4 calc_uvs=%b",
131                 1, 1, RNA_float_get(op->ptr, "size") / 2.0f, creation_data.mat, calc_uvs))
132         {
133                 return OPERATOR_CANCELLED;
134         }
135
136         make_prim_finish(C, obedit, &creation_data, enter_editmode);
137
138         return OPERATOR_FINISHED;
139 }
140
141 void MESH_OT_primitive_plane_add(wmOperatorType *ot)
142 {
143         /* identifiers */
144         ot->name = "Add Plane";
145         ot->description = "Construct a filled planar mesh with 4 vertices";
146         ot->idname = "MESH_OT_primitive_plane_add";
147
148         /* api callbacks */
149         ot->exec = add_primitive_plane_exec;
150         ot->poll = ED_operator_scene_editable;
151
152         /* flags */
153         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
154
155         ED_object_add_unit_props_size(ot);
156         ED_object_add_mesh_props(ot);
157         ED_object_add_generic_props(ot, true);
158 }
159
160 static int add_primitive_cube_exec(bContext *C, wmOperator *op)
161 {
162         MakePrimitiveData creation_data;
163         Object *obedit;
164         BMEditMesh *em;
165         float loc[3], rot[3];
166         bool enter_editmode;
167         ushort local_view_bits;
168         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
169
170         WM_operator_view3d_unit_defaults(C, op);
171         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
172         obedit = make_prim_init(
173                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Cube"),
174                 loc, rot, local_view_bits, &creation_data);
175         em = BKE_editmesh_from_object(obedit);
176
177         if (calc_uvs) {
178                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
179         }
180
181         if (!EDBM_op_call_and_selectf(
182                 em, op, "verts.out", false,
183                 "create_cube matrix=%m4 size=%f calc_uvs=%b",
184                 creation_data.mat, RNA_float_get(op->ptr, "size"), calc_uvs))
185         {
186                 return OPERATOR_CANCELLED;
187         }
188
189         /* BMESH_TODO make plane side this: M_SQRT2 - plane (diameter of 1.41 makes it unit size) */
190         make_prim_finish(C, obedit, &creation_data, enter_editmode);
191
192         return OPERATOR_FINISHED;
193 }
194
195 void MESH_OT_primitive_cube_add(wmOperatorType *ot)
196 {
197         /* identifiers */
198         ot->name = "Add Cube";
199         ot->description = "Construct a cube mesh";
200         ot->idname = "MESH_OT_primitive_cube_add";
201
202         /* api callbacks */
203         ot->exec = add_primitive_cube_exec;
204         ot->poll = ED_operator_scene_editable;
205
206         /* flags */
207         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
208
209         ED_object_add_unit_props_size(ot);
210         ED_object_add_mesh_props(ot);
211         ED_object_add_generic_props(ot, true);
212 }
213
214 static const EnumPropertyItem fill_type_items[] = {
215         {0, "NOTHING", 0, "Nothing", "Don't fill at all"},
216         {1, "NGON", 0, "Ngon", "Use ngons"},
217         {2, "TRIFAN", 0, "Triangle Fan", "Use triangle fans"},
218         {0, NULL, 0, NULL, NULL}};
219
220 static int add_primitive_circle_exec(bContext *C, wmOperator *op)
221 {
222         MakePrimitiveData creation_data;
223         Object *obedit;
224         BMEditMesh *em;
225         float loc[3], rot[3];
226         bool enter_editmode;
227         ushort local_view_bits;
228         int cap_end, cap_tri;
229         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
230
231         cap_end = RNA_enum_get(op->ptr, "fill_type");
232         cap_tri = (cap_end == 2);
233
234         WM_operator_view3d_unit_defaults(C, op);
235         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
236         obedit = make_prim_init(
237                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Circle"),
238                 loc, rot, local_view_bits, &creation_data);
239         em = BKE_editmesh_from_object(obedit);
240
241         if (calc_uvs) {
242                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
243         }
244
245         if (!EDBM_op_call_and_selectf(
246                 em, op, "verts.out", false,
247                 "create_circle segments=%i radius=%f cap_ends=%b cap_tris=%b matrix=%m4 calc_uvs=%b",
248                 RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius"),
249                 cap_end, cap_tri, creation_data.mat, calc_uvs))
250         {
251                 return OPERATOR_CANCELLED;
252         }
253
254         make_prim_finish(C, obedit, &creation_data, enter_editmode);
255
256         return OPERATOR_FINISHED;
257 }
258
259 void MESH_OT_primitive_circle_add(wmOperatorType *ot)
260 {
261         /* identifiers */
262         ot->name = "Add Circle";
263         ot->description = "Construct a circle mesh";
264         ot->idname = "MESH_OT_primitive_circle_add";
265
266         /* api callbacks */
267         ot->exec = add_primitive_circle_exec;
268         ot->poll = ED_operator_scene_editable;
269
270         /* flags */
271         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
272
273         /* props */
274         RNA_def_int(ot->srna, "vertices", 32, 3, MESH_ADD_VERTS_MAXI, "Vertices", "", 3, 500);
275         ED_object_add_unit_props_radius(ot);
276         RNA_def_enum(ot->srna, "fill_type", fill_type_items, 0, "Fill Type", "");
277
278         ED_object_add_mesh_props(ot);
279         ED_object_add_generic_props(ot, true);
280 }
281
282 static int add_primitive_cylinder_exec(bContext *C, wmOperator *op)
283 {
284         MakePrimitiveData creation_data;
285         Object *obedit;
286         BMEditMesh *em;
287         float loc[3], rot[3];
288         bool enter_editmode;
289         ushort local_view_bits;
290         const int end_fill_type = RNA_enum_get(op->ptr, "end_fill_type");
291         const bool cap_end = (end_fill_type != 0);
292         const bool cap_tri = (end_fill_type == 2);
293         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
294
295         WM_operator_view3d_unit_defaults(C, op);
296         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
297         obedit = make_prim_init(
298                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Cylinder"),
299                 loc, rot, local_view_bits, &creation_data);
300         em = BKE_editmesh_from_object(obedit);
301
302         if (calc_uvs) {
303                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
304         }
305
306         if (!EDBM_op_call_and_selectf(
307                 em, op, "verts.out", false,
308                 "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f matrix=%m4 calc_uvs=%b",
309                 RNA_int_get(op->ptr, "vertices"),
310                 RNA_float_get(op->ptr, "radius"),
311                 RNA_float_get(op->ptr, "radius"),
312                 cap_end, cap_tri,
313                 RNA_float_get(op->ptr, "depth"), creation_data.mat, calc_uvs))
314         {
315                 return OPERATOR_CANCELLED;
316         }
317
318         make_prim_finish(C, obedit, &creation_data, enter_editmode);
319
320         return OPERATOR_FINISHED;
321 }
322
323 void MESH_OT_primitive_cylinder_add(wmOperatorType *ot)
324 {
325         /* identifiers */
326         ot->name = "Add Cylinder";
327         ot->description = "Construct a cylinder mesh";
328         ot->idname = "MESH_OT_primitive_cylinder_add";
329
330         /* api callbacks */
331         ot->exec = add_primitive_cylinder_exec;
332         ot->poll = ED_operator_scene_editable;
333
334         /* flags */
335         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
336
337         /* props */
338         RNA_def_int(ot->srna, "vertices", 32, 3, MESH_ADD_VERTS_MAXI, "Vertices", "", 3, 500);
339         ED_object_add_unit_props_radius(ot);
340         RNA_def_float_distance(ot->srna, "depth", 2.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Depth", "", 0.001, 100.00);
341         RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Cap Fill Type", "");
342
343         ED_object_add_mesh_props(ot);
344         ED_object_add_generic_props(ot, true);
345 }
346
347 static int add_primitive_cone_exec(bContext *C, wmOperator *op)
348 {
349         MakePrimitiveData creation_data;
350         Object *obedit;
351         BMEditMesh *em;
352         float loc[3], rot[3];
353         bool enter_editmode;
354         ushort local_view_bits;
355         const int end_fill_type = RNA_enum_get(op->ptr, "end_fill_type");
356         const bool cap_end = (end_fill_type != 0);
357         const bool cap_tri = (end_fill_type == 2);
358         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
359
360         WM_operator_view3d_unit_defaults(C, op);
361         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
362         obedit = make_prim_init(
363                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Cone"),
364                 loc, rot, local_view_bits, &creation_data);
365         em = BKE_editmesh_from_object(obedit);
366
367         if (calc_uvs) {
368                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
369         }
370
371         if (!EDBM_op_call_and_selectf(
372                 em, op, "verts.out", false,
373                 "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f matrix=%m4 calc_uvs=%b",
374                 RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius1"),
375                 RNA_float_get(op->ptr, "radius2"), cap_end, cap_tri, RNA_float_get(op->ptr, "depth"),
376                 creation_data.mat, calc_uvs))
377         {
378                 return OPERATOR_CANCELLED;
379         }
380
381         make_prim_finish(C, obedit, &creation_data, enter_editmode);
382
383         return OPERATOR_FINISHED;
384 }
385
386 void MESH_OT_primitive_cone_add(wmOperatorType *ot)
387 {
388         /* identifiers */
389         ot->name = "Add Cone";
390         ot->description = "Construct a conic mesh";
391         ot->idname = "MESH_OT_primitive_cone_add";
392
393         /* api callbacks */
394         ot->exec = add_primitive_cone_exec;
395         ot->poll = ED_operator_scene_editable;
396
397         /* flags */
398         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
399
400         /* props */
401         RNA_def_int(ot->srna, "vertices", 32, 3, MESH_ADD_VERTS_MAXI, "Vertices", "", 3, 500);
402         RNA_def_float_distance(ot->srna, "radius1", 1.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Radius 1", "", 0.001, 100.00);
403         RNA_def_float_distance(ot->srna, "radius2", 0.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Radius 2", "", 0.0, 100.00);
404         RNA_def_float_distance(ot->srna, "depth", 2.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Depth", "", 0.001, 100.00);
405         RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Base Fill Type", "");
406
407         ED_object_add_mesh_props(ot);
408         ED_object_add_generic_props(ot, true);
409 }
410
411 static int add_primitive_grid_exec(bContext *C, wmOperator *op)
412 {
413         MakePrimitiveData creation_data;
414         Object *obedit;
415         BMEditMesh *em;
416         float loc[3], rot[3];
417         bool enter_editmode;
418         ushort local_view_bits;
419         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
420
421         WM_operator_view3d_unit_defaults(C, op);
422         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
423         obedit = make_prim_init(
424                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Grid"),
425                 loc, rot, local_view_bits, &creation_data);
426         em = BKE_editmesh_from_object(obedit);
427
428         if (calc_uvs) {
429                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
430         }
431
432         if (!EDBM_op_call_and_selectf(
433                 em, op, "verts.out", false,
434                 "create_grid x_segments=%i y_segments=%i size=%f matrix=%m4 calc_uvs=%b",
435                 RNA_int_get(op->ptr, "x_subdivisions"),
436                 RNA_int_get(op->ptr, "y_subdivisions"),
437                 RNA_float_get(op->ptr, "size") / 2.0f, creation_data.mat, calc_uvs))
438         {
439                 return OPERATOR_CANCELLED;
440         }
441
442         make_prim_finish(C, obedit, &creation_data, enter_editmode);
443
444         return OPERATOR_FINISHED;
445 }
446
447 void MESH_OT_primitive_grid_add(wmOperatorType *ot)
448 {
449         /* identifiers */
450         ot->name = "Add Grid";
451         ot->description = "Construct a grid mesh";
452         ot->idname = "MESH_OT_primitive_grid_add";
453
454         /* api callbacks */
455         ot->exec = add_primitive_grid_exec;
456         ot->poll = ED_operator_scene_editable;
457
458         /* flags */
459         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
460
461         /* props */
462         /* Note that if you use MESH_ADD_VERTS_MAXI for both x and y at the same time you will still reach
463          * impossible values (10^12 vertices or so...). */
464         RNA_def_int(ot->srna, "x_subdivisions", 10, 2, MESH_ADD_VERTS_MAXI, "X Subdivisions", "", 2, 1000);
465         RNA_def_int(ot->srna, "y_subdivisions", 10, 2, MESH_ADD_VERTS_MAXI, "Y Subdivisions", "", 2, 1000);
466
467         ED_object_add_unit_props_size(ot);
468         ED_object_add_mesh_props(ot);
469         ED_object_add_generic_props(ot, true);
470 }
471
472 static int add_primitive_monkey_exec(bContext *C, wmOperator *op)
473 {
474         MakePrimitiveData creation_data;
475         Object *obedit;
476         BMEditMesh *em;
477         float loc[3], rot[3];
478         float dia;
479         bool enter_editmode;
480         ushort local_view_bits;
481         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
482
483         WM_operator_view3d_unit_defaults(C, op);
484         ED_object_add_generic_get_opts(C, op, 'Y', loc, rot, &enter_editmode, &local_view_bits, NULL);
485
486         obedit = make_prim_init(
487                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Suzanne"),
488                 loc, rot, local_view_bits, &creation_data);
489         dia = RNA_float_get(op->ptr, "size") / 2.0f;
490         mul_mat3_m4_fl(creation_data.mat, dia);
491
492         em = BKE_editmesh_from_object(obedit);
493
494         if (calc_uvs) {
495                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
496         }
497
498         if (!EDBM_op_call_and_selectf(
499                 em, op, "verts.out",  false,
500                 "create_monkey matrix=%m4 calc_uvs=%b", creation_data.mat, calc_uvs))
501         {
502                 return OPERATOR_CANCELLED;
503         }
504
505         make_prim_finish(C, obedit, &creation_data, enter_editmode);
506
507         return OPERATOR_FINISHED;
508 }
509
510 void MESH_OT_primitive_monkey_add(wmOperatorType *ot)
511 {
512         /* identifiers */
513         ot->name = "Add Monkey";
514         ot->description = "Construct a Suzanne mesh";
515         ot->idname = "MESH_OT_primitive_monkey_add";
516
517         /* api callbacks */
518         ot->exec = add_primitive_monkey_exec;
519         ot->poll = ED_operator_scene_editable;
520
521         /* flags */
522         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
523
524         /* props */
525         ED_object_add_unit_props_size(ot);
526         ED_object_add_mesh_props(ot);
527         ED_object_add_generic_props(ot, true);
528 }
529
530 static int add_primitive_uvsphere_exec(bContext *C, wmOperator *op)
531 {
532         MakePrimitiveData creation_data;
533         Object *obedit;
534         BMEditMesh *em;
535         float loc[3], rot[3];
536         bool enter_editmode;
537         ushort local_view_bits;
538         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
539
540         WM_operator_view3d_unit_defaults(C, op);
541         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
542         obedit = make_prim_init(
543                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Sphere"),
544                 loc, rot, local_view_bits, &creation_data);
545         em = BKE_editmesh_from_object(obedit);
546
547         if (calc_uvs) {
548                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
549         }
550
551         if (!EDBM_op_call_and_selectf(
552                 em, op, "verts.out", false,
553                 "create_uvsphere u_segments=%i v_segments=%i diameter=%f matrix=%m4 calc_uvs=%b",
554                 RNA_int_get(op->ptr, "segments"), RNA_int_get(op->ptr, "ring_count"),
555                 RNA_float_get(op->ptr, "radius"), creation_data.mat, calc_uvs))
556         {
557                 return OPERATOR_CANCELLED;
558         }
559
560         make_prim_finish(C, obedit, &creation_data, enter_editmode);
561
562         return OPERATOR_FINISHED;
563 }
564
565 void MESH_OT_primitive_uv_sphere_add(wmOperatorType *ot)
566 {
567         /* identifiers */
568         ot->name = "Add UV Sphere";
569         ot->description = "Construct a UV sphere mesh";
570         ot->idname = "MESH_OT_primitive_uv_sphere_add";
571
572         /* api callbacks */
573         ot->exec = add_primitive_uvsphere_exec;
574         ot->poll = ED_operator_scene_editable;
575
576         /* flags */
577         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
578
579         /* props */
580         RNA_def_int(ot->srna, "segments", 32, 3, MESH_ADD_VERTS_MAXI / 100, "Segments", "", 3, 500);
581         RNA_def_int(ot->srna, "ring_count", 16, 3, MESH_ADD_VERTS_MAXI / 100, "Rings", "", 3, 500);
582
583         ED_object_add_unit_props_radius(ot);
584         ED_object_add_mesh_props(ot);
585         ED_object_add_generic_props(ot, true);
586 }
587
588 static int add_primitive_icosphere_exec(bContext *C, wmOperator *op)
589 {
590         MakePrimitiveData creation_data;
591         Object *obedit;
592         BMEditMesh *em;
593         float loc[3], rot[3];
594         bool enter_editmode;
595         ushort local_view_bits;
596         const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
597
598         WM_operator_view3d_unit_defaults(C, op);
599         ED_object_add_generic_get_opts(C, op, 'Z', loc, rot, &enter_editmode, &local_view_bits, NULL);
600         obedit = make_prim_init(
601                 C, CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Icosphere"),
602                 loc, rot, local_view_bits, &creation_data);
603         em = BKE_editmesh_from_object(obedit);
604
605         if (calc_uvs) {
606                 ED_mesh_uv_texture_ensure(obedit->data, NULL);
607         }
608
609         if (!EDBM_op_call_and_selectf(
610                 em, op, "verts.out", false,
611                 "create_icosphere subdivisions=%i diameter=%f matrix=%m4 calc_uvs=%b",
612                 RNA_int_get(op->ptr, "subdivisions"),
613                 RNA_float_get(op->ptr, "radius"), creation_data.mat, calc_uvs))
614         {
615                 return OPERATOR_CANCELLED;
616         }
617
618         make_prim_finish(C, obedit, &creation_data, enter_editmode);
619
620         return OPERATOR_FINISHED;
621 }
622
623 void MESH_OT_primitive_ico_sphere_add(wmOperatorType *ot)
624 {
625         /* identifiers */
626         ot->name = "Add Ico Sphere";
627         ot->description = "Construct an Icosphere mesh";
628         ot->idname = "MESH_OT_primitive_ico_sphere_add";
629
630         /* api callbacks */
631         ot->exec = add_primitive_icosphere_exec;
632         ot->poll = ED_operator_scene_editable;
633
634         /* flags */
635         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
636
637         /* props */
638         RNA_def_int(ot->srna, "subdivisions", 2, 1, 10, "Subdivisions", "", 1, 8);
639
640         ED_object_add_unit_props_radius(ot);
641         ED_object_add_mesh_props(ot);
642         ED_object_add_generic_props(ot, true);
643 }