33 {
BMO_DELIM_UV,
"UV", 0,
"UVs",
"Delimit by UV coordinates"},
34 {0,
nullptr, 0,
nullptr,
nullptr},
43 "Delimit edge loop selection at sharp edges"},
49 "Stop boundary selection at vertices with more than three edges"},
54 "Stop boundary selection at vertices with two edges when they share a face that is not an "
56 {0,
nullptr, 0,
nullptr,
nullptr},
65 "Delimit edge ring selection at sharp edges"},
70 "Delimit edge ring selection at material boundaries"},
75 "Allow edge ring selection to step over n-gons with an even number of sides"},
76 {0,
nullptr, 0,
nullptr,
nullptr},
85 "Delimit face loop selection at sharp edges"},
90 "Delimit face loop selection at material boundaries"},
91 {0,
nullptr, 0,
nullptr,
nullptr},
95 {
REMESH_VOXEL,
"VOXEL", 0,
"Voxel",
"Use the voxel remesher"},
96 {
REMESH_QUAD,
"QUAD", 0,
"Quad",
"Use the quad remesher"},
97 {0,
nullptr, 0,
nullptr,
nullptr},
104# include <fmt/format.h>
139 Mesh *
mesh = id_cast<Mesh *>(ptr->owner_id);
149static bool rna_Mesh_has_custom_normals_get(
PointerRNA *ptr)
172static void rna_Mesh_update_data_legacy_deg_tag_all(
Main * ,
176 ID *
id = ptr->owner_id;
187 ID *
id = ptr->owner_id;
200 rna_Mesh_update_data_legacy_deg_tag_all(bmain, scene, ptr);
203static void rna_Mesh_update_data_edit_active_color(
Main *bmain,
Scene *scene,
PointerRNA *ptr)
207 rna_Mesh_update_data_legacy_deg_tag_all(bmain, scene, ptr);
211 ID *
id = ptr->owner_id;
221 ID *
id = ptr->owner_id;
266 rna_Mesh_update_data_legacy_deg_tag_all(bmain, scene, ptr);
275static int rna_MeshVertex_index_get(
PointerRNA *ptr)
285static int rna_MeshEdge_index_get(
PointerRNA *ptr)
288 const int2 *edge =
static_cast<const int2 *
>(ptr->data);
289 const int2 *edges =
mesh->edges().data();
290 const int index = int(edge - edges);
296static int rna_MeshPolygon_index_get(
PointerRNA *ptr)
299 const int *face_offset =
static_cast<const int *
>(ptr->data);
300 const int index = int(face_offset -
mesh->face_offsets().data());
306static int rna_MeshLoop_index_get(
PointerRNA *ptr)
309 const int *corner_vert =
static_cast<const int *
>(ptr->data);
310 const int index = int(corner_vert -
mesh->corner_verts().data());
316static int rna_MeshLoopTriangle_index_get(
PointerRNA *ptr)
319 const int3 *tri =
static_cast<const int3 *
>(ptr->data);
320 const int index = int(tri -
mesh->corner_tris().data());
326static int rna_MeshLoopTriangle_polygon_index_get(
PointerRNA *ptr)
329 const int index = rna_MeshLoopTriangle_index_get(ptr);
339 const_cast<int3 *
>(corner_tris.
data()),
346static int rna_Mesh_loop_triangles_length(
PointerRNA *ptr)
360 *ptr, RNA_MeshLoopTriangle,
const_cast<int3 *
>(&
mesh->corner_tris()[
index]), *r_ptr);
370 const_cast<int *
>(
mesh->corner_tri_faces().data()),
385 *ptr, RNA_ReadOnlyInteger,
const_cast<int *
>(&
mesh->corner_tri_faces()[
index]), *r_ptr);
389static void rna_MeshVertex_co_get(
PointerRNA *ptr,
float *value)
391 copy_v3_v3(value,
static_cast<const float *
>(ptr->data));
394static void rna_MeshVertex_co_set(
PointerRNA *ptr,
const float *value)
396 copy_v3_v3(
static_cast<float *
>(ptr->data), value);
398 mesh->tag_positions_changed();
401static void rna_MeshVertex_normal_get(
PointerRNA *ptr,
float *value)
405 const int index = rna_MeshVertex_index_get(ptr);
409static bool rna_MeshVertex_hide_get(
PointerRNA *ptr)
413 const VArray hide_vert = *attributes.lookup_or_default<
bool>(
415 const int index = rna_MeshVertex_index_get(ptr);
416 return hide_vert[
index];
419static void rna_MeshVertex_hide_set(
PointerRNA *ptr,
bool value)
425 const int index = rna_MeshVertex_index_get(ptr);
426 hide_vert.varray.set(
index, value);
430static bool rna_MeshVertex_select_get(
PointerRNA *ptr)
433 const int index = rna_MeshVertex_index_get(ptr);
435 const VArray select_vert = *attributes.lookup_or_default<
bool>(
437 return select_vert[
index];
440static void rna_MeshVertex_select_set(
PointerRNA *ptr,
bool value)
443 const int index = rna_MeshVertex_index_get(ptr);
448 select_vert.finish();
451static int rna_MeshLoop_vertex_index_get(
PointerRNA *ptr)
453 return *
static_cast<int *
>(ptr->data);
456static void rna_MeshLoop_vertex_index_set(
PointerRNA *ptr,
int value)
458 *
static_cast<int *
>(ptr->data) = value;
461static int rna_MeshLoop_edge_index_get(
PointerRNA *ptr)
464 const int index = rna_MeshLoop_index_get(ptr);
468static void rna_MeshLoop_edge_index_set(
PointerRNA *ptr,
int value)
471 const int index = rna_MeshLoop_index_get(ptr);
472 mesh->corner_edges_for_write()[
index] = value;
475static void rna_MeshLoop_normal_get(
PointerRNA *ptr,
float *values)
478 const int index = rna_MeshLoop_index_get(ptr);
482static void rna_MeshLoop_tangent_get(
PointerRNA *ptr,
float *values)
485 const int index = rna_MeshLoop_index_get(ptr);
497static float rna_MeshLoop_bitangent_sign_get(
PointerRNA *ptr)
500 const int index = rna_MeshLoop_index_get(ptr);
504 return (vec) ? vec[
index][3] : 0.0f;
507static void rna_MeshLoop_bitangent_get(
PointerRNA *ptr,
float *values)
510 const int index = rna_MeshLoop_index_get(ptr);
523static void rna_MeshPolygon_normal_get(
PointerRNA *ptr,
float *values)
526 const int poly_start = *(
static_cast<const int *
>(ptr->data));
527 const int poly_size = *((
static_cast<const int *
>(ptr->data)) + 1) - poly_start;
528 const Span<int> face_verts =
mesh->corner_verts().slice(poly_start, poly_size);
533static bool rna_MeshPolygon_hide_get(
PointerRNA *ptr)
536 const int index = rna_MeshPolygon_index_get(ptr);
538 const VArray hide_poly = *attributes.lookup_or_default<
bool>(
540 return hide_poly[
index];
543static void rna_MeshPolygon_hide_set(
PointerRNA *ptr,
bool value)
546 const int index = rna_MeshPolygon_index_get(ptr);
554static bool rna_MeshPolygon_use_smooth_get(
PointerRNA *ptr)
557 const int index = rna_MeshPolygon_index_get(ptr);
559 const VArray sharp_face = *attributes.lookup_or_default<
bool>(
561 return !sharp_face[
index];
564static void rna_MeshPolygon_use_smooth_set(
PointerRNA *ptr,
bool value)
567 const int index = rna_MeshPolygon_index_get(ptr);
575static bool rna_MeshPolygon_select_get(
PointerRNA *ptr)
578 const int index = rna_MeshPolygon_index_get(ptr);
580 const VArray select_poly = *attributes.lookup_or_default<
bool>(
582 return select_poly[
index];
585static void rna_MeshPolygon_select_set(
PointerRNA *ptr,
bool value)
588 const int index = rna_MeshPolygon_index_get(ptr);
593 select_poly.finish();
596static int rna_MeshPolygon_material_index_get(
PointerRNA *ptr)
600 const VArray material_index = *attributes.lookup_or_default<
int>(
602 return material_index[rna_MeshPolygon_index_get(ptr)];
605static void rna_MeshPolygon_material_index_set(
PointerRNA *ptr,
int value)
611 material_index.
varray.set(rna_MeshPolygon_index_get(ptr),
max_ii(0, value));
612 material_index.finish();
615static void rna_MeshPolygon_center_get(
PointerRNA *ptr,
float *values)
618 const int poly_start = *(
static_cast<const int *
>(ptr->data));
619 const int poly_size = *((
static_cast<const int *
>(ptr->data)) + 1) - poly_start;
620 const Span<int> face_verts =
mesh->corner_verts().slice(poly_start, poly_size);
625static float rna_MeshPolygon_area_get(
PointerRNA *ptr)
627 Mesh *
mesh = id_cast<Mesh *>(ptr->owner_id);
628 const int poly_start = *(
static_cast<const int *
>(ptr->data));
629 const int poly_size = *((
static_cast<const int *
>(ptr->data)) + 1) - poly_start;
630 const Span<int> face_verts =
mesh->corner_verts().slice(poly_start, poly_size);
634static void rna_MeshPolygon_flip(
ID *
id,
MIntProperty *poly_offset_p)
637 const int index =
reinterpret_cast<int *
>(poly_offset_p) -
mesh->faces().data().data();
643static void rna_MeshLoopTriangle_verts_get(
PointerRNA *ptr,
int *values)
647 int3 tri = *
static_cast<int3 *
>(ptr->data);
648 values[0] = corner_verts[tri[0]];
649 values[1] = corner_verts[tri[1]];
650 values[2] = corner_verts[tri[2]];
653static void rna_MeshLoopTriangle_normal_get(
PointerRNA *ptr,
float *values)
656 int3 tri = *
static_cast<int3 *
>(ptr->data);
659 const int v1 = corner_verts[tri[0]];
660 const int v2 = corner_verts[tri[1]];
661 const int v3 = corner_verts[tri[2]];
666static void rna_MeshLoopTriangle_split_normals_get(
PointerRNA *ptr,
float *values)
670 const int3 tri = *
static_cast<const int3 *
>(ptr->data);
671 copy_v3_v3(values + 0, corner_normals[tri[0]]);
672 copy_v3_v3(values + 3, corner_normals[tri[1]]);
673 copy_v3_v3(values + 6, corner_normals[tri[2]]);
676static float rna_MeshLoopTriangle_area_get(
PointerRNA *ptr)
679 int3 tri = *
static_cast<int3 *
>(ptr->data);
682 const int v1 = corner_verts[tri[0]];
683 const int v2 = corner_verts[tri[1]];
684 const int v3 = corner_verts[tri[2]];
685 return area_tri_v3(positions[v1], positions[
v2], positions[v3]);
688static void rna_MeshLoopColor_color_get(
PointerRNA *ptr,
float *values)
692 values[0] = mlcol->
r / 255.0f;
693 values[1] = mlcol->g / 255.0f;
694 values[2] = mlcol->b / 255.0f;
695 values[3] = mlcol->a / 255.0f;
698static void rna_MeshLoopColor_color_set(
PointerRNA *ptr,
const float *values)
708static int rna_Mesh_texspace_editable(
const PointerRNA *ptr,
const char ** )
714static void rna_Mesh_texspace_size_get(
PointerRNA *ptr,
float values[3])
723static void rna_Mesh_texspace_location_get(
PointerRNA *ptr,
float values[3])
737 const int index = rna_MeshVertex_index_get(ptr);
741 iter, ptr, dvert->dw,
sizeof(
MDeformWeight), dvert->totweight, 0,
nullptr);
748static void rna_MeshVertex_undeformed_co_get(
PointerRNA *ptr,
float values[3])
751 const float *
position =
static_cast<const float *
>(ptr->data);
756 const int index = rna_MeshVertex_index_get(ptr);
758 float texspace_location[3], texspace_size[3];
761 mesh->texcomesh ?
mesh->texcomesh :
mesh, texspace_location, texspace_size);
783static int rna_Mesh_uv_layers_length(
PointerRNA *ptr)
789static void rna_Mesh_uv_layer_index_range(
PointerRNA *ptr,
int *
min,
int *
max,
int *,
int *)
802 attr_ptr.type = RNA_MeshUVLoopLayer;
813static int rna_Mesh_uv_layer_active_index_get(
PointerRNA *ptr)
817 rna_mesh(ptr)->active_uv_map_name(),
823static void rna_Mesh_uv_layer_active_index_set(
PointerRNA *ptr,
int value)
832 mesh->uv_maps_active_set(*name);
841 attr_ptr.type = RNA_MeshUVLoopLayer;
852static int rna_Mesh_uv_layer_default_index_get(
PointerRNA *ptr)
856 rna_mesh(ptr)->default_uv_map_name(),
862static void rna_Mesh_uv_layer_default_index_set(
PointerRNA *ptr,
int value)
871 mesh->uv_maps_default_set(*name);
879 attr_ptr.type = RNA_MeshUVLoopLayer;
887 MEM_SAFE_DELETE(
mesh->clone_uv_map_attribute);
888 if (name.is_empty()) {
895static int rna_Mesh_uv_layer_clone_index_get(
PointerRNA *ptr)
899 if (!names.contains_as(
mesh->clone_uv_map_attribute)) {
902 return names.index_of_as(
mesh->clone_uv_map_attribute);
905static void rna_Mesh_uv_layer_clone_index_set(
PointerRNA *ptr,
int value)
908 MEM_SAFE_DELETE(
mesh->clone_uv_map_attribute);
910 if (!names.index_range().contains(value)) {
921 attr_ptr.type = RNA_MeshUVLoopLayer;
929 MEM_SAFE_DELETE(
mesh->stencil_uv_map_attribute);
930 if (name.is_empty()) {
933 mesh->stencil_uv_map_attribute =
BLI_strdupn(name.c_str(), name.size());
937static int rna_Mesh_uv_layer_stencil_index_get(
PointerRNA *ptr)
941 if (!names.contains_as(
mesh->stencil_uv_map_attribute)) {
944 return names.index_of_as(
mesh->stencil_uv_map_attribute);
947static void rna_Mesh_uv_layer_stencil_index_set(
PointerRNA *ptr,
int value)
950 MEM_SAFE_DELETE(
mesh->stencil_uv_map_attribute);
952 if (!names.index_range().contains(value)) {
961static std::optional<std::string> rna_MeshUVLoopLayer_path(
const PointerRNA *ptr)
964 return fmt::format(
"uv_layers[\"{}\"]",
BLI_str_escape(name.c_str()));
972 if (
mesh->runtime->edit_mesh) {
979 layername_func(name, buffer),
996 layername_func(name, buffer),
1008 if (
mesh->runtime->edit_mesh) {
1014 if (attributes.contains(name)) {
1029static int rna_MeshUVLoopLayer_pin_length(
PointerRNA *ptr)
1039static bool rna_MeshUVLoopLayer_active_render_get(
PointerRNA *ptr)
1044static bool rna_MeshUVLoopLayer_active_get(
PointerRNA *ptr)
1049static bool rna_MeshUVLoopLayer_clone_get(
PointerRNA *ptr)
1056static void rna_MeshUVLoopLayer_active_render_set(
PointerRNA *ptr,
bool value)
1064static void rna_MeshUVLoopLayer_active_set(
PointerRNA *ptr,
bool value)
1072static void rna_MeshUVLoopLayer_clone_set(
PointerRNA *ptr,
bool value)
1079 MEM_SAFE_DELETE(
mesh->clone_uv_map_attribute);
1080 if (name.is_empty()) {
1083 mesh->clone_uv_map_attribute =
BLI_strdupn(name.c_str(), name.size());
1097 if (index < 0 || index >=
internal->length) {
1122static int rna_Mesh_vertex_colors_length(
PointerRNA *ptr)
1128static void rna_Mesh_vertex_color_index_range(
PointerRNA *ptr,
int *
min,
int *
max,
int *,
int *)
1140 rna_mesh(ptr)->active_color_attribute,
1143 attr_ptr.type = RNA_MeshLoopColorLayer;
1147static void rna_Mesh_vertex_color_active_set(
PointerRNA *ptr,
1158static int rna_Mesh_vertex_color_active_index_get(
PointerRNA *ptr)
1163 mesh->active_color_attribute,
1169static void rna_Mesh_vertex_color_active_index_set(
PointerRNA *ptr,
int value)
1176 fprintf(stderr,
"Invalid loop byte attribute index %d\n", value);
1182static bool rna_mesh_color_active_render_get(
PointerRNA *ptr)
1188static bool rna_mesh_color_active_get(
PointerRNA *ptr)
1194static void rna_mesh_color_active_render_set(
PointerRNA *ptr,
bool value)
1202static void rna_mesh_color_active_set(
PointerRNA *ptr,
bool value)
1212 memset(&iter->internal.array, 0,
sizeof(iter->internal.array));
1215 void *
layer = attr_ptr ? attr_ptr.data :
nullptr;
1226static int rna_Mesh_skin_vertices_length(
PointerRNA *ptr)
1230 return attr_ptr ? 1 : 0;
1234static int rna_MeshPoly_vertices_get_length(
const PointerRNA *ptr,
1237 const int *poly_offset_p =
static_cast<const int *
>(ptr->data);
1238 const int poly_start = *poly_offset_p;
1239 const int poly_size = *(poly_offset_p + 1) - poly_start;
1242 return (
length[0] = poly_size);
1245static void rna_MeshPoly_vertices_get(
PointerRNA *ptr,
int *values)
1248 const int *poly_offset_p =
static_cast<const int *
>(ptr->data);
1249 const int poly_start = *poly_offset_p;
1250 const int poly_size = *(poly_offset_p + 1) - poly_start;
1251 memcpy(values, &
mesh->corner_verts()[poly_start],
sizeof(
int) * poly_size);
1254static int rna_MeshPolygon_loop_total_get(
PointerRNA *ptr)
1256 const int *
data =
static_cast<const int *
>(ptr->data);
1260static void rna_MeshPoly_vertices_set(
PointerRNA *ptr,
const int *values)
1263 const int *poly_offset_p =
static_cast<const int *
>(ptr->data);
1264 const int poly_start = *poly_offset_p;
1265 const int poly_size = *(poly_offset_p + 1) - poly_start;
1266 memcpy(&
mesh->corner_verts_for_write()[poly_start], values,
sizeof(
int) * poly_size);
1271static void rna_MeshPoly_material_index_range(
1280static bool rna_MeshEdge_hide_get(
PointerRNA *ptr)
1283 const int index = rna_MeshEdge_index_get(ptr);
1285 const VArray hide_edge = *attributes.lookup_or_default<
bool>(
1287 return hide_edge[
index];
1290static void rna_MeshEdge_hide_set(
PointerRNA *ptr,
bool value)
1293 const int index = rna_MeshEdge_index_get(ptr);
1301static bool rna_MeshEdge_select_get(
PointerRNA *ptr)
1304 const int index = rna_MeshEdge_index_get(ptr);
1306 const VArray select_edge = *attributes.lookup_or_default<
bool>(
1308 return select_edge[
index];
1311static void rna_MeshEdge_select_set(
PointerRNA *ptr,
bool value)
1314 const int index = rna_MeshEdge_index_get(ptr);
1319 select_edge.finish();
1322static bool rna_MeshEdge_use_edge_sharp_get(
PointerRNA *ptr)
1325 const int index = rna_MeshEdge_index_get(ptr);
1327 const VArray sharp_edge = *attributes.lookup_or_default<
bool>(
1329 return sharp_edge[
index];
1332static void rna_MeshEdge_use_edge_sharp_set(
PointerRNA *ptr,
bool value)
1335 const int index = rna_MeshEdge_index_get(ptr);
1340 sharp_edge.finish();
1343static bool rna_MeshEdge_use_seam_get(
PointerRNA *ptr)
1346 const int index = rna_MeshEdge_index_get(ptr);
1348 const VArray uv_seam = *attributes.lookup_or_default<
bool>(
1350 return uv_seam[
index];
1353static void rna_MeshEdge_use_seam_set(
PointerRNA *ptr,
bool value)
1356 const int index = rna_MeshEdge_index_get(ptr);
1364static bool rna_MeshEdge_is_loose_get(
PointerRNA *ptr)
1367 const int index = rna_MeshEdge_index_get(ptr);
1368 return mesh->loose_edges().contains(
index);
1371static int rna_MeshLoopTriangle_material_index_get(
PointerRNA *ptr)
1375 const VArray material_indices = *attributes.lookup_or_default<
int>(
1377 return material_indices[rna_MeshLoopTriangle_polygon_index_get(ptr)];
1380static bool rna_MeshLoopTriangle_use_smooth_get(
PointerRNA *ptr)
1384 const VArray sharp_face = *attributes.lookup_or_default<
bool>(
1386 return !sharp_face[rna_MeshLoopTriangle_polygon_index_get(ptr)];
1391static std::optional<std::string> rna_VertexGroupElement_path(
const PointerRNA *ptr)
1398 for (a = 0; a <
mesh->verts_num; a++, dvert++) {
1399 for (
b = 0;
b < dvert->totweight;
b++) {
1400 if (dw == &dvert->dw[
b]) {
1401 return fmt::format(
"vertices[{}].groups[{}]", a,
b);
1406 return std::nullopt;
1409static std::optional<std::string> rna_MeshPolygon_path(
const PointerRNA *ptr)
1411 return fmt::format(
"polygons[{}]", rna_MeshPolygon_index_get(
const_cast<PointerRNA *
>(ptr)));
1414static std::optional<std::string> rna_MeshLoopTriangle_path(
const PointerRNA *ptr)
1416 const int index = rna_MeshLoopTriangle_index_get(
const_cast<PointerRNA *
>(ptr));
1417 return fmt::format(
"loop_triangles[{}]",
index);
1420static std::optional<std::string> rna_MeshEdge_path(
const PointerRNA *ptr)
1422 return fmt::format(
"edges[{}]", rna_MeshEdge_index_get(
const_cast<PointerRNA *
>(ptr)));
1425static std::optional<std::string> rna_MeshLoop_path(
const PointerRNA *ptr)
1427 return fmt::format(
"loops[{}]", rna_MeshLoop_index_get(
const_cast<PointerRNA *
>(ptr)));
1430static std::optional<std::string> rna_MeshVertex_path(
const PointerRNA *ptr)
1432 return fmt::format(
"vertices[{}]", rna_MeshVertex_index_get(
const_cast<PointerRNA *
>(ptr)));
1435struct AttrReverseLookup {
1440static std::optional<AttrReverseLookup> find_attr_from_data_ptr(
const PointerRNA *ptr,
1445 const void *value =
static_cast<const void *
>(ptr->data);
1447 std::optional<AttrReverseLookup>
result;
1449 int index_in_group = -1;
1458 if (!
data.is_span()) {
1465 const GSpan span =
data.get_internal_span();
1466 int64_t index =
reinterpret_cast<const std::byte *
>(value) -
1467 reinterpret_cast<const std::byte *
>(span.data());
1471 index /= span.type().size;
1472 if (
index >= span.size()) {
1475 result = AttrReverseLookup{iter.name, index_in_group, int(
index)};
1482static std::optional<std::string> rna_LoopCustomData_data_path(
const PointerRNA *ptr,
1486 const std::optional<AttrReverseLookup>
lookup = find_attr_from_data_ptr(
1489 return std::nullopt;
1500 mesh->vert_positions_for_write().data(),
1506static int rna_Mesh_vertices_length(
PointerRNA *ptr)
1509 return mesh->verts_num;
1514 if (index < 0 || index >=
mesh->verts_num) {
1518 *ptr, RNA_MeshVertex, &
mesh->vert_positions_for_write()[
index], *r_ptr);
1528static int rna_Mesh_edges_length(
PointerRNA *ptr)
1531 return mesh->edges_num;
1536 if (index < 0 || index >=
mesh->edges_num) {
1549 mesh->face_offsets_for_write().data(),
1555static int rna_Mesh_polygons_length(
PointerRNA *ptr)
1558 return mesh->faces_num;
1563 if (index < 0 || index >=
mesh->faces_num) {
1567 *ptr, RNA_MeshPolygon, &
mesh->face_offsets_for_write()[
index], *r_ptr);
1576 mesh->corner_verts_for_write().data(),
1582static int rna_Mesh_loops_length(
PointerRNA *ptr)
1585 return mesh->corners_num;
1590 if (index < 0 || index >=
mesh->corners_num) {
1594 *ptr, RNA_MeshLoop, &
mesh->corner_verts_for_write()[
index], *r_ptr);
1598static int rna_Mesh_normals_domain_get(
PointerRNA *ptr)
1600 return int(rna_mesh(ptr)->normals_domain());
1616static int rna_Mesh_vertex_normals_length(
PointerRNA *ptr)
1619 return mesh->verts_num;
1625 if (index < 0 || index >=
mesh->verts_num) {
1630 *ptr, RNA_MeshNormalValue,
const_cast<float3 *
>(&
mesh->vert_normals()[
index]), *r_ptr);
1647static int rna_Mesh_poly_normals_length(
PointerRNA *ptr)
1650 return mesh->faces_num;
1656 if (index < 0 || index >=
mesh->faces_num) {
1661 *ptr, RNA_MeshNormalValue,
const_cast<float3 *
>(&
mesh->face_normals()[
index]), *r_ptr);
1670 iter->valid =
false;
1674 iter, ptr, (
void *)normals.
data(),
sizeof(
float[3]),
mesh->corners_num,
false,
nullptr);
1677static int rna_Mesh_corner_normals_length(
PointerRNA *ptr)
1680 return mesh->corners_num;
1687 if (index < 0 || index >=
mesh->corners_num || normals.
is_empty()) {
1692 *ptr, RNA_MeshNormalValue,
const_cast<float3 *
>(&normals[
index]), *r_ptr);
1696static std::optional<std::string> rna_MeshUVLoop_path(
const PointerRNA *ptr)
1698 return rna_LoopCustomData_data_path(ptr,
"uv_layers",
CD_PROP_FLOAT2);
1711static std::optional<AttrReverseLookup> find_uv_from_data_ptr(
const PointerRNA *ptr)
1716static bool rna_MeshUVLoop_pin_uv_get(
PointerRNA *ptr)
1719 if (
const std::optional<AttrReverseLookup> lookup = find_uv_from_data_ptr(ptr)) {
1721 return pin_uv[
lookup->elem_index];
1726static void rna_MeshUVLoop_pin_uv_set(
PointerRNA *ptr,
const bool value)
1729 if (
const std::optional<AttrReverseLookup> lookup = find_uv_from_data_ptr(ptr)) {
1732 pin_uv.varray.set(
lookup->elem_index, value);
1737static void rna_MeshUVLoop_uv_get(
PointerRNA *ptr,
float *value)
1739 copy_v2_v2(value,
static_cast<const float *
>(ptr->data));
1742static void rna_MeshUVLoop_uv_set(
PointerRNA *ptr,
const float *value)
1744 copy_v2_v2(
static_cast<float *
>(ptr->data), value);
1747static std::optional<std::string> rna_MeshSkinVertexLayer_path(
const PointerRNA * )
1750 return "skin_vertices[\"\"]";
1753static std::optional<int> vert_index_from_skin_data_ptr(
const PointerRNA *ptr)
1759 return std::nullopt;
1761 if (!
radius.varray.is_span()) {
1762 return std::nullopt;
1766 if (index < 0 || index >=
data.size()) {
1767 return std::nullopt;
1772static std::optional<std::string> rna_MeshSkinVertex_path(
const PointerRNA *ptr)
1774 const std::optional<int>
index = vert_index_from_skin_data_ptr(ptr);
1776 return std::nullopt;
1778 return fmt::format(
"skin_vertices[\"\"].data[{}]", *
index);
1781static void rna_MeshSkinVertex_radius_get(
PointerRNA *ptr,
float *value)
1783 copy_v2_v2(value,
static_cast<const float *
>(ptr->data));
1786static void rna_MeshSkinVertex_radius_set(
PointerRNA *ptr,
const float *value)
1788 copy_v2_v2(
static_cast<float *
>(ptr->data), value);
1791static bool rna_MeshSkinVertex_use_root_get(
PointerRNA *ptr)
1794 if (
const std::optional<int>
index = vert_index_from_skin_data_ptr(ptr)) {
1797 return root[*
index];
1802static void rna_MeshSkinVertex_use_root_set(
PointerRNA *ptr,
const bool value)
1805 if (
const std::optional<int>
index = vert_index_from_skin_data_ptr(ptr)) {
1808 root.varray.set(*
index, value);
1813static bool rna_MeshSkinVertex_use_loose_get(
PointerRNA *ptr)
1816 if (
const std::optional<int>
index = vert_index_from_skin_data_ptr(ptr)) {
1819 return loose[*
index];
1824static void rna_MeshSkinVertex_use_loose_set(
PointerRNA *ptr,
const bool value)
1827 if (
const std::optional<int>
index = vert_index_from_skin_data_ptr(ptr)) {
1830 loose.varray.set(*
index, value);
1845 if (index < 0 || index >=
internal->length) {
1858static std::optional<std::string> rna_MeshLoopColorLayer_path(
const PointerRNA *ptr)
1863static std::optional<std::string> rna_MeshColor_path(
const PointerRNA *ptr)
1870static int rna_Mesh_tot_vert_get(
PointerRNA *ptr)
1876static int rna_Mesh_tot_edge_get(
PointerRNA *ptr)
1882static int rna_Mesh_tot_face_get(
PointerRNA *ptr)
1895 mesh, name,
false, do_init, reports);
1900 if (!
mesh->active_color_attribute) {
1903 if (!
mesh->default_color_attribute) {
1911 attr_ptr.type = RNA_MeshLoopColorLayer;
1926 const std::optional<std::string> new_name =
ED_mesh_uv_add(
mesh, name,
false, do_init, reports);
1932 if (
mesh->active_uv_map_name().is_empty()) {
1933 mesh->uv_maps_active_set(*new_name);
1935 if (
mesh->default_uv_map_name().is_empty()) {
1936 mesh->uv_maps_default_set(*new_name);
1938 attr_ptr.type = RNA_MeshUVLoopLayer;
1946 if (
mesh->runtime->edit_mesh) {
1955 if (!attributes.contains(name)) {
1963static bool rna_Mesh_is_editmode_get(
PointerRNA *ptr)
1966 return (
mesh->runtime->edit_mesh !=
nullptr);
1969static bool rna_Mesh_materials_override_apply(
Main *bmain,
1974 PointerRNA *ptr_item_dst = &rnaapply_ctx.ptr_item_dst;
1975 PointerRNA *ptr_item_src = &rnaapply_ctx.ptr_item_src;
1979 "Unsupported RNA override operation on collections' objects");
1982 Mesh *mesh_dst = id_cast<Mesh *>(ptr_dst->owner_id);
1984 if (!ptr_item_dst->has_type() || !ptr_item_src->has_type()) {
1992 if (mat_src == mat_dst) {
1996 bool is_modified =
false;
1997 for (
int i = 0; i < mesh_dst->totcol; i++) {
1998 if (mesh_dst->mat[i] == mat_dst) {
2000 mesh_dst->mat[i] = mat_src;
2034 srna,
"Vertex Group Element",
"Weight value of a vertex in a vertex group");
2087 "rna_MeshVertex_groups_begin",
2088 "rna_iterator_array_next",
2089 "rna_iterator_array_end",
2090 "rna_iterator_array_get",
2097 prop,
"Groups",
"Weights for the vertex groups this vertex is member of");
2108 "Undeformed Location",
2109 "For meshes with modifiers applied, the coordinate of the vertex with no deforming "
2110 "modifiers applied, as used for generated texture coordinates");
2152 prop,
"rna_MeshEdge_use_edge_sharp_get",
"rna_MeshEdge_use_edge_sharp_set");
2171 const int splitnor_dim[] = {3, 3};
2202 prop,
"Triangle Normal",
"Local space unit length normal vector for this triangle");
2212 "Local space unit length custom normal vectors of the face corners of this triangle");
2247 prop,
"rna_MeshLoop_vertex_index_get",
"rna_MeshLoop_vertex_index_set",
nullptr);
2253 prop,
"rna_MeshLoop_edge_index_get",
"rna_MeshLoop_edge_index_set",
nullptr);
2269 "The normal direction of the face corner, taking into account sharp "
2270 "faces, sharp edges, and custom normal data");
2279 "Local space unit length tangent vector of this vertex for this face "
2280 "(must be computed beforehand using calc_tangents)");
2289 "Sign of the bitangent vector of this vertex for this face (must be computed "
2290 "beforehand using calc_tangents, bitangent = bitangent_sign * cross(normal, tangent))");
2300 "Bitangent vector of this vertex for this face (must be computed beforehand using "
2301 "calc_tangents, use it only if really needed, slower access than bitangent_sign)");
2326 prop,
"rna_MeshPoly_vertices_get",
"rna_MeshPoly_vertices_set",
nullptr);
2343 prop,
"rna_MeshPolygon_material_index_get",
"rna_MeshPolygon_material_index_set",
nullptr);
2364 prop,
"rna_MeshPolygon_use_smooth_get",
"rna_MeshPolygon_use_smooth_set");
2374 prop,
"Polygon Normal",
"Local space unit length normal vector for this face");
2411 "MeshUVLoop (Deprecated)",
2412 "Deprecated, use 'uv', 'vertex_select', 'edge_select' or 'pin' properties instead");
2415 "rna_Attribute_data_begin",
2416 "rna_iterator_array_next",
2417 "rna_iterator_array_end",
2418 "rna_iterator_array_get",
2419 "rna_Attribute_data_length",
2420 "rna_MeshUVLoopLayer_data_lookup_int",
2427 prop,
"rna_Attribute_name_get",
"rna_Attribute_name_length",
"rna_Attribute_name_set");
2434 prop,
"rna_MeshUVLoopLayer_active_get",
"rna_MeshUVLoopLayer_active_set");
2441 prop,
"rna_MeshUVLoopLayer_active_render_get",
"rna_MeshUVLoopLayer_active_render_set");
2448 prop,
"rna_MeshUVLoopLayer_clone_get",
"rna_MeshUVLoopLayer_clone_set");
2458 "rna_Attribute_data_begin",
2459 "rna_iterator_array_next",
2460 "rna_iterator_array_end",
2461 "rna_iterator_array_get",
2462 "rna_Attribute_data_length",
2463 "rna_Attribute_data_lookup_int",
2473 "rna_MeshUVLoopLayer_pin_begin",
2474 "rna_iterator_array_next",
2475 "rna_iterator_array_end",
2476 "rna_iterator_array_get",
2477 "rna_MeshUVLoopLayer_pin_length",
2478 "rna_Attribute_data_lookup_int",
2482 func =
RNA_def_function(srna,
"pin_ensure",
"rna_MeshUVLoopLayer_pin_ensure");
2484 parm =
RNA_def_pointer(func,
"layer",
"BoolAttribute",
"",
"The boolean attribute");
2490 srna,
"Mesh UV Layer",
"(Deprecated) Layer of UV coordinates in a Mesh data-block");
2511 srna,
"Mesh Vertex Color Layer",
"Layer of vertex colors in a Mesh data-block");
2518 prop,
"rna_Attribute_name_get",
"rna_Attribute_name_length",
"rna_Attribute_name_set");
2531 prop,
"rna_mesh_color_active_render_get",
"rna_mesh_color_active_render_set");
2541 "rna_Attribute_data_begin",
2542 "rna_iterator_array_next",
2543 "rna_iterator_array_end",
2544 "rna_iterator_array_get",
2545 "rna_Attribute_data_length",
2559 prop,
"rna_MeshLoopColor_color_get",
"rna_MeshLoopColor_color_set",
nullptr);
2573 "Auto Texture Space",
2574 "Adjust active object's texture space automatically when transforming object");
2607 "rna_IDMaterials_assign_int");
2628 func,
"count", 0, 0,
INT_MAX,
"Count",
"Number of vertices to add", 0,
INT_MAX);
2671 srna,
"Mesh Loop Triangles",
"Tessellation of mesh polygons into triangles");
2718 func,
"count", 0, 0,
INT_MAX,
"Count",
"Number of polygons to add", 0,
INT_MAX);
2757 "Whether new layer's data should be initialized by copying current active one");
2758 parm =
RNA_def_pointer(func,
"layer",
"MeshLoopColorLayer",
"",
"The newly created layer");
2765 parm =
RNA_def_pointer(func,
"layer",
"MeshLoopColorLayer",
"",
"The layer to remove");
2772 "rna_Mesh_vertex_color_active_get",
2773 "rna_Mesh_vertex_color_active_set",
2782 "rna_Mesh_vertex_color_active_index_get",
2783 "rna_Mesh_vertex_color_active_index_set",
2784 "rna_Mesh_vertex_color_index_range");
2811 "Whether new layer's data should be initialized by copying current active one, "
2812 "or if none is active, with a default UVmap");
2813 parm =
RNA_def_pointer(func,
"layer",
"MeshUVLoopLayer",
"",
"The newly created layer");
2820 parm =
RNA_def_pointer(func,
"layer",
"MeshUVLoopLayer",
"",
"The layer to remove");
2826 prop,
"rna_Mesh_uv_layer_active_get",
"rna_Mesh_uv_layer_active_set",
nullptr,
nullptr);
2834 "rna_Mesh_uv_layer_active_index_get",
2835 "rna_Mesh_uv_layer_active_index_set",
2836 "rna_Mesh_uv_layer_index_range");
2844 prop,
"rna_Mesh_uv_layer_default_get",
"rna_Mesh_uv_layer_default_set",
nullptr,
nullptr);
2852 "rna_Mesh_uv_layer_default_index_get",
2853 "rna_Mesh_uv_layer_default_index_set",
2854 "rna_Mesh_uv_layer_index_range");
2868 srna,
"Mesh Skin Vertex Layer",
"Per-vertex skin data for use with the Skin modifier");
2874 prop,
"rna_Attribute_name_get",
"rna_Attribute_name_length",
"rna_Attribute_name_set");
2884 "rna_Attribute_data_begin",
2885 "rna_iterator_array_next",
2886 "rna_iterator_array_end",
2887 "rna_iterator_array_get",
2888 "rna_Attribute_data_length",
2889 "rna_MeshSkinVertexLayer_data_lookup_int",
2896 srna,
"Skin Vertex",
"Per-vertex skin data for use with the Skin modifier");
2902 prop,
"rna_MeshSkinVertex_radius_get",
"rna_MeshSkinVertex_radius_set",
nullptr);
2911 prop,
"rna_MeshSkinVertex_use_root_get",
"rna_MeshSkinVertex_use_root_set");
2914 "Vertex is a root for rotation calculations and armature generation, "
2915 "setting this flag does not clear other roots in the same mesh island");
2920 prop,
"rna_MeshSkinVertex_use_loose_get",
"rna_MeshSkinVertex_use_loose_set");
2922 prop,
"Loose",
"If vertex has multiple adjacent edges, it is hulled to them directly");
2949 "rna_Mesh_vertices_begin",
2950 "rna_iterator_array_next",
2951 "rna_iterator_array_end",
2952 "rna_iterator_array_get",
2953 "rna_Mesh_vertices_length",
2954 "rna_Mesh_vertices_lookup_int",
2964 "rna_Mesh_edges_begin",
2965 "rna_iterator_array_next",
2966 "rna_iterator_array_end",
2967 "rna_iterator_array_get",
2968 "rna_Mesh_edges_length",
2969 "rna_Mesh_edges_lookup_int",
2979 "rna_Mesh_loops_begin",
2980 "rna_iterator_array_next",
2981 "rna_iterator_array_end",
2982 "rna_iterator_array_get",
2983 "rna_Mesh_loops_length",
2984 "rna_Mesh_loops_lookup_int",
2994 "rna_Mesh_polygons_begin",
2995 "rna_iterator_array_next",
2996 "rna_iterator_array_end",
2997 "rna_iterator_array_get",
2998 "rna_Mesh_polygons_length",
2999 "rna_Mesh_polygons_lookup_int",
3013 {0,
nullptr, 0,
nullptr,
nullptr},
3021 "The attribute domain that gives enough information to represent the mesh's normals");
3030 "The normal direction of each vertex, defined as the average of the "
3031 "surrounding face normals");
3033 "rna_Mesh_vertex_normals_begin",
3034 "rna_iterator_array_next",
3035 "rna_iterator_array_end",
3036 "rna_iterator_array_get",
3037 "rna_Mesh_vertex_normals_length",
3038 "rna_Mesh_vertex_normals_lookup_int",
3047 "The normal direction of each face, defined by the winding order "
3048 "and position of its vertices");
3050 "rna_Mesh_poly_normals_begin",
3051 "rna_iterator_array_next",
3052 "rna_iterator_array_end",
3053 "rna_iterator_array_get",
3054 "rna_Mesh_poly_normals_length",
3055 "rna_Mesh_poly_normals_lookup_int",
3065 "The \"split\" normal direction of each face corner, influenced by vertex normals, "
3066 "sharp faces, sharp edges, and custom normals. May be empty.");
3068 "rna_Mesh_corner_normals_begin",
3069 "rna_iterator_array_next",
3070 "rna_iterator_array_end",
3071 "rna_iterator_array_get",
3072 "rna_Mesh_corner_normals_length",
3073 "rna_Mesh_corner_normals_lookup_int",
3079 "rna_Mesh_loop_triangles_begin",
3080 "rna_iterator_array_next",
3081 "rna_iterator_array_end",
3082 "rna_iterator_array_get",
3083 "rna_Mesh_loop_triangles_length",
3084 "rna_Mesh_loop_triangles_lookup_int",
3096 "rna_Mesh_loop_triangle_polygons_begin",
3097 "rna_iterator_array_next",
3098 "rna_iterator_array_end",
3099 "rna_iterator_array_get",
3100 "rna_Mesh_loop_triangles_length",
3101 "rna_Mesh_loop_triangle_polygons_lookup_int",
3116 "Use another mesh for texture indices (vertex indices must be aligned)");
3121 "rna_Mesh_uv_layers_begin",
3122 "rna_iterator_array_next",
3123 "rna_iterator_array_end",
3124 "rna_Mesh_uv_layers_iterator_get",
3125 "rna_Mesh_uv_layers_length",
3137 prop,
"rna_Mesh_uv_layer_clone_get",
"rna_Mesh_uv_layer_clone_set",
nullptr,
nullptr);
3141 prop,
"Clone UV Loop Layer",
"UV loop layer to be used as cloning source");
3145 "rna_Mesh_uv_layer_clone_index_get",
3146 "rna_Mesh_uv_layer_clone_index_set",
3147 "rna_Mesh_uv_layer_index_range");
3154 prop,
"rna_Mesh_uv_layer_stencil_get",
"rna_Mesh_uv_layer_stencil_set",
nullptr,
nullptr);
3161 "rna_Mesh_uv_layer_stencil_index_get",
3162 "rna_Mesh_uv_layer_stencil_index_set",
3163 "rna_Mesh_uv_layer_index_range");
3172 "rna_Mesh_vertex_colors_begin",
3173 "rna_iterator_array_next",
3174 "rna_iterator_array_end",
3175 "rna_Mesh_vertex_colors_iterator_get",
3176 "rna_Mesh_vertex_colors_length",
3185 "Legacy vertex color layers. Deprecated, use color attributes instead.");
3191 "rna_Mesh_skin_vertices_begin",
3192 "rna_iterator_array_next",
3193 "rna_iterator_array_end",
3194 "rna_Mesh_skin_vertices_iterator_get",
3195 "rna_Mesh_skin_vertices_length",
3217 "Size of the voxel in object space used for volume evaluation. Lower "
3218 "values preserve finer details.");
3230 "Reduces the final face count by simplifying geometry where detail is not needed, "
3231 "generating triangles. A value greater than 0 disables Fix Poles.");
3248 "Projects the mesh to preserve the volume and details of the original mesh");
3293 "Mirror Vertex Groups",
3294 "Mirror the left/right vertex groups when painting. The symmetry axis "
3295 "is determined by the symmetry settings.");
3305 prop,
"Radial Symmetry Count",
"Number of mirrored regions around a central axis");
3313 prop,
"Has Custom Normals",
"True if there is custom normal data for this mesh");
3322 prop,
"Texture Space Mesh",
"Derive texture coordinates from another mesh");
3335 "Auto Texture Space",
3336 "Adjust active object's texture space automatically when transforming object");
3345 prop,
"rna_Mesh_texspace_location_get",
"rna_Mesh_texspace_location_set",
nullptr);
3355 "Use topology based mirroring "
3356 "(for when both sides of mesh have matching, unique topology)");
Generic geometry attributes built on CustomData.
#define ATTR_DOMAIN_AS_MASK(domain)
CustomData interface, see also DNA_customdata_types.h.
#define RNA_MAX_ARRAY_DIMENSION
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define BLI_assert_msg(a, msg)
#define MAX_CUSTOMDATA_LAYER_NAME
#define CD_MASK_PROP_BYTE_COLOR
#define CD_MASK_PROP_FLOAT2
#define CD_MASK_PROP_BOOL
#define MAX_CUSTOMDATA_LAYER_NAME_NO_PREFIX
SIMD_FORCE_INLINE btScalar length() const
Return the length of the vector.
constexpr const T * data() const
constexpr int64_t size() const
constexpr bool is_empty() const
static AttributeOwner from_id(ID *id)
constexpr IndexRange()=default
StringRefNull name() const
float3 face_normal_calc(Span< float3 > vert_positions, Span< int > face_verts)
float face_area_calc(Span< float3 > vert_positions, Span< int > face_verts)
float3 face_center_calc(Span< float3 > vert_positions, Span< int > face_verts)
std::optional< eCustomDataType > attr_type_to_custom_data_type(AttrType attr_type)
void mesh_flip_faces(Mesh &mesh, const IndexMask &selection)
int size(const AssetLibraryReference *library_reference)
const MultiFunction & lookup(UString id)
constexpr StringRefNull radius
void WM_main_add_notifier(uint type, void *reference)
static const EnumPropertyItem rna_enum_mesh_remesh_mode_items[]
void RNA_def_property_srna(PropertyRNA *prop, const char *type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
static void rna_def_mesh_vertices(BlenderRNA *brna, PropertyRNA *cprop)
void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable)
bool BKE_attribute_remove(AttributeOwner &owner, StringRef name, struct ReportList *reports)
void rna_Mesh_update_draw(Main *bmain, Scene *scene, PointerRNA *ptr)
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
void RNA_def_property_dynamic_array_funcs(PropertyRNA *prop, const char *getlength)
void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, const int maxlen, const char *ui_name, const char *ui_description)
void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
void BKE_id_attributes_default_color_set(struct ID *id, std::optional< StringRef > name)
void RNA_def_property_override_funcs(PropertyRNA *prop, const char *diff, const char *store, const char *apply)
MINLINE void copy_v3_v3(float r[3], const float a[3])
const EnumPropertyItem rna_enum_mesh_walk_delimit_face_loop_items[]
void rna_iterator_array_end(CollectionPropertyIterator *iter)
void RNA_property_update_main(Main *bmain, Scene *scene, PointerRNA *ptr, PropertyRNA *prop)
void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *type_fn, const char *poll)
void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
static void rna_def_mesh_looptris(BlenderRNA *brna, PropertyRNA *cprop)
static void rna_def_mvert(BlenderRNA *brna)
PointerRNA RNA_id_pointer_create(ID *id)
VArray< bool > ED_mesh_uv_map_pin_layer_get(const Mesh *mesh, int uv_index)
MINLINE void copy_v2_v2(float r[2], const float a[2])
void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
static void rna_def_mesh_polygons(BlenderRNA *brna, PropertyRNA *cprop)
StringRefNull rna_Attribute_name_get(const PointerRNA &ptr)
PropertyRNA * RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type, const char *ui_name, const char *ui_description)
void rna_pointer_create_with_ancestors(const PointerRNA &parent, StructRNA *type, void *data, PointerRNA &r_ptr)
int BKE_attributes_length(const AttributeOwner &owner, AttrDomainMask domain_mask, eCustomDataMask mask, bool include_anonymous=true)
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
MINLINE int max_ii(int a, int b)
void BKE_mesh_tessface_clear(Mesh *mesh)
float normal_tri_v3(float n[3], const float v1[3], const float v2[3], const float v3[3])
static void rna_def_medge(BlenderRNA *brna)
void RNA_def_property_string_maxlength(PropertyRNA *prop, int maxlength)
static void rna_def_mlooptri(BlenderRNA *brna)
static void rna_def_mesh_edges(BlenderRNA *brna, PropertyRNA *cprop)
MINLINE void mul_v3_fl(float r[3], float f)
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
const EnumPropertyItem rna_enum_mesh_walk_delimit_edge_ring_items[]
@ PROPOVERRIDE_OVERRIDABLE_LIBRARY
void rna_Attribute_data_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
void rna_def_animdata_common(StructRNA *srna)
static void rna_def_mloopcol(BlenderRNA *brna)
VecBase< float, 4 > float4
PropertyRNA * RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier_c_str, int type, int subtype)
void rna_def_texmat_common(StructRNA *srna, const char *texspace_editable)
void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
bool BKE_mesh_has_custom_loop_normals(Mesh *mesh)
@ ME_EDIT_MIRROR_VERTEX_GROUPS
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
static void rna_def_uv_layers(BlenderRNA *brna, PropertyRNA *cprop)
void RNA_def_property_collection_funcs(PropertyRNA *prop, const char *begin, const char *next, const char *end, const char *get, const char *length, const char *lookupint, const char *lookupstring, const char *assignint)
void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
void RNA_def_property_override_flag(PropertyRNA *prop, PropertyOverrideFlag flag)
void BKE_mesh_batch_cache_dirty_tag(Mesh *mesh, eMeshBatchDirtyMode mode)
const EnumPropertyItem rna_enum_mesh_walk_delimit_edge_loop_items[]
void BKE_mesh_texspace_get(Mesh *mesh, float r_texspace_location[3], float r_texspace_size[3])
void RNA_def_mesh(BlenderRNA *brna)
int rna_Attribute_data_length(PointerRNA *ptr)
void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
void RNA_def_property_range(PropertyRNA *prop, double min, double max)
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
void RNA_def_struct_path_func(StructRNA *srna, const char *path)
void BKE_mesh_texspace_ensure(Mesh *mesh)
void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
static void rna_def_mloop(BlenderRNA *brna)
const EnumPropertyItem rna_enum_mesh_delimit_mode_items[]
int BKE_mesh_runtime_corner_tris_len(const Mesh *mesh)
eCustomDataMask CD_TYPE_AS_MASK(eCustomDataType type)
void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
const void * CustomData_get_layer(const CustomData *data, eCustomDataType type)
FunctionRNA * RNA_def_function(StructRNA *srna, const char *identifier_c_str, const char *call)
std::optional< std::string > ED_mesh_color_add(Mesh *mesh, const char *name, bool active_set, bool do_init, ReportList *reports)
std::optional< StringRef > BKE_attribute_from_index(AttributeOwner &owner, int lookup_index, AttrDomainMask domain_mask, eCustomDataMask layer_mask, bool include_anonymous=true)
void * rna_iterator_array_get(CollectionPropertyIterator *iter)
MINLINE void zero_v3(float r[3])
@ ME_REMESH_REPROJECT_ATTRIBUTES
@ ME_REMESH_REPROJECT_VOLUME
void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
bke::AttributeWriter< bool > ED_mesh_uv_map_pin_layer_ensure(Mesh *mesh, int uv_index)
void rna_AttributeGroup_iterator_begin(CollectionPropertyIterator *iter, PointerRNA *ptr, AttrDomainMask domain_mask, eCustomDataMask cd_type_mask, bool include_anonymous)
void RNA_def_function_flag(FunctionRNA *func, FunctionFlag flag)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
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)
MINLINE void madd_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
static void rna_def_loop_colors(BlenderRNA *brna, PropertyRNA *cprop)
static void rna_def_looptri_poly_value(BlenderRNA *brna)
@ ATTR_DOMAIN_MASK_CORNER
void RNA_api_mesh(StructRNA *srna)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
ATTR_WARN_UNUSED_RESULT const BMVert * v2
static void rna_def_mvert_group(BlenderRNA *brna)
int BKE_attribute_to_index(const AttributeOwner &owner, const StringRef name, AttrDomainMask domain_mask, eCustomDataMask layer_mask, bool include_anonymous=true)
float area_tri_v3(const float v1[3], const float v2[3], const float v3[3])
StructRNA * RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
void BKE_id_attributes_active_color_set(struct ID *id, std::optional< StringRef > name)
static void rna_def_normal_layer_value(BlenderRNA *brna)
void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
const BMesh * BKE_editmesh_bmesh_get(const Object *ob)
MINLINE unsigned char round_fl_to_uchar_clamp(float a)
void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
std::optional< std::string > ED_mesh_uv_add(Mesh *mesh, const char *name, bool active_set, bool do_init, ReportList *reports)
PointerRNA RNA_pointer_create_with_parent(const PointerRNA &parent, StructRNA *type, void *data)
static void rna_def_mpolygon(BlenderRNA *brna)
void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
void RNA_define_verify_sdna(bool verify)
VecBase< float, 3 > float3
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
bool CustomData_has_layer_named(const CustomData *data, eCustomDataType type, StringRef name)
void RNA_def_property_int_default(PropertyRNA *prop, int value)
@ BKE_MESH_BATCH_DIRTY_ALL
StringRef BKE_uv_map_pin_name_get(StringRef uv_map_name, char *buffer)
void RNA_def_struct_name_property(StructRNA *srna, PropertyRNA *prop, const bool allow_replace)
static void rna_def_mloopuv(BlenderRNA *brna)
static void rna_def_mesh(BlenderRNA *brna)
void RNA_def_property_array(PropertyRNA *prop, int length)
static void rna_def_skin_vertices(BlenderRNA *brna, PropertyRNA *)
PointerRNA rna_AttributeGroup_lookup_string(const PointerRNA &ptr, const StringRef key, AttrDomainMask domain_mask, eCustomDataMask cd_type_mask)
void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
static void rna_def_mesh_loops(BlenderRNA *brna, PropertyRNA *cprop)
void rna_iterator_array_begin(CollectionPropertyIterator *iter, PointerRNA *ptr, void *data, size_t itemsize, int64_t length, bool free_ptr, IteratorSkipFunc skip)
@ BMW_DELIMIT_EDGE_LOOP_OUTER_CORNERS
@ BMW_DELIMIT_EDGE_MARK_SHARP
@ BMW_DELIMIT_EDGE_LOOP_INNER_CORNERS
@ BMW_DELIMIT_EDGE_LOOP_NGONS
@ BMW_DELIMIT_FACE_MARK_MATERIAL
@ BMW_DELIMIT_EDGE_MARK_SEAM
@ BMW_DELIMIT_EDGE_RING_NGONS
void rna_def_attributes_common(StructRNA *srna, const AttributeOwnerType type)
void BKE_mesh_runtime_clear_geometry(Mesh *mesh)
VMutableArray< T > varray