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