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