bmesh operator naming - use clearer names for args eg: (mat -> matrix, use_singleedge...
[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_mesh_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_scene_types.h"
35
36 #include "RNA_define.h"
37 #include "RNA_access.h"
38
39 #include "BLI_math.h"
40
41 #include "BKE_context.h"
42 #include "BKE_depsgraph.h"
43 #include "BKE_library.h"
44 #include "BKE_tessmesh.h"
45
46
47 #include "WM_api.h"
48 #include "WM_types.h"
49
50 #include "ED_mesh.h"
51 #include "ED_screen.h"
52 #include "ED_object.h"
53
54 #include "mesh_intern.h"
55
56 /* ********* add primitive operators ************* */
57
58 static Object *make_prim_init(bContext *C, const char *idname,
59                               float *dia, float mat[][4],
60                               int *state, const float loc[3], const float rot[3], const unsigned int layer)
61 {
62         Object *obedit = CTX_data_edit_object(C);
63
64         *state = 0;
65         if (obedit == NULL || obedit->type != OB_MESH) {
66                 obedit = ED_object_add_type(C, OB_MESH, loc, rot, FALSE, layer);
67
68                 rename_id((ID *)obedit, idname);
69                 rename_id((ID *)obedit->data, idname);
70
71                 /* create editmode */
72                 ED_object_enter_editmode(C, EM_DO_UNDO | EM_IGNORE_LAYER); /* rare cases the active layer is messed up */
73                 *state = 1;
74         }
75
76         *dia = ED_object_new_primitive_matrix(C, obedit, loc, rot, mat, FALSE);
77
78         return obedit;
79 }
80
81 static void make_prim_finish(bContext *C, Object *obedit, int *state, int enter_editmode)
82 {
83         BMEditMesh *em = BMEdit_FromObject(obedit);
84
85         /* Primitive has all verts selected, use vert select flush
86          * to push this up to edges & faces. */
87         EDBM_selectmode_flush_ex(em, SCE_SELECT_VERTEX);
88
89         EDBM_update_generic(C, em, TRUE);
90
91         /* userdef */
92         if (*state && !enter_editmode) {
93                 ED_object_exit_editmode(C, EM_FREEDATA); /* adding EM_DO_UNDO messes up operator redo */
94         }
95         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, obedit);
96 }
97
98 static int add_primitive_plane_exec(bContext *C, wmOperator *op)
99 {
100         Object *obedit;
101         BMEditMesh *em;
102         float loc[3], rot[3], mat[4][4], dia;
103         int enter_editmode;
104         int state;
105         unsigned int layer;
106
107         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
108         obedit = make_prim_init(C, "Plane", &dia, mat, &state, loc, rot, layer);
109         em = BMEdit_FromObject(obedit);
110
111         if (!EDBM_op_call_and_selectf(em, op, "verts.out",
112                                       "create_grid x_segments=%i y_segments=%i size=%f matrix=%m4", 1, 1, dia, mat))
113         {
114                 return OPERATOR_CANCELLED;
115         }
116
117         make_prim_finish(C, obedit, &state, enter_editmode);
118
119         return OPERATOR_FINISHED;
120 }
121
122 void MESH_OT_primitive_plane_add(wmOperatorType *ot)
123 {
124         /* identifiers */
125         ot->name = "Add Plane";
126         ot->description = "Construct a filled planar mesh with 4 vertices";
127         ot->idname = "MESH_OT_primitive_plane_add";
128
129         /* api callbacks */
130         ot->exec = add_primitive_plane_exec;
131         ot->poll = ED_operator_scene_editable;
132
133         /* flags */
134         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
135
136         ED_object_add_generic_props(ot, TRUE);
137 }
138
139 static int add_primitive_cube_exec(bContext *C, wmOperator *op)
140 {
141         Object *obedit;
142         BMEditMesh *em;
143         float loc[3], rot[3], mat[4][4], dia;
144         int enter_editmode;
145         int state;
146         unsigned int layer;
147
148         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
149         obedit = make_prim_init(C, "Cube", &dia, mat, &state, loc, rot, layer);
150         em = BMEdit_FromObject(obedit);
151
152         if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_cube matrix=%m4 size=%f", mat, dia * 2.0f)) {
153                 return OPERATOR_CANCELLED;
154         }
155
156         /* BMESH_TODO make plane side this: M_SQRT2 - plane (diameter of 1.41 makes it unit size) */
157         make_prim_finish(C, obedit, &state, enter_editmode);
158
159         return OPERATOR_FINISHED;
160 }
161
162 void MESH_OT_primitive_cube_add(wmOperatorType *ot)
163 {
164         /* identifiers */
165         ot->name = "Add Cube";
166         ot->description = "Construct a cube mesh";
167         ot->idname = "MESH_OT_primitive_cube_add";
168
169         /* api callbacks */
170         ot->exec = add_primitive_cube_exec;
171         ot->poll = ED_operator_scene_editable;
172
173         /* flags */
174         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
175
176         ED_object_add_generic_props(ot, TRUE);
177 }
178
179 static const EnumPropertyItem fill_type_items[] = {
180         {0, "NOTHING", 0, "Nothing", "Don't fill at all"},
181         {1, "NGON", 0, "Ngon", "Use ngons"},
182         {2, "TRIFAN", 0, "Triangle Fan", "Use triangle fans"},
183         {0, NULL, 0, NULL, NULL}};
184
185 static int add_primitive_circle_exec(bContext *C, wmOperator *op)
186 {
187         Object *obedit;
188         BMEditMesh *em;
189         float loc[3], rot[3], mat[4][4], dia;
190         int enter_editmode;
191         int state, cap_end, cap_tri;
192         unsigned int layer;
193
194         cap_end = RNA_enum_get(op->ptr, "fill_type");
195         cap_tri = (cap_end == 2);
196
197         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
198         obedit = make_prim_init(C, "Circle", &dia, mat, &state, loc, rot, layer);
199         em = BMEdit_FromObject(obedit);
200
201         if (!EDBM_op_call_and_selectf(em, op, "verts.out",
202                                       "create_circle segments=%i diameter=%f cap_ends=%b cap_tris=%b matrix=%m4",
203                                       RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius") * dia,
204                                       cap_end, cap_tri, mat))
205         {
206                 return OPERATOR_CANCELLED;
207         }
208
209         make_prim_finish(C, obedit, &state, enter_editmode);
210
211         return OPERATOR_FINISHED;
212 }
213
214 void MESH_OT_primitive_circle_add(wmOperatorType *ot)
215 {
216         PropertyRNA *prop;
217
218         /* identifiers */
219         ot->name = "Add Circle";
220         ot->description = "Construct a circle mesh";
221         ot->idname = "MESH_OT_primitive_circle_add";
222
223         /* api callbacks */
224         ot->exec = add_primitive_circle_exec;
225         ot->poll = ED_operator_scene_editable;
226
227         /* flags */
228         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
229
230         /* props */
231         RNA_def_int(ot->srna, "vertices", 32, 3, INT_MAX, "Vertices", "", 3, 500);
232         prop = RNA_def_float(ot->srna, "radius", 1.0f, 0.0, FLT_MAX, "Radius", "", 0.001, 100.00);
233         RNA_def_property_subtype(prop, PROP_DISTANCE);
234         RNA_def_enum(ot->srna, "fill_type", fill_type_items, 0, "Fill Type", "");
235
236         ED_object_add_generic_props(ot, TRUE);
237 }
238
239 static int add_primitive_cylinder_exec(bContext *C, wmOperator *op)
240 {
241         Object *obedit;
242         BMEditMesh *em;
243         float loc[3], rot[3], mat[4][4], dia;
244         int enter_editmode;
245         int state, cap_end, cap_tri;
246         unsigned int layer;
247
248         cap_end = RNA_enum_get(op->ptr, "end_fill_type");
249         cap_tri = (cap_end == 2);
250
251         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
252         obedit = make_prim_init(C, "Cylinder", &dia, mat, &state, loc, rot, layer);
253         em = BMEdit_FromObject(obedit);
254
255         if (!EDBM_op_call_and_selectf(
256                 em, op, "verts.out",
257                 "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f matrix=%m4",
258                 RNA_int_get(op->ptr, "vertices"),
259                 RNA_float_get(op->ptr, "radius") * dia,
260                 RNA_float_get(op->ptr, "radius") * dia,
261                 cap_end, cap_tri,
262                 RNA_float_get(op->ptr, "depth") * dia, mat))
263         {
264                 return OPERATOR_CANCELLED;
265         }
266
267         make_prim_finish(C, obedit, &state, enter_editmode);
268
269         return OPERATOR_FINISHED;
270 }
271
272 void MESH_OT_primitive_cylinder_add(wmOperatorType *ot)
273 {
274         PropertyRNA *prop;
275
276         /* identifiers */
277         ot->name = "Add Cylinder";
278         ot->description = "Construct a cylinder mesh";
279         ot->idname = "MESH_OT_primitive_cylinder_add";
280
281         /* api callbacks */
282         ot->exec = add_primitive_cylinder_exec;
283         ot->poll = ED_operator_scene_editable;
284
285         /* flags */
286         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
287
288         /* props */
289         RNA_def_int(ot->srna, "vertices", 32, 3, INT_MAX, "Vertices", "", 3, 500);
290         prop = RNA_def_float(ot->srna, "radius", 1.0f, 0.0, FLT_MAX, "Radius", "", 0.001, 100.00);
291         RNA_def_property_subtype(prop, PROP_DISTANCE);
292         prop = RNA_def_float(ot->srna, "depth", 2.0f, 0.0, FLT_MAX, "Depth", "", 0.001, 100.00);
293         RNA_def_property_subtype(prop, PROP_DISTANCE);
294         RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Cap Fill Type", "");
295
296         ED_object_add_generic_props(ot, TRUE);
297 }
298
299 static int add_primitive_cone_exec(bContext *C, wmOperator *op)
300 {
301         Object *obedit;
302         BMEditMesh *em;
303         float loc[3], rot[3], mat[4][4], dia;
304         int enter_editmode;
305         int state, cap_end, cap_tri;
306         unsigned int layer;
307
308         cap_end = RNA_enum_get(op->ptr, "end_fill_type");
309         cap_tri = (cap_end == 2);
310
311         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
312         obedit = make_prim_init(C, "Cone", &dia, mat, &state, loc, rot, layer);
313         em = BMEdit_FromObject(obedit);
314
315         if (!EDBM_op_call_and_selectf(
316                 em, op, "verts.out",
317                 "create_cone segments=%i diameter1=%f diameter2=%f cap_ends=%b cap_tris=%b depth=%f matrix=%m4",
318                 RNA_int_get(op->ptr, "vertices"), RNA_float_get(op->ptr, "radius1") * dia,
319                 RNA_float_get(op->ptr, "radius2") * dia, cap_end, cap_tri, RNA_float_get(op->ptr, "depth") * dia, mat))
320         {
321                 return OPERATOR_CANCELLED;
322         }
323
324         make_prim_finish(C, obedit, &state, enter_editmode);
325
326         return OPERATOR_FINISHED;
327 }
328
329 void MESH_OT_primitive_cone_add(wmOperatorType *ot)
330 {
331         PropertyRNA *prop;
332
333         /* identifiers */
334         ot->name = "Add Cone";
335         ot->description = "Construct a conic mesh";
336         ot->idname = "MESH_OT_primitive_cone_add";
337
338         /* api callbacks */
339         ot->exec = add_primitive_cone_exec;
340         ot->poll = ED_operator_scene_editable;
341
342         /* flags */
343         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
344
345         /* props */
346         RNA_def_int(ot->srna, "vertices", 32, 3, INT_MAX, "Vertices", "", 3, 500);
347         prop = RNA_def_float(ot->srna, "radius1", 1.0f, 0.0, FLT_MAX, "Radius 1", "", 0.001, 100.00);
348         RNA_def_property_subtype(prop, PROP_DISTANCE);
349         prop = RNA_def_float(ot->srna, "radius2", 0.0f, 0.0, FLT_MAX, "Radius 2", "", 0.001, 100.00);
350         RNA_def_property_subtype(prop, PROP_DISTANCE);
351         prop = RNA_def_float(ot->srna, "depth", 2.0f, 0.0, FLT_MAX, "Depth", "", 0.001, 100.00);
352         RNA_def_property_subtype(prop, PROP_DISTANCE);
353         RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Base Fill Type", "");
354
355         ED_object_add_generic_props(ot, TRUE);
356 }
357
358 static int add_primitive_grid_exec(bContext *C, wmOperator *op)
359 {
360         Object *obedit;
361         BMEditMesh *em;
362         float loc[3], rot[3], mat[4][4], dia;
363         int enter_editmode;
364         int state;
365         unsigned int layer;
366
367         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
368         obedit = make_prim_init(C, "Grid", &dia, mat, &state, loc, rot, layer);
369         em = BMEdit_FromObject(obedit);
370
371         if (!EDBM_op_call_and_selectf(em, op, "verts.out",
372                                       "create_grid x_segments=%i y_segments=%i size=%f matrix=%m4",
373                                       RNA_int_get(op->ptr, "x_subdivisions"),
374                                       RNA_int_get(op->ptr, "y_subdivisions"),
375                                       RNA_float_get(op->ptr, "size") * dia, mat))
376         {
377                 return OPERATOR_CANCELLED;
378         }
379
380         make_prim_finish(C, obedit, &state, enter_editmode);
381
382         return OPERATOR_FINISHED;
383 }
384
385 void MESH_OT_primitive_grid_add(wmOperatorType *ot)
386 {
387         PropertyRNA *prop;
388
389         /* identifiers */
390         ot->name = "Add Grid";
391         ot->description = "Construct a grid mesh";
392         ot->idname = "MESH_OT_primitive_grid_add";
393
394         /* api callbacks */
395         ot->exec = add_primitive_grid_exec;
396         ot->poll = ED_operator_scene_editable;
397
398         /* flags */
399         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
400
401         /* props */
402         RNA_def_int(ot->srna, "x_subdivisions", 10, 3, INT_MAX, "X Subdivisions", "", 3, 1000);
403         RNA_def_int(ot->srna, "y_subdivisions", 10, 3, INT_MAX, "Y Subdivisions", "", 3, 1000);
404         prop = RNA_def_float(ot->srna, "size", 1.0f, 0.0, FLT_MAX, "Size", "", 0.001, FLT_MAX);
405         RNA_def_property_subtype(prop, PROP_DISTANCE);
406
407         ED_object_add_generic_props(ot, TRUE);
408 }
409
410 static int add_primitive_monkey_exec(bContext *C, wmOperator *op)
411 {
412         Object *obedit;
413         BMEditMesh *em;
414         float loc[3], rot[3], mat[4][4], dia;
415         int enter_editmode;
416         int state, view_aligned;
417         unsigned int layer;
418
419         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, &view_aligned);
420         if (!view_aligned)
421                 rot[0] += (float)M_PI / 2.0f;
422
423         obedit = make_prim_init(C, "Suzanne", &dia, mat, &state, loc, rot, layer);
424         mat[0][0] *= dia;
425         mat[1][1] *= dia;
426         mat[2][2] *= dia;
427
428         em = BMEdit_FromObject(obedit);
429
430         if (!EDBM_op_call_and_selectf(em, op, "verts.out", "create_monkey matrix=%m4", mat)) {
431                 return OPERATOR_CANCELLED;
432         }
433
434         make_prim_finish(C, obedit, &state, enter_editmode);
435
436         return OPERATOR_FINISHED;
437 }
438
439 void MESH_OT_primitive_monkey_add(wmOperatorType *ot)
440 {
441         /* identifiers */
442         ot->name = "Add Monkey";
443         ot->description = "Construct a Suzanne mesh";
444         ot->idname = "MESH_OT_primitive_monkey_add";
445
446         /* api callbacks */
447         ot->exec = add_primitive_monkey_exec;
448         ot->poll = ED_operator_scene_editable;
449
450         /* flags */
451         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
452
453         ED_object_add_generic_props(ot, TRUE);
454 }
455
456 static int add_primitive_uvsphere_exec(bContext *C, wmOperator *op)
457 {
458         Object *obedit;
459         BMEditMesh *em;
460         float loc[3], rot[3], mat[4][4], dia;
461         int enter_editmode;
462         int state;
463         unsigned int layer;
464
465         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
466         obedit = make_prim_init(C, "Sphere", &dia, mat, &state, loc, rot, layer);
467         em = BMEdit_FromObject(obedit);
468
469         if (!EDBM_op_call_and_selectf(em, op, "verts.out",
470                                       "create_uvsphere u_segments=%i v_segments=%i diameter=%f matrix=%m4",
471                                       RNA_int_get(op->ptr, "segments"), RNA_int_get(op->ptr, "ring_count"),
472                                       RNA_float_get(op->ptr, "size") * dia, mat))
473         {
474                 return OPERATOR_CANCELLED;
475         }
476
477         make_prim_finish(C, obedit, &state, enter_editmode);
478
479         return OPERATOR_FINISHED;
480 }
481
482 void MESH_OT_primitive_uv_sphere_add(wmOperatorType *ot)
483 {
484         PropertyRNA *prop;
485
486         /* identifiers */
487         ot->name = "Add UV Sphere";
488         ot->description = "Construct a UV sphere mesh";
489         ot->idname = "MESH_OT_primitive_uv_sphere_add";
490
491         /* api callbacks */
492         ot->exec = add_primitive_uvsphere_exec;
493         ot->poll = ED_operator_scene_editable;
494
495         /* flags */
496         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
497
498         /* props */
499         RNA_def_int(ot->srna, "segments", 32, 3, INT_MAX, "Segments", "", 3, 500);
500         RNA_def_int(ot->srna, "ring_count", 16, 3, INT_MAX, "Rings", "", 3, 500);
501         prop = RNA_def_float(ot->srna, "size", 1.0f, 0.0, FLT_MAX, "Size", "", 0.001, 100.00);
502         RNA_def_property_subtype(prop, PROP_DISTANCE);
503
504         ED_object_add_generic_props(ot, TRUE);
505 }
506
507 static int add_primitive_icosphere_exec(bContext *C, wmOperator *op)
508 {
509         Object *obedit;
510         BMEditMesh *em;
511         float loc[3], rot[3], mat[4][4], dia;
512         int enter_editmode;
513         int state;
514         unsigned int layer;
515
516         ED_object_add_generic_get_opts(C, op, loc, rot, &enter_editmode, &layer, NULL);
517         obedit = make_prim_init(C, "Icosphere", &dia, mat, &state, loc, rot, layer);
518         em = BMEdit_FromObject(obedit);
519
520         if (!EDBM_op_call_and_selectf(
521                 em, op, "verts.out",
522                 "create_icosphere subdivisions=%i diameter=%f matrix=%m4",
523                 RNA_int_get(op->ptr, "subdivisions"),
524                 RNA_float_get(op->ptr, "size") * dia, mat))
525         {
526                 return OPERATOR_CANCELLED;
527         }
528
529         make_prim_finish(C, obedit, &state, enter_editmode);
530
531         return OPERATOR_FINISHED;
532 }
533
534 void MESH_OT_primitive_ico_sphere_add(wmOperatorType *ot)
535 {
536         PropertyRNA *prop;
537
538         /* identifiers */
539         ot->name = "Add Ico Sphere";
540         ot->description = "Construct an Icosphere mesh";
541         ot->idname = "MESH_OT_primitive_ico_sphere_add";
542
543         /* api callbacks */
544         ot->exec = add_primitive_icosphere_exec;
545         ot->poll = ED_operator_scene_editable;
546
547         /* flags */
548         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
549
550         /* props */
551         RNA_def_int(ot->srna, "subdivisions", 2, 1, INT_MAX, "Subdivisions", "", 1, 8);
552         prop = RNA_def_float(ot->srna, "size", 1.0f, 0.0f, FLT_MAX, "Size", "", 0.001f, 100.00);
553         RNA_def_property_subtype(prop, PROP_DISTANCE);
554
555         ED_object_add_generic_props(ot, TRUE);
556 }