Blender V5.3
editmesh_add.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2004 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstdarg>
10
11#include "BLI_math_matrix_c.hh"
12#include "BLI_sys_types.hh"
13
14#include "BLT_translation.hh"
15
16#include "BKE_context.hh"
17#include "BKE_editmesh.hh"
18#include "BKE_lib_id.hh"
19#include "BKE_mesh.h"
20#include "BKE_paint.hh"
21
22#include "DNA_mesh_types.h"
23#include "DNA_object_types.h"
24#include "DNA_scene_types.h"
25
26#include "DEG_depsgraph.hh"
27
28#include "ED_mesh.hh"
29#include "ED_object.hh"
30#include "ED_screen.hh"
31#include "ED_sculpt.hh"
32
34
35#include "RNA_access.hh"
36#include "RNA_define.hh"
37
38#include "WM_api.hh"
39#include "WM_types.hh"
40
41#include "mesh_intern.hh" /* own include */
42
43namespace blender {
44
45#define MESH_ADD_VERTS_MAXI 10000000
46
47/* ********* add primitive operators ************* */
48
54
56 wmOperator *op,
57 const char *idname,
58 const float loc[3],
59 const float rot[3],
60 const float scale[3],
61 ushort local_view_bits,
62 MakePrimitiveData *r_creation_data)
63{
64 Main *bmain = CTX_data_main(C);
65 Scene *scene = CTX_data_scene(C);
66 Object *obedit;
67
68 const enum eContextObjectMode original_mode = CTX_data_mode_enum(C);
69 r_creation_data->original_mode = original_mode;
70
71 switch (original_mode) {
72 case CTX_MODE_SCULPT:
73 obedit = CTX_data_active_object(C);
74 ed::sculpt_paint::undo::geometry_begin(*scene, *obedit, op);
75 break;
77 obedit = CTX_data_edit_object(C);
78 if (obedit->type != OB_MESH) {
79 obedit = ed::object::add_type(C, OB_MESH, idname, loc, rot, false, local_view_bits);
80 ed::object::editmode_enter_ex(bmain, scene, obedit, 0);
81 }
82 break;
83 default:
84 /* Permit adding objects in a variety of modes, even those which are not typically associated
85 * with mesh-editing actions (e.g. Vertex & Texture Paint). This has been the case since 2.7x
86 * and as a result, the operators are often used in user created scripts. */
87 obedit = ed::object::add_type(C, OB_MESH, idname, loc, rot, false, local_view_bits);
88 ed::object::editmode_enter_ex(bmain, scene, obedit, 0);
89 break;
90 }
91
92 ed::object::new_primitive_matrix(C, obedit, loc, rot, scale, r_creation_data->mat);
93
94 return obedit;
95}
96
98{
99 const BMAllocTemplate allocsize{.totvert = 0, .totedge = 0, .totloop = 0, .totface = 0};
100
101 BMeshCreateParams bm_create_params{};
102 bm_create_params.use_toolflags = true;
103 BMesh *bm = BM_mesh_create(&allocsize, &bm_create_params);
104
105 return bm;
106}
107
112
113static void init_facesets(const Mesh *object_mesh, Mesh *primitive_mesh)
114{
115 bke::AttributeAccessor object_attributes = object_mesh->attributes();
116 bke::AttributeReader<int> object_face_sets = object_attributes.lookup<int>(".sculpt_face_set");
117 if (!object_face_sets) {
118 return;
119 }
120
121 bke::MutableAttributeAccessor primitive_attributes = primitive_mesh->attributes_for_write();
122 bke::SpanAttributeWriter<int> primitive_face_sets =
123 primitive_attributes.lookup_or_add_for_write_span<int>(".sculpt_face_set",
125
126 primitive_face_sets.span.fill(ed::sculpt_paint::face_set::find_next_available_id(*object_mesh));
127 primitive_face_sets.finish();
128}
129
131{
132 Mesh *object_mesh = id_cast<Mesh *>(ob->data);
133
134 BMeshToMeshParams bm_to_mesh_params{};
135 bm_to_mesh_params.calc_object_remap = false;
136 Mesh *primitive_mesh = BKE_mesh_from_bmesh_nomain(bm, &bm_to_mesh_params, object_mesh);
138
139 init_facesets(object_mesh, primitive_mesh);
140
144 {});
145
147
148 BKE_id_free(CTX_data_main(C), primitive_mesh);
149 BKE_mesh_nomain_to_mesh(result, object_mesh, ob);
150
153 WM_event_add_notifier(C, NC_GEOM | ND_DATA, object_mesh);
154}
155
157 Object *obedit,
158 const MakePrimitiveData *creation_data,
159 int enter_editmode)
160{
161 if (creation_data->original_mode == CTX_MODE_SCULPT) {
163 }
164 else {
167 /* TODO(@ideasman42): maintain UV sync for newly created data. */
169
170 /* Only recalculate edit-mode tessellation if we are staying in edit-mode. */
171 EDBMUpdate_Params params{};
172 params.calc_looptris = creation_data->original_mode == CTX_MODE_EDIT_MESH || enter_editmode;
173 params.calc_normals = false;
174 params.is_destructive = true;
175 EDBM_update(id_cast<Mesh *>(obedit->data), &params);
176
177 if (!(creation_data->original_mode == CTX_MODE_EDIT_MESH || enter_editmode)) {
180 }
181 }
182
184}
185
195 wmOperator *op,
196 Object *obedit,
197 const MakePrimitiveData *creation_data,
198 const bool calc_uvs,
199 const char *fmt,
200 ...)
201{
202 va_list list;
203 va_start(list, fmt);
204
205 bool ok;
206 if (creation_data->original_mode == CTX_MODE_SCULPT) {
209 if (ok) {
210 make_prim_finish_sculpt(C, obedit, bm);
211 }
212 else {
214 }
215 }
216 else {
218 if (calc_uvs) {
219 ED_mesh_uv_ensure(id_cast<Mesh *>(obedit->data), nullptr);
220 }
221 ok = EDBM_op_vcall_and_selectf(bm, op, "verts.out", false, fmt, list);
222 }
223
224 va_end(list);
225 return ok;
226}
227
229{
230 MakePrimitiveData creation_data;
231 Object *obedit;
232 float loc[3], rot[3];
233 bool enter_editmode;
234 ushort local_view_bits;
235 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
236
239 C, op, 'Z', loc, rot, nullptr, &enter_editmode, &local_view_bits, nullptr);
240 obedit = make_prim_init(C,
241 op,
243 loc,
244 rot,
245 nullptr,
246 local_view_bits,
247 &creation_data);
248
250 op,
251 obedit,
252 &creation_data,
253 calc_uvs,
254 "create_grid x_segments=%i y_segments=%i size=%f matrix=%m4 "
255 "calc_uvs=%b",
256 0,
257 0,
258 RNA_float_get(op->ptr, "size") / 2.0f,
259 creation_data.mat,
260 calc_uvs))
261 {
262 return OPERATOR_CANCELLED;
263 }
264
265 make_prim_finish(C, obedit, &creation_data, enter_editmode);
266
267 return OPERATOR_FINISHED;
268}
269
271{
272 /* identifiers */
273 ot->name = "Add Plane";
274 ot->description = "Construct a filled planar mesh with 4 vertices";
275 ot->idname = "MESH_OT_primitive_plane_add";
276
277 /* API callbacks. */
280
281 /* flags */
283
287}
288
290{
291 MakePrimitiveData creation_data;
292 Object *obedit;
293 float loc[3], rot[3], scale[3];
294 bool enter_editmode;
295 ushort local_view_bits;
296 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
297
300 C, op, 'Z', loc, rot, scale, &enter_editmode, &local_view_bits, nullptr);
301 obedit = make_prim_init(C,
302 op,
304 loc,
305 rot,
306 scale,
307 local_view_bits,
308 &creation_data);
309
311 op,
312 obedit,
313 &creation_data,
314 calc_uvs,
315 "create_cube matrix=%m4 size=%f calc_uvs=%b",
316 creation_data.mat,
317 RNA_float_get(op->ptr, "size"),
318 calc_uvs))
319 {
320 return OPERATOR_CANCELLED;
321 }
322
323 /* BMESH_TODO make plane side this: M_SQRT2 - plane (diameter of 1.41 makes it unit size) */
324 make_prim_finish(C, obedit, &creation_data, enter_editmode);
325
326 return OPERATOR_FINISHED;
327}
328
330{
331 /* identifiers */
332 ot->name = "Add Cube";
333 ot->description = "Construct a cube mesh that consists of six square faces";
334 ot->idname = "MESH_OT_primitive_cube_add";
335
336 /* API callbacks. */
339
340 /* flags */
342
346}
347
349 {0, "NOTHING", 0, "Nothing", "Don't fill at all"},
350 {1, "NGON", 0, "N-Gon", "Use n-gons"},
351 {2, "TRIFAN", 0, "Triangle Fan", "Use triangle fans"},
352 {0, nullptr, 0, nullptr, nullptr},
353};
354
356{
357 MakePrimitiveData creation_data;
358 Object *obedit;
359 float loc[3], rot[3];
360 bool enter_editmode;
361 ushort local_view_bits;
362 int cap_end, cap_tri;
363 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
364
365 cap_end = RNA_enum_get(op->ptr, "fill_type");
366 cap_tri = (cap_end == 2);
367
370 C, op, 'Z', loc, rot, nullptr, &enter_editmode, &local_view_bits, nullptr);
371 obedit = make_prim_init(C,
372 op,
374 loc,
375 rot,
376 nullptr,
377 local_view_bits,
378 &creation_data);
379
381 C,
382 op,
383 obedit,
384 &creation_data,
385 calc_uvs,
386 "create_circle segments=%i radius=%f cap_ends=%b cap_tris=%b matrix=%m4 calc_uvs=%b",
387 RNA_int_get(op->ptr, "vertices"),
388 RNA_float_get(op->ptr, "radius"),
389 cap_end,
390 cap_tri,
391 creation_data.mat,
392 calc_uvs))
393 {
394 return OPERATOR_CANCELLED;
395 }
396
397 make_prim_finish(C, obedit, &creation_data, enter_editmode);
398
399 return OPERATOR_FINISHED;
400}
401
403{
404 /* identifiers */
405 ot->name = "Add Circle";
406 ot->description = "Construct a circle mesh";
407 ot->idname = "MESH_OT_primitive_circle_add";
408
409 /* API callbacks. */
412
413 /* flags */
415
416 /* props */
417 RNA_def_int(ot->srna, "vertices", 32, 3, MESH_ADD_VERTS_MAXI, "Vertices", "", 3, 500);
419 RNA_def_enum(ot->srna, "fill_type", fill_type_items, 0, "Fill Type", "");
420
423}
424
426{
427 MakePrimitiveData creation_data;
428 Object *obedit;
429 float loc[3], rot[3], scale[3];
430 bool enter_editmode;
431 ushort local_view_bits;
432 const int end_fill_type = RNA_enum_get(op->ptr, "end_fill_type");
433 const bool cap_end = (end_fill_type != 0);
434 const bool cap_tri = (end_fill_type == 2);
435 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
436
439 C, op, 'Z', loc, rot, scale, &enter_editmode, &local_view_bits, nullptr);
440 obedit = make_prim_init(C,
441 op,
443 loc,
444 rot,
445 scale,
446 local_view_bits,
447 &creation_data);
448
450 op,
451 obedit,
452 &creation_data,
453 calc_uvs,
454 "create_cone segments=%i radius1=%f radius2=%f cap_ends=%b "
455 "cap_tris=%b depth=%f matrix=%m4 calc_uvs=%b",
456 RNA_int_get(op->ptr, "vertices"),
457 RNA_float_get(op->ptr, "radius"),
458 RNA_float_get(op->ptr, "radius"),
459 cap_end,
460 cap_tri,
461 RNA_float_get(op->ptr, "depth"),
462 creation_data.mat,
463 calc_uvs))
464 {
465 return OPERATOR_CANCELLED;
466 }
467
468 make_prim_finish(C, obedit, &creation_data, enter_editmode);
469
470 return OPERATOR_FINISHED;
471}
472
474{
475 /* identifiers */
476 ot->name = "Add Cylinder";
477 ot->description = "Construct a cylinder mesh";
478 ot->idname = "MESH_OT_primitive_cylinder_add";
479
480 /* API callbacks. */
483
484 /* flags */
486
487 /* props */
488 RNA_def_int(ot->srna, "vertices", 32, 3, MESH_ADD_VERTS_MAXI, "Vertices", "", 3, 500);
491 ot->srna, "depth", 2.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Depth", "", 0.001, 100.00);
492 RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Cap Fill Type", "");
493
496}
497
499{
500 MakePrimitiveData creation_data;
501 Object *obedit;
502 float loc[3], rot[3], scale[3];
503 bool enter_editmode;
504 ushort local_view_bits;
505 const int end_fill_type = RNA_enum_get(op->ptr, "end_fill_type");
506 const bool cap_end = (end_fill_type != 0);
507 const bool cap_tri = (end_fill_type == 2);
508 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
509
512 C, op, 'Z', loc, rot, scale, &enter_editmode, &local_view_bits, nullptr);
513 obedit = make_prim_init(C,
514 op,
516 loc,
517 rot,
518 scale,
519 local_view_bits,
520 &creation_data);
521
523 op,
524 obedit,
525 &creation_data,
526 calc_uvs,
527 "create_cone segments=%i radius1=%f radius2=%f cap_ends=%b "
528 "cap_tris=%b depth=%f matrix=%m4 calc_uvs=%b",
529 RNA_int_get(op->ptr, "vertices"),
530 RNA_float_get(op->ptr, "radius1"),
531 RNA_float_get(op->ptr, "radius2"),
532 cap_end,
533 cap_tri,
534 RNA_float_get(op->ptr, "depth"),
535 creation_data.mat,
536 calc_uvs))
537 {
538 return OPERATOR_CANCELLED;
539 }
540
541 make_prim_finish(C, obedit, &creation_data, enter_editmode);
542
543 return OPERATOR_FINISHED;
544}
545
547{
548 /* identifiers */
549 ot->name = "Add Cone";
550 ot->description = "Construct a conic mesh";
551 ot->idname = "MESH_OT_primitive_cone_add";
552
553 /* API callbacks. */
556
557 /* flags */
559
560 /* props */
561 RNA_def_int(ot->srna, "vertices", 32, 3, MESH_ADD_VERTS_MAXI, "Vertices", "", 3, 500);
563 ot->srna, "radius1", 1.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Radius 1", "", 0.001, 100.00);
565 ot->srna, "radius2", 0.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Radius 2", "", 0.0, 100.00);
567 ot->srna, "depth", 2.0f, 0.0, OBJECT_ADD_SIZE_MAXF, "Depth", "", 0.001, 100.00);
568 RNA_def_enum(ot->srna, "end_fill_type", fill_type_items, 1, "Base Fill Type", "");
569
572}
573
575{
576 MakePrimitiveData creation_data;
577 Object *obedit;
578 float loc[3], rot[3];
579 bool enter_editmode;
580 ushort local_view_bits;
581 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
582
585 C, op, 'Z', loc, rot, nullptr, &enter_editmode, &local_view_bits, nullptr);
586 obedit = make_prim_init(C,
587 op,
589 loc,
590 rot,
591 nullptr,
592 local_view_bits,
593 &creation_data);
594
596 op,
597 obedit,
598 &creation_data,
599 calc_uvs,
600 "create_grid x_segments=%i y_segments=%i size=%f matrix=%m4 "
601 "calc_uvs=%b",
602 RNA_int_get(op->ptr, "x_subdivisions"),
603 RNA_int_get(op->ptr, "y_subdivisions"),
604 RNA_float_get(op->ptr, "size") / 2.0f,
605 creation_data.mat,
606 calc_uvs))
607 {
608 return OPERATOR_CANCELLED;
609 }
610
611 make_prim_finish(C, obedit, &creation_data, enter_editmode);
612
613 return OPERATOR_FINISHED;
614}
615
617{
618 /* identifiers */
619 ot->name = "Add Grid";
620 ot->description = "Construct a subdivided plane mesh";
621 ot->idname = "MESH_OT_primitive_grid_add";
622
623 /* API callbacks. */
626
627 /* flags */
629
630 /* props */
631 /* Note that if you use MESH_ADD_VERTS_MAXI for both x and y at the same time
632 * you will still reach impossible values (10^12 vertices or so...). */
634 ot->srna, "x_subdivisions", 10, 1, MESH_ADD_VERTS_MAXI, "X Subdivisions", "", 1, 1000);
636 ot->srna, "y_subdivisions", 10, 1, MESH_ADD_VERTS_MAXI, "Y Subdivisions", "", 1, 1000);
637
641}
642
644{
645 MakePrimitiveData creation_data;
646 Object *obedit;
647 float loc[3], rot[3];
648 float dia;
649 bool enter_editmode;
650 ushort local_view_bits;
651 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
652
655 C, op, 'Y', loc, rot, nullptr, &enter_editmode, &local_view_bits, nullptr);
656
657 obedit = make_prim_init(C,
658 op,
660 loc,
661 rot,
662 nullptr,
663 local_view_bits,
664 &creation_data);
665 dia = RNA_float_get(op->ptr, "size") / 2.0f;
666 mul_mat3_m4_fl(creation_data.mat, dia);
667
669 op,
670 obedit,
671 &creation_data,
672 calc_uvs,
673 "create_monkey matrix=%m4 calc_uvs=%b",
674 creation_data.mat,
675 calc_uvs))
676 {
677 return OPERATOR_CANCELLED;
678 }
679
680 make_prim_finish(C, obedit, &creation_data, enter_editmode);
681
682 return OPERATOR_FINISHED;
683}
684
686{
687 /* identifiers */
688 ot->name = "Add Monkey";
689 ot->description = "Construct a Suzanne mesh";
690 ot->idname = "MESH_OT_primitive_monkey_add";
691
692 /* API callbacks. */
695
696 /* flags */
698
699 /* props */
703}
704
707 "EVEN_AREA",
708 0,
709 "Even Area",
710 "Distribute the area evenly between faces"},
712 "EVEN_ANGLE",
713 0,
714 "Even Angle",
715 "Distribute vertices at an even angle, spacing each axis as an exact circle"},
716 {0, nullptr, 0, nullptr, nullptr},
717};
718
720{
721 MakePrimitiveData creation_data;
722 Object *obedit;
723 float loc[3], rot[3], scale[3];
724 bool enter_editmode;
725 ushort local_view_bits;
726 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
727
730 C, op, 'Z', loc, rot, scale, &enter_editmode, &local_view_bits, nullptr);
731 obedit = make_prim_init(C,
732 op,
733 CTX_DATA_(BLT_I18NCONTEXT_ID_MESH, "Quadsphere"),
734 loc,
735 rot,
736 scale,
737 local_view_bits,
738 &creation_data);
739
741 op,
742 obedit,
743 &creation_data,
744 calc_uvs,
745 "create_quadsphere segments=%i method=%i "
746 "radius=%f matrix=%m4 calc_uvs=%b",
747 RNA_int_get(op->ptr, "segments"),
748 RNA_enum_get(op->ptr, "method"),
749 RNA_float_get(op->ptr, "radius"),
750 creation_data.mat,
751 calc_uvs))
752 {
753 return OPERATOR_CANCELLED;
754 }
755
756 make_prim_finish(C, obedit, &creation_data, enter_editmode);
757
758 return OPERATOR_FINISHED;
759}
760
762{
763 /* identifiers */
764 ot->name = "Add Quad Sphere";
765 ot->description =
766 "Construct a spherical mesh from a subdivided cube, consisting entirely of four-sided faces";
767 ot->idname = "MESH_OT_primitive_quad_sphere_add";
768 /* API callbacks. */
771
772 /* flags */
774
775 /* props */
776 RNA_def_int(ot->srna, "segments", 4, 1, 500, "Segments", "", 1, 200);
777 RNA_def_enum(ot->srna,
778 "method",
781 "Method",
782 "Mapping from the cube onto the sphere");
786}
787
789{
790 MakePrimitiveData creation_data;
791 Object *obedit;
792 float loc[3], rot[3], scale[3];
793 bool enter_editmode;
794 ushort local_view_bits;
795 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
796
799 C, op, 'Z', loc, rot, scale, &enter_editmode, &local_view_bits, nullptr);
800 obedit = make_prim_init(C,
801 op,
803 loc,
804 rot,
805 scale,
806 local_view_bits,
807 &creation_data);
808
810 C,
811 op,
812 obedit,
813 &creation_data,
814 calc_uvs,
815 "create_uvsphere u_segments=%i v_segments=%i radius=%f matrix=%m4 calc_uvs=%b",
816 RNA_int_get(op->ptr, "segments"),
817 RNA_int_get(op->ptr, "ring_count"),
818 RNA_float_get(op->ptr, "radius"),
819 creation_data.mat,
820 calc_uvs))
821 {
822 return OPERATOR_CANCELLED;
823 }
824
825 make_prim_finish(C, obedit, &creation_data, enter_editmode);
826
827 return OPERATOR_FINISHED;
828}
829
831{
832 /* identifiers */
833 ot->name = "Add UV Sphere";
834 ot->description =
835 "Construct a spherical mesh with quad faces, except for triangle faces at the top and "
836 "bottom";
837 ot->idname = "MESH_OT_primitive_uv_sphere_add";
838
839 /* API callbacks. */
842
843 /* flags */
845
846 /* props */
847 RNA_def_int(ot->srna, "segments", 32, 3, MESH_ADD_VERTS_MAXI / 100, "Segments", "", 3, 500);
848 RNA_def_int(ot->srna, "ring_count", 16, 3, MESH_ADD_VERTS_MAXI / 100, "Rings", "", 3, 500);
849
853}
854
856{
857 MakePrimitiveData creation_data;
858 Object *obedit;
859 float loc[3], rot[3], scale[3];
860 bool enter_editmode;
861 ushort local_view_bits;
862 const bool calc_uvs = RNA_boolean_get(op->ptr, "calc_uvs");
863
866 C, op, 'Z', loc, rot, scale, &enter_editmode, &local_view_bits, nullptr);
867 obedit = make_prim_init(C,
868 op,
870 loc,
871 rot,
872 scale,
873 local_view_bits,
874 &creation_data);
875
877 op,
878 obedit,
879 &creation_data,
880 calc_uvs,
881 "create_icosphere subdivisions=%i radius=%f matrix=%m4 calc_uvs=%b",
882 RNA_int_get(op->ptr, "subdivisions"),
883 RNA_float_get(op->ptr, "radius"),
884 creation_data.mat,
885 calc_uvs))
886 {
887 return OPERATOR_CANCELLED;
888 }
889
890 make_prim_finish(C, obedit, &creation_data, enter_editmode);
891
892 return OPERATOR_FINISHED;
893}
894
896{
897 /* identifiers */
898 ot->name = "Add Ico Sphere";
899 ot->description = "Construct a spherical mesh that consists of equally sized triangles";
900 ot->idname = "MESH_OT_primitive_ico_sphere_add";
901
902 /* API callbacks. */
905
906 /* flags */
908
909 /* props */
910 RNA_def_int(ot->srna, "subdivisions", 2, 1, 10, "Subdivisions", "", 1, 8);
911
915}
916
917} // namespace blender
#define CTX_DATA_(context, msgid)
#define BLT_I18NCONTEXT_ID_MESH
Object is a sort of wrapper for general info.
#define OBJECT_ADD_SIZE_MAXF
Definition ED_object.hh:332
#define C
Definition RandGen.cpp:29
#define NC_GEOM
Definition WM_types.hh:406
#define ND_DRAW
Definition WM_types.hh:502
#define ND_DATA
Definition WM_types.hh:552
#define NC_OBJECT
Definition WM_types.hh:392
#define BMO_FLAG_DEFAULTS
GAttributeReader lookup(const StringRef name) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
#define MESH_ADD_VERTS_MAXI
#define rot(x, k)
float3x3 scale(float3x3 mat, float2 scale)
void add_unit_props_radius(wmOperatorType *ot)
Object * add_type(bContext *C, int type, const char *name, const float loc[3], const float rot[3], bool enter_editmode, unsigned short local_view_bits) ATTR_NONNULL(1) ATTR_RETURNS_NONNULL
void add_unit_props_size(wmOperatorType *ot, float default_value=2.0f)
float new_primitive_matrix(bContext *C, Object *obedit, const float loc[3], const float rot[3], const float scale[3], float primmat[4][4])
bool editmode_enter_ex(Main *bmain, Scene *scene, Object *ob, int flag)
void add_generic_props(wmOperatorType *ot, bool do_editmode)
void add_mesh_props(wmOperatorType *ot)
void add_generic_get_opts(bContext *C, wmOperator *op, char view_align_axis, float r_loc[3], float r_rot[3], float r_scale[3], bool *r_enter_editmode, unsigned short *r_local_view_bits, bool *r_is_view_aligned)
bool editmode_exit_ex(Main *bmain, Scene *scene, Object *obedit, int flag)
int find_next_available_id(const Mesh &mesh)
void geometry_begin(const Scene &scene, Object &ob, const wmOperator *op)
bke::GeometrySet join_geometries(Span< bke::GeometrySet > geometries, const bke::AttributeFilter &attribute_filter, const std::optional< Span< bke::GeometryComponent::Type > > &component_types_to_join=std::nullopt, bool allow_merging_instance_references=true)
BMesh Iterators.
bool ED_operator_scene_editable(bContext *C)
int RNA_enum_get(PointerRNA *ptr, const char *name)
static wmOperatorStatus add_primitive_monkey_exec(bContext *C, wmOperator *op)
static const EnumPropertyItem fill_type_items[]
void BM_mesh_free(BMesh *bm)
BMesh Free Mesh.
static wmOperatorStatus add_primitive_cone_exec(bContext *C, wmOperator *op)
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
Definition editmesh.cc:79
static bool make_prim_from_bmo_args(bContext *C, wmOperator *op, Object *obedit, const MakePrimitiveData *creation_data, const bool calc_uvs, const char *fmt,...)
void MESH_OT_primitive_uv_sphere_add(wmOperatorType *ot)
void MESH_OT_primitive_cube_add(wmOperatorType *ot)
void EDBM_update(Mesh *mesh, const EDBMUpdate_Params *params)
void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, Mesh *mesh_dst, Object *ob, bool process_shape_keys=true)
unsigned short ushort
Definition BKE_text.h:56
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void mul_mat3_m4_fl(float R[4][4], float f)
Mesh * BKE_mesh_from_bmesh_nomain(BMesh *bm, const BMeshToMeshParams *params, const Mesh *me_settings)
void ED_mesh_uv_ensure(Mesh *mesh, const char *name)
Definition mesh_data.cc:256
static wmOperatorStatus add_primitive_plane_exec(bContext *C, wmOperator *op)
static wmOperatorStatus add_primitive_uvsphere_exec(bContext *C, wmOperator *op)
int RNA_int_get(PointerRNA *ptr, const char *name)
void MESH_OT_primitive_circle_add(wmOperatorType *ot)
bool EDBM_op_vcall_and_selectf(BMesh *bm, wmOperator *op, const char *select_slot_out, const bool select_extend, const char *fmt, va_list list)
enum eContextObjectMode CTX_data_mode_enum(const bContext *C)
static Object * make_prim_init(bContext *C, wmOperator *op, const char *idname, const float loc[3], const float rot[3], const float scale[3], ushort local_view_bits, MakePrimitiveData *r_creation_data)
static void make_prim_finish_sculpt(bContext *C, Object *ob, BMesh *bm)
static wmOperatorStatus add_primitive_cylinder_exec(bContext *C, wmOperator *op)
static void init_facesets(const Mesh *object_mesh, Mesh *primitive_mesh)
static BMesh * make_prim_init_sculpt()
void BKE_sculptsession_free_pbvh(Object &object)
void MESH_OT_primitive_plane_add(wmOperatorType *ot)
@ CTX_MODE_SCULPT
@ CTX_MODE_EDIT_MESH
static void make_prim_finish(bContext *C, Object *obedit, const MakePrimitiveData *creation_data, int enter_editmode)
static const EnumPropertyItem quadsphere_method_items[]
void WM_operator_view3d_unit_defaults(bContext *C, wmOperator *op)
void MESH_OT_primitive_ico_sphere_add(wmOperatorType *ot)
void DEG_id_tag_update(ID *id, unsigned int flags)
void MESH_OT_primitive_cone_add(wmOperatorType *ot)
Object * CTX_data_edit_object(const bContext *C)
void MESH_OT_primitive_quad_sphere_add(wmOperatorType *ot)
static wmOperatorStatus add_primitive_icosphere_exec(bContext *C, wmOperator *op)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void BKE_id_free(Main *bmain, void *idv)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
void EDBM_selectmode_flush_ex(BMesh *bm, short selectmode)
Main * CTX_data_main(const bContext *C)
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
PropertyRNA * RNA_def_float_distance(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
static wmOperatorStatus add_primitive_grid_exec(bContext *C, wmOperator *op)
bool EDBM_uvselect_clear(BMesh *bm)
static void make_prim_finish_sculpt_cancelled(BMesh *bm)
Scene * CTX_data_scene(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
bool BMO_op_vcallf(BMesh *bm, int flag, const char *fmt, va_list list)
@ QUADSPHERE_METHOD_EQUI_ANGULAR
@ QUADSPHERE_METHOD_EQUI_ANGULAR_EVEN_AREA
BMesh * BM_mesh_create(const BMAllocTemplate *allocsize, const BMeshCreateParams *params)
BMesh Make Mesh.
Object * CTX_data_active_object(const bContext *C)
void MESH_OT_primitive_cylinder_add(wmOperatorType *ot)
float RNA_float_get(PointerRNA *ptr, const char *name)
void MESH_OT_primitive_grid_add(wmOperatorType *ot)
static wmOperatorStatus add_primitive_cube_exec(bContext *C, wmOperator *op)
static wmOperatorStatus add_primitive_quadsphere_exec(bContext *C, wmOperator *op)
void MESH_OT_primitive_monkey_add(wmOperatorType *ot)
static wmOperatorStatus add_primitive_circle_exec(bContext *C, wmOperator *op)
eContextObjectMode original_mode
GeometryComponent & get_component_for_write(GeometryComponent::Type component_type)
static GeometrySet from_mesh(Mesh *mesh, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165