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