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