blender
/
blender
136
406
Fork 589
Code Issues 6.2k Pull Requests 749 Projects 19 Wiki Activity

All compile errors fixed, basic viewport works

This commit is contained in:
Hans Goudey 2022-12-06 18:15:16 -06:00
parent c51550c6eb
commit a0991a1a9f
37 changed files with 165 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
intern/cycles/blender/mesh.cpp
View File

@ -820,6 +820,23 @@ static void attr_create_pointiness(Scene *scene, Mesh *mesh, BL::Mesh &b_mesh, b
}
}
static std::optional<BL::IntAttribute> find_corner_vert_attribute(BL::Mesh b_mesh)
{
for (BL::Attribute &b_attribute : b_mesh.attributes) {
if (b_attribute.domain() != BL::Attribute::domain_CORNER) {
continue;
}
if (b_attribute.data_type() != BL::Attribute::data_type_INT) {
continue;
}
if (b_attribute.name() != ".corner_vert") {
continue;
}
return BL::IntAttribute{b_attribute};
}
return std::nullopt;
}
/* The Random Per Island attribute is a random float associated with each
* connected component (island) of the mesh. The attribute is computed by
* first classifying the vertices into different sets using a Disjoint Set
@ -866,11 +883,11 @@ static void attr_create_random_per_island(Scene *scene,
else {
if (polys_num != 0) {
const MPoly *polys = static_cast<const MPoly *>(b_mesh.polygons[0].ptr.data);
const int *corner_verts = b_mesh.corner_verts[0].ptr.data;
std::optional<BL::IntAttribute> corner_verts = find_corner_vert_attribute(b_mesh);
for (int i = 0; i < polys_num; i++) {
const MPoly &b_poly = polys[i];
const int vert = corner_verts[b_poly.loopstart];
data[i] = hash_uint_to_float(vertices_sets.find(b_loop.v));
const int vert = corner_verts->data[b_poly.loopstart].value();
data[i] = hash_uint_to_float(vertices_sets.find(vert));
}
}
}
@ -1014,7 +1031,7 @@ static void create_mesh(Scene *scene,
else {
vector<int> vi;
const int *corner_verts = b_mesh.corner_verts[0].ptr.data;
std::optional<BL::IntAttribute> corner_verts = find_corner_vert_attribute(b_mesh);
for (int i = 0; i < numfaces; i++) {
const MPoly &b_poly = polys[i];
@ -1025,7 +1042,7 @@ static void create_mesh(Scene *scene,
vi.resize(n);
for (int i = 0; i < n; i++) {
/* NOTE: Autosmooth is already taken care about. */
vi[i] = corner_verts[b_poly.loopstart + i];
vi[i] = corner_verts->data[b_poly.loopstart + i].value();
}
/* create subd faces */

18
source/blender/blenkernel/BKE_mesh.h
View File

@ -1047,23 +1047,21 @@ BLI_INLINE MPoly *BKE_mesh_polys_for_write(Mesh *mesh)
BLI_INLINE const int *BKE_mesh_corner_verts(const Mesh *mesh)
{
return (const float(*)[3])CustomData_get_layer_named(
&mesh->ldata, CD_PROP_INT32, ".corner_vert");
return (const int *)CustomData_get_layer_named(&mesh->ldata, CD_PROP_INT32, ".corner_vert");
}
BLI_INLINE int *BKE_mesh_corner_verts_for_write(Mesh *mesh)
{
return (float(*)[3])CustomData_duplicate_referenced_layer_named(
return (int *)CustomData_duplicate_referenced_layer_named(
&mesh->ldata, CD_PROP_INT32, ".corner_vert", mesh->totloop);
}
BLI_INLINE const int *BKE_mesh_corner_edges(const Mesh *mesh)
{
return (const float(*)[3])CustomData_get_layer_named(
&mesh->ldata, CD_PROP_INT32, ".corner_edge");
return (const int *)CustomData_get_layer_named(&mesh->ldata, CD_PROP_INT32, ".corner_edge");
}
BLI_INLINE int *BKE_mesh_corner_edges_for_write(Mesh *mesh)
{
return (float(*)[3])CustomData_duplicate_referenced_layer_named(
return (int *)CustomData_duplicate_referenced_layer_named(
&mesh->ldata, CD_PROP_INT32, ".corner_edge", mesh->totloop);
}
@ -1120,20 +1118,20 @@ inline blender::MutableSpan<MPoly> Mesh::polys_for_write()
inline blender::Span<int> Mesh::corner_verts() const
{
return {BKE_mesh_corner_verts(this), mesh->totloop};
return {BKE_mesh_corner_verts(this), this->totloop};
}
inline blender::MutableSpan<int> Mesh::corner_verts_for_write()
{
return {BKE_mesh_corner_verts_for_write(this), mesh->totloop};
return {BKE_mesh_corner_verts_for_write(this), this->totloop};
}
inline blender::Span<int> Mesh::corner_edges() const
{
return {BKE_mesh_corner_edges(this), mesh->totloop};
return {BKE_mesh_corner_edges(this), this->totloop};
}
inline blender::MutableSpan<int> Mesh::corner_edges_for_write()
{
return {BKE_mesh_corner_edges_for_write(this), mesh->totloop};
return {BKE_mesh_corner_edges_for_write(this), this->totloop};
}
inline blender::Span<MDeformVert> Mesh::deform_verts() const

4
source/blender/blenkernel/BKE_mesh_legacy_convert.h
View File

@ -101,10 +101,10 @@ struct MLoop *BKE_mesh_legacy_convert_corners_to_loops(
blender::ResourceScope &temp_arrays_for_convert,
blender::Vector<CustomDataLayer, 16> &loop_layers_to_write);
void BKE_mesh_legacy_convert_loops_to_corners(Mesh *mesh);
#endif
void BKE_mesh_legacy_convert_loops_to_corners(struct Mesh *mesh);
/**
* Recreate #MFace Tessellation.
*

1
source/blender/blenkernel/intern/data_transfer.cc
View File

@ -1616,7 +1616,6 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
const MPoly *polys_dst = BKE_mesh_polys(me_dst);
const int num_polys_dst = me_dst->totpoly;
const int *corner_verts_dst = BKE_mesh_corner_verts(me_dst);
const int *corner_edges_dst = BKE_mesh_corner_edges(me_dst);
const int num_loops_dst = me_dst->totloop;
if (!geom_map_init[PDATA]) {

2
source/blender/blenkernel/intern/key.cc
View File

@ -2237,6 +2237,7 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
const MEdge *edges = BKE_mesh_edges(mesh);
const MPoly *polys = BKE_mesh_polys(mesh);
const int *corner_verts = BKE_mesh_corner_verts(mesh);
const int *corner_edges = BKE_mesh_corner_edges(mesh);
const bool loop_normals_needed = r_loopnors != nullptr;
const bool vert_normals_needed = r_vertnors != nullptr || loop_normals_needed;
@ -2281,6 +2282,7 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
edges,
mesh->totedge,
corner_verts,
corner_edges,
r_loopnors,
mesh->totloop,
polys,

8
source/blender/blenkernel/intern/mball_tessellate.cc
View File

@ -1482,11 +1482,11 @@ Mesh *BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob)
mpoly[i].totloop = count;
mpoly[i].flag = ME_SMOOTH;
corner_verts[loop_offset] = uint32_t(indices[0]);
corner_verts[loop_offset + 1] = uint32_t(indices[1]);
corner_verts[loop_offset + 2] = uint32_t(indices[2]);
corner_verts[loop_offset] = indices[0];
corner_verts[loop_offset + 1] = indices[1];
corner_verts[loop_offset + 2] = indices[2];
if (count == 4) {
corner_verts[loop_offset + 3] = uint32_t(indices[3]);
corner_verts[loop_offset + 3] = indices[3];
}
loop_offset += count;

19
source/blender/blenkernel/intern/mesh.cc
View File

@ -471,7 +471,7 @@ static const char *cmpcode_to_str(int code)
/** Thresh is threshold for comparing vertices, UV's, vertex colors, weights, etc. */
static int customdata_compare(
CustomData *c1, CustomData *c2, const int total_length, Mesh *m1, Mesh *m2, const float thresh)
CustomData *c1, CustomData *c2, const int total_length, Mesh *m1, const float thresh)
{
const float thresh_sq = thresh * thresh;
CustomDataLayer *l1, *l2;
@ -715,19 +715,19 @@ const char *BKE_mesh_cmp(Mesh *me1, Mesh *me2, float thresh)
return "Number of loops don't match";
}
if ((c = customdata_compare(&me1->vdata, &me2->vdata, me1->totvert, me1, me2, thresh))) {
if ((c = customdata_compare(&me1->vdata, &me2->vdata, me1->totvert, me1, thresh))) {
return cmpcode_to_str(c);
}
if ((c = customdata_compare(&me1->edata, &me2->edata, me1->totedge, me1, me2, thresh))) {
if ((c = customdata_compare(&me1->edata, &me2->edata, me1->totedge, me1, thresh))) {
return cmpcode_to_str(c);
}
if ((c = customdata_compare(&me1->ldata, &me2->ldata, me1->totloop, me1, me2, thresh))) {
if ((c = customdata_compare(&me1->ldata, &me2->ldata, me1->totloop, me1, thresh))) {
return cmpcode_to_str(c);
}
if ((c = customdata_compare(&me1->pdata, &me2->pdata, me1->totpoly, me1, me2, thresh))) {
if ((c = customdata_compare(&me1->pdata, &me2->pdata, me1->totpoly, me1, thresh))) {
return cmpcode_to_str(c);
}
@ -1481,14 +1481,13 @@ void BKE_mesh_looptri_get_real_edges(const MEdge *edges,
const int corner_1 = tri->tri[i];
const int corner_2 = tri->tri[i_next];
const int vert_1 = corner_verts[corner_1];
const int vert_2 = corner_verts[corner_1];
const int edge_1 = corner_edges[corner_1];
const int edge_2 = corner_edges[corner_1];
const MEdge *e = &edges[edge_1];
const int vert_2 = corner_verts[corner_2];
const int edge = corner_edges[corner_1];
const MEdge *e = &edges[edge];
bool is_real = (vert_1 == e->v1 && vert_2 == e->v2) || (vert_1 == e->v2 && vert_2 == e->v1);
r_edges[i] = is_real ? edge_1 : -1;
r_edges[i] = is_real ? edge : -1;
}
}

2
source/blender/blenkernel/intern/mesh_iterators.cc
View File

@ -309,7 +309,7 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
{
const float(*positions)[3] = BKE_mesh_positions(mesh);
const MPoly *mp = BKE_mesh_polys(mesh);
const Span<int> corner_verts = mesh->corner_verts();
const blender::Span<int> corner_verts = mesh->corner_verts();
const float(*vert_normals)[3] = (flag & MESH_FOREACH_USE_NORMAL) ?
BKE_mesh_vertex_normals_ensure(mesh) :
nullptr;

4
source/blender/blenkernel/intern/mesh_legacy_convert.cc
View File

@ -1657,6 +1657,10 @@ MLoop *BKE_mesh_legacy_convert_corners_to_loops(
void BKE_mesh_legacy_convert_loops_to_corners(Mesh *mesh)
{
using namespace blender;
if (CustomData_get_layer_named(&mesh->ldata, CD_PROP_INT32, ".corner_vert") &&
CustomData_get_layer_named(&mesh->ldata, CD_PROP_INT32, ".corner_edge")) {
return;
}
const Span<MLoop> loops(static_cast<MLoop *>(CustomData_get_layer(&mesh->ldata, CD_MLOOP)),
mesh->totloop);
MutableSpan<int> corner_verts(

12
source/blender/blenkernel/intern/mesh_mapping.cc
View File

@ -397,16 +397,15 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
int *indices = static_cast<int *>(MEM_mallocN(sizeof(int) * size_t(totloop) * 2, __func__));
int *index_step;
const MPoly *mp;
int i;
/* count face users */
for (const int i : IndexRange(totloop)) {
for (const int64_t i : IndexRange(totloop)) {
map[corner_edges[i]].count += 2;
}
/* create offsets */
index_step = indices;
for (i = 0; i < totedge; i++) {
for (int i = 0; i < totedge; i++) {
map[i].indices = index_step;
index_step += map[i].count;
@ -414,11 +413,12 @@ void BKE_mesh_edge_loop_map_create(MeshElemMap **r_map,
map[i].count = 0;
}
int i;
/* assign loop-edge users */
for (i = 0, mp = mpoly; i < totpoly; mp++, i++) {
MeshElemMap *map_ele;
const int max_loop = mp->loopstart + mp->totloop;
int j = mp->loopstart;
for (int j = mp->loopstart; j < max_loop; j++) {
map_ele = &map[corner_edges[j]];
map_ele->indices[map_ele->count++] = j;
@ -1020,8 +1020,8 @@ static bool mesh_check_island_boundary_uv(const MPoly * /*mp*/,
BLI_assert(edge_to_loops->count >= 2 && (edge_to_loops->count % 2) == 0);
const uint v1 = corner_verts[edge_to_loops->indices[0]];
const uint v2 = corner_verts[edge_to_loops->indices[1]];
const int v1 = corner_verts[edge_to_loops->indices[0]];
const int v2 = corner_verts[edge_to_loops->indices[1]];
const float *uvco_v1 = luvs[edge_to_loops->indices[0]].uv;
const float *uvco_v2 = luvs[edge_to_loops->indices[1]].uv;
for (int i = 2; i < edge_to_loops->count; i += 2) {

4
source/blender/blenkernel/intern/mesh_merge.c
View File

@ -464,7 +464,7 @@ Mesh *BKE_mesh_merge_verts(Mesh *mesh,
uint v2 = mlv;
BLI_assert(v1 != v2);
if (BLI_edgehash_ensure_p(ehash, v1, v2, &val_p)) {
last_valid_corner_edge = POINTER_AS_INT(*val_p);
*last_valid_corner_edge = POINTER_AS_INT(*val_p);
}
else {
const int new_eidx = STACK_SIZE(medge);
@ -525,7 +525,7 @@ Mesh *BKE_mesh_merge_verts(Mesh *mesh,
*first_valid_corner_vert;
BLI_assert(v1 != v2);
if (BLI_edgehash_ensure_p(ehash, v1, v2, &val_p)) {
last_valid_corner_edge = POINTER_AS_INT(*val_p);
*last_valid_corner_edge = POINTER_AS_INT(*val_p);
}
else {
const int new_eidx = STACK_SIZE(medge);

1
source/blender/blenkernel/intern/mesh_mirror.cc
View File

@ -346,7 +346,6 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
/* adjust mirrored loop vertex and edge indices */
int *corner_verts = BKE_mesh_corner_verts_for_write(result) + maxLoops;
int *corner_edges = BKE_mesh_corner_edges_for_write(result) + maxLoops;
for (i = 0; i < maxLoops; i++) {
corner_verts[i] += maxVerts;
corner_edges[i] += maxEdges;

2
source/blender/blenkernel/intern/mesh_normals.cc
View File

@ -234,7 +234,7 @@ void BKE_mesh_calc_normals_poly(const float (*positions)[3],
int mpoly_len,
float (*r_poly_normals)[3])
{
calculate_normals_poly({reinterpret_cast<const float3 *>(positions), mpoly_len},
calculate_normals_poly({reinterpret_cast<const float3 *>(positions), verts_num},
{mpoly, mpoly_len},
{corner_verts, mloop_len},
{reinterpret_cast<float3 *>(r_poly_normals), mpoly_len});

8
source/blender/blenkernel/intern/mesh_remesh_voxel.cc
View File

@ -133,10 +133,10 @@ static Mesh *remesh_quadriflow(const Mesh *input_mesh,
const int loopstart = i * 4;
poly.loopstart = loopstart;
poly.totloop = 4;
corner_verts[loopstart] = = qrd.out_faces[loopstart];
corner_verts[loopstart + 1] = = qrd.out_faces[loopstart + 1];
corner_verts[loopstart + 2] = = qrd.out_faces[loopstart + 2];
corner_verts[loopstart + 3] = = qrd.out_faces[loopstart + 3];
corner_verts[loopstart] = qrd.out_faces[loopstart];
corner_verts[loopstart + 1] = qrd.out_faces[loopstart + 1];
corner_verts[loopstart + 2] = qrd.out_faces[loopstart + 2];
corner_verts[loopstart + 3] = qrd.out_faces[loopstart + 3];
}
BKE_mesh_calc_edges(mesh, false, false);

30
source/blender/blenkernel/intern/mesh_tessellate.cc
View File

@ -52,22 +52,22 @@ BLI_INLINE void mesh_calc_tessellation_for_face_impl(const int *corner_verts,
const uint mp_loopstart = uint(mpoly[poly_index].loopstart);
const uint mp_totloop = uint(mpoly[poly_index].totloop);
#define ML_TO_MLT(i1, i2, i3) \
{ \
ARRAY_SET_ITEMS(mlt->tri, mp_loopstart + i1, mp_loopstart + i2, mp_loopstart + i3); \
mlt->poly = poly_index; \
} \
((void)0)
auto create_tri = [&](uint i1, uint i2, uint i3) {
mlt->tri[0] = mp_loopstart + i1;
mlt->tri[1] = mp_loopstart + i2;
mlt->tri[2] = mp_loopstart + i3;
mlt->poly = poly_index;
};
switch (mp_totloop) {
case 3: {
ML_TO_MLT(0, 1, 2);
create_tri(0, 1, 2);
break;
}
case 4: {
ML_TO_MLT(0, 1, 2);
create_tri(0, 1, 2);
MLoopTri *mlt_a = mlt++;
ML_TO_MLT(0, 2, 3);
create_tri(0, 2, 3);
MLoopTri *mlt_b = mlt;
if (UNLIKELY(face_normal ? is_quad_flip_v3_first_third_fast_with_normal(
@ -100,10 +100,9 @@ BLI_INLINE void mesh_calc_tessellation_for_face_impl(const int *corner_verts,
zero_v3(normal);
/* Calc normal, flipped: to get a positive 2D cross product. */
int corner_i = mp_loopstart;
co_prev = positions[corner_verts[mp_totloop - 1]];
for (uint j = 0; j < mp_totloop; j++, corner_i++) {
co_curr = positions[corner_verts[corner_i]];
for (uint j = 0; j < mp_totloop; j++) {
co_curr = positions[corner_verts[mp_loopstart + j]];
add_newell_cross_v3_v3v3(normal, co_prev, co_curr);
co_prev = co_curr;
}
@ -128,9 +127,8 @@ BLI_INLINE void mesh_calc_tessellation_for_face_impl(const int *corner_verts,
float(*projverts)[2] = static_cast<float(*)[2]>(
BLI_memarena_alloc(pf_arena, sizeof(*projverts) * size_t(mp_totloop)));
int corner_i = mp_loopstart;
for (uint j = 0; j < mp_totloop; j++, corner_i++) {
mul_v2_m3v3(projverts[j], axis_mat, positions[corner_verts[corner_i]]);
for (uint j = 0; j < mp_totloop; j++) {
mul_v2_m3v3(projverts[j], axis_mat, positions[corner_verts[mp_loopstart + j]]);
}
BLI_polyfill_calc_arena(projverts, mp_totloop, 1, tris, pf_arena);
@ -138,7 +136,7 @@ BLI_INLINE void mesh_calc_tessellation_for_face_impl(const int *corner_verts,
/* Apply fill. */
for (uint j = 0; j < totfilltri; j++, mlt++) {
const uint *tri = tris[j];
ML_TO_MLT(tri[0], tri[1], tri[2]);
create_tri(tri[0], tri[1], tri[2]);
}
BLI_memarena_clear(pf_arena);

10
source/blender/blenkernel/intern/mesh_validate.cc
View File

@ -615,11 +615,11 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
const int vert_i = corner_verts[sp->loopstart + j];
if (vert_i >= totvert) {
/* Invalid vert idx. */
PRINT_ERR("\tLoop %u has invalid vert reference (%u)", sp->loopstart + j, vert_i);
PRINT_ERR("\tLoop %d has invalid vert reference (%d)", sp->loopstart + j, vert_i);
sp->invalid = true;
}
else if (BLI_BITMAP_TEST(vert_tag, vert_i)) {
PRINT_ERR("\tPoly %u has duplicated vert reference at corner (%u)", i, j);
PRINT_ERR("\tPoly %d has duplicated vert reference at corner (%d)", i, j);
sp->invalid = true;
}
else {
@ -656,7 +656,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
int prev_e = edge_i;
corner_edges[corner_i] = POINTER_AS_INT(BLI_edgehash_lookup(edge_hash, v1, v2));
fix_flag.loops_edge = true;
PRINT_ERR("\tLoop %u has invalid edge reference (%d), fixed using edge %u",
PRINT_ERR("\tLoop %u has invalid edge reference (%d), fixed using edge %d",
corner_i,
prev_e,
corner_edges[corner_i]);
@ -679,14 +679,14 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
fix_flag.loops_edge = true;
PRINT_ERR(
"\tPoly %u has invalid edge reference (%d, is_removed: %d), fixed using edge "
"%u",
"%d",
sp->index,
prev_e,
IS_REMOVED_EDGE(me),
corner_edges[corner_i]);
}
else {
PRINT_ERR("\tPoly %u has invalid edge reference (%u)", sp->index, edge_i);
PRINT_ERR("\tPoly %u has invalid edge reference (%d)", sp->index, edge_i);
sp->invalid = true;
}
}

6
source/blender/blenkernel/intern/multires_reshape_subdivide.c
View File

@ -48,9 +48,9 @@ static void multires_subdivide_create_object_space_linear_grids(Mesh *mesh)
int prev_loop_index = l - 1 >= 0 ? loop_index - 1 : loop_index + poly->totloop - 1;
int next_loop_index = l + 1 < poly->totloop ? loop_index + 1 : poly->loopstart;
const int vert = &corner_verts[loop_index];
const int vert_next = &corner_verts[next_loop_index];
const int vert_prev = &corner_verts[prev_loop_index];
const int vert = corner_verts[loop_index];
const int vert_next = corner_verts[next_loop_index];
const int vert_prev = corner_verts[prev_loop_index];
copy_v3_v3(disps[0], poly_center);
mid_v3_v3v3(disps[1], positions[vert], positions[vert_next]);

1
source/blender/blenkernel/intern/pbvh.c
View File

@ -667,6 +667,7 @@ static void pbvh_draw_args_init(PBVH *pbvh, PBVH_GPU_Args *args, PBVHNode *node)
args->face_sets_color_seed = pbvh->face_sets_color_seed;
args->mesh_positions = pbvh->mesh_positions;
args->corner_verts = pbvh->corner_verts;
args->corner_edges = pbvh->mesh ? BKE_mesh_corner_edges(pbvh->mesh) : NULL;
args->mpoly = pbvh->mpoly;
args->mlooptri = pbvh->looptri;

4
source/blender/blenkernel/intern/subdiv_foreach.c
View File

@ -162,8 +162,6 @@ static void subdiv_foreach_ctx_count(SubdivForeachTaskContext *ctx)
const int num_inner_vertices_per_noquad_patch = (no_quad_patch_resolution - 2) *
(no_quad_patch_resolution - 2);
const Mesh *coarse_mesh = ctx->coarse_mesh;
const MPoly *coarse_mpoly = BKE_mesh_polys(coarse_mesh);
const int *coarse_corner_edges = BKE_mesh_corner_edges(coarse_mesh);
ctx->num_subdiv_vertices = coarse_mesh->totvert;
ctx->num_subdiv_edges = coarse_mesh->totedge * (num_subdiv_vertices_per_coarse_edge + 1);
/* Calculate extra vertices and edges created by non-loose geometry. */
@ -171,7 +169,7 @@ static void subdiv_foreach_ctx_count(SubdivForeachTaskContext *ctx)
const MPoly *coarse_poly = &ctx->coarse_polys[poly_index];
const int num_ptex_faces_per_poly = num_ptex_faces_per_poly_get(coarse_poly);
for (int corner = 0; corner < coarse_poly->totloop; corner++) {
const int coarse_edge_i = coarse_corner_edges[coarse_poly->loopstart + corner];
const int coarse_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const bool is_edge_used = BLI_BITMAP_TEST_BOOL(ctx->coarse_edges_used_map, coarse_edge_i);
/* Edges which aren't counted yet. */
if (!is_edge_used) {

5
source/blender/blenloader/intern/versioning_290.c
View File

@ -50,6 +50,7 @@
#include "BKE_lib_id.h"
#include "BKE_main.h"
#include "BKE_mesh.h"
#include "BKE_mesh_legacy_convert.h"
#include "BKE_multires.h"
#include "BKE_node.h"
@ -821,6 +822,7 @@ void blo_do_versions_290(FileData *fd, Library *UNUSED(lib), Main *bmain)
for (const MPoly *mp = BKE_mesh_polys(me), *mp_end = mp + me->totpoly; mp < mp_end; mp++) {
if (mp->totloop == 2) {
bool changed;
BKE_mesh_legacy_convert_loops_to_corners(me);
BKE_mesh_validate_arrays(me,
BKE_mesh_positions_for_write(me),
me->totvert,
@ -828,7 +830,8 @@ void blo_do_versions_290(FileData *fd, Library *UNUSED(lib), Main *bmain)
me->totedge,
(MFace *)CustomData_get_layer(&me->fdata, CD_MFACE),
me->totface,
BKE_mesh_loops_for_write(me),
BKE_mesh_corner_verts_for_write(me),
BKE_mesh_corner_edges_for_write(me),
me->totloop,
BKE_mesh_polys_for_write(me),
me->totpoly,

1
source/blender/draw/DRW_pbvh.h
View File

@ -41,6 +41,7 @@ typedef struct PBVH_GPU_Args {
const struct Mesh *me;
const float (*mesh_positions)[3];
const int *corner_verts;
const int *corner_edges;
const struct MPoly *mpoly;
int mesh_verts_num, mesh_faces_num, mesh_grids_num;
struct CustomData *vdata, *ldata, *pdata;

1
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc
View File

@ -39,7 +39,6 @@ static void extract_sculpt_data_init(const MeshRenderData *mr,
GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
GPUVertFormat *format = get_sculpt_data_format();
CustomData *cd_ldata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->ldata : &mr->me->ldata;
CustomData *cd_vdata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->vdata : &mr->me->vdata;
CustomData *cd_pdata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->pdata : &mr->me->pdata;

10
source/blender/editors/sculpt_paint/curves_sculpt_puff.cc
View File

@ -71,7 +71,7 @@ struct PuffOperationExecutor {
Object *surface_ob_ = nullptr;
Mesh *surface_ = nullptr;
Span<float3> surface_positions_;
Span<int> surface_loops_;
Span<int> surface_corner_verts_;
Span<MLoopTri> surface_looptris_;
Span<float3> corner_normals_su_;
BVHTreeFromMesh surface_bvh_;
@ -120,7 +120,7 @@ struct PuffOperationExecutor {
surface_->totloop};
surface_positions_ = surface_->positions();
surface_loops_ = surface_->loops();
surface_corner_verts_ = surface_->corner_verts();
surface_looptris_ = surface_->looptris();
BKE_bvhtree_from_mesh_get(&surface_bvh_, surface_, BVHTREE_FROM_LOOPTRI, 2);
BLI_SCOPED_DEFER([&]() { free_bvhtree_from_mesh(&surface_bvh_); });
@ -291,9 +291,9 @@ struct PuffOperationExecutor {
const MLoopTri &looptri = surface_looptris_[nearest.index];
const float3 closest_pos_su = nearest.co;
const float3 &v0_su = surface_positions_[surface_loops_[looptri.tri[0]].v];
const float3 &v1_su = surface_positions_[surface_loops_[looptri.tri[1]].v];
const float3 &v2_su = surface_positions_[surface_loops_[looptri.tri[2]].v];
const float3 &v0_su = surface_positions_[surface_corner_verts_[looptri.tri[0]]];
const float3 &v1_su = surface_positions_[surface_corner_verts_[looptri.tri[1]]];
const float3 &v2_su = surface_positions_[surface_corner_verts_[looptri.tri[2]]];
float3 bary_coords;
interp_weights_tri_v3(bary_coords, v0_su, v1_su, v2_su, closest_pos_su);
const float3 normal_su = geometry::compute_surface_point_normal(

4
source/blender/editors/sculpt_paint/paint_vertex.cc
View File

@ -3341,7 +3341,7 @@ static void do_vpaint_brush_smear(bContext *C,
UNUSED_VARS_NDEBUG(l_index);
const MPoly *mp = &ss->mpoly[p_index];
if (!use_face_sel || select_poly[p_index]) {
for (int k = 0; k < mp->totloop; k++, ml_other++) {
for (int k = 0; k < mp->totloop; k++) {
const int other_corner_i = mp->loopstart + k;
const int v_other_index = ss->corner_verts[other_corner_i];
if (v_other_index != v_index) {
@ -3359,7 +3359,7 @@ static void do_vpaint_brush_smear(bContext *C,
int elem_index;
if constexpr (domain == ATTR_DOMAIN_POINT) {
elem_index = ml_other->v;
elem_index = v_other_index;
}
else {
elem_index = mp->loopstart + k;

6
source/blender/editors/sculpt_paint/sculpt_expand.c
View File

@ -150,7 +150,7 @@ static bool sculpt_expand_is_face_in_active_component(SculptSession *ss,
ExpandCache *expand_cache,
const int f)
{
const int vert_i = &ss->corner_verts[ss->mpoly[f].loopstart];
const int vert_i = ss->corner_verts[ss->mpoly[f].loopstart];
return sculpt_expand_is_vert_in_active_component(ss, expand_cache, BKE_pbvh_make_vref(vert_i));
}
@ -1090,7 +1090,7 @@ static void sculpt_expand_snap_initialize_from_enabled(SculptSession *ss,
const MPoly *poly = &ss->mpoly[p];
bool any_disabled = false;
for (int l = 0; l < poly->totloop; l++) {
const int vert_i = &ss->corner_verts[l + poly->loopstart];
const int vert_i = ss->corner_verts[l + poly->loopstart];
if (!BLI_BITMAP_TEST(enabled_verts, vert_i)) {
any_disabled = true;
break;
@ -1976,7 +1976,7 @@ static void sculpt_expand_delete_face_set_id(int *r_face_sets,
int other_id = delete_id;
const MPoly *c_poly = &polys[f_index];
for (int l = 0; l < c_poly->totloop; l++) {
const int vert_i = &corner_verts[c_poly->loopstart + l];
const int vert_i = corner_verts[c_poly->loopstart + l];
const MeshElemMap *vert_map = &pmap[vert_i];
for (int i = 0; i < vert_map->count; i++) {

4
source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc
View File

@ -210,8 +210,8 @@ std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values(
VArray<int>::ForSpan(mesh->corner_verts()));
}
if (STREQ(column_id.name, "Edge")) {
return std::make_unique<ColumnValues>(
column_id.name, VArray<int>::ForSpan(mesh->corner_edges());
return std::make_unique<ColumnValues>(column_id.name,
VArray<int>::ForSpan(mesh->corner_edges()));
}
}
}

2
source/blender/io/usd/intern/usd_writer_mesh.cc
View File

@ -429,7 +429,7 @@ void USDGenericMeshWriter::write_normals(const Mesh *mesh, pxr::UsdGeomMesh usd_
else {
/* Smooth shaded, use individual vert normals. */
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
loop_normals.push_back(pxr::GfVec3f(vert_normals[corner_verts]));
loop_normals.push_back(pxr::GfVec3f(vert_normals[vert_i]));
}
}
}

2
source/blender/makesrna/intern/rna_mesh.c
View File

@ -579,7 +579,7 @@ static int rna_MeshLoop_edge_index_get(PointerRNA *ptr)
static void rna_MeshLoop_edge_index_set(PointerRNA *ptr, int value)
{
const Mesh *me = rna_mesh(ptr);
Mesh *me = rna_mesh(ptr);
const int index = rna_MeshLoop_index_get(ptr);
BKE_mesh_corner_edges_for_write(me)[index] = value;
}

49
source/blender/modifiers/intern/MOD_screw.c
View File

@ -240,8 +240,6 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
uint edge_offset;
MPoly *mp_new;
int *corner_verts_new;
int *corner_edges_new;
MEdge *med_new, *med_new_firstloop;
Object *ob_axis = ltmd->ob_axis;
@ -391,8 +389,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
float(*positions_new)[3] = BKE_mesh_positions_for_write(result);
MEdge *medge_new = BKE_mesh_edges_for_write(result);
MPoly *mpoly_new = BKE_mesh_polys_for_write(result);
int *corner_verts_orig = BKE_mesh_corner_verts_for_write(result);
int *corner_edges_orig = BKE_mesh_corner_edges_for_write(result);
int *corner_verts_new = BKE_mesh_corner_verts_for_write(result);
int *corner_edges_new = BKE_mesh_corner_edges_for_write(result);
if (!CustomData_has_layer(&result->pdata, CD_ORIGINDEX)) {
CustomData_add_layer(&result->pdata, CD_ORIGINDEX, CD_SET_DEFAULT, NULL, (int)maxPolys);
@ -454,8 +452,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
uint k;
for (k = loopstart; k < loopend; k++) {
const int vert_i = corner_verts_orig[loopstart + k];
const int edge_i = corner_edges_orig[loopstart + k];
const uint vert_i = (uint)corner_verts_orig[loopstart + k];
const uint edge_i = (uint)corner_edges_orig[loopstart + k];
edge_poly_map[edge_i] = i;
vert_loop_map[vert_i] = k;
@ -930,18 +928,18 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
/* Loop-Data */
if (!(close && step == step_last)) {
/* regular segments */
corner_verts_new[dst_corner_i + quad_ord[0]] = i1;
corner_verts_new[dst_corner_i + quad_ord[0]] = i1;
corner_verts_new[dst_corner_i + quad_ord[1]] = i2;
corner_verts_new[dst_corner_i + quad_ord[2]] = i2 + totvert;
corner_verts_new[dst_corner_i + quad_ord[3]] = i1 + totvert;
corner_verts_new[dst_corner_i + quad_ord[0]] = (int)i1;
corner_verts_new[dst_corner_i + quad_ord[0]] = (int)i1;
corner_verts_new[dst_corner_i + quad_ord[1]] = (int)i2;
corner_verts_new[dst_corner_i + quad_ord[2]] = (int)(i2 + totvert);
corner_verts_new[dst_corner_i + quad_ord[3]] = (int)(i1 + totvert);
corner_edges_new[dst_corner_i + quad_ord_ofs[0]] =
step == 0 ? i : (edge_offset + step + (i * (step_tot - 1))) - 1;
corner_edges_new[dst_corner_i + quad_ord_ofs[1]] = totedge + i2;
corner_edges_new[dst_corner_i + quad_ord_ofs[2]] = edge_offset + step +
(i * (step_tot - 1));
corner_edges_new[dst_corner_i + quad_ord_ofs[3]] = totedge + i1;
(int)(step == 0 ? i : (edge_offset + step + (i * (step_tot - 1))) - 1);
corner_edges_new[dst_corner_i + quad_ord_ofs[1]] = (int)(totedge + i2);
corner_edges_new[dst_corner_i + quad_ord_ofs[2]] = (int)(edge_offset + step +
(i * (step_tot - 1)));
corner_edges_new[dst_corner_i + quad_ord_ofs[3]] = (int)(totedge + i1);
/* new vertical edge */
if (step) { /* The first set is already done */
@ -955,17 +953,16 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
}
else {
/* last segment */
corner_verts_new[dst_corner_i + quad_ord[0]] = i1;
corner_verts_new[dst_corner_i + quad_ord[1]] = i2;
corner_verts_new[dst_corner_i + quad_ord[2]] = med_new_firstloop->v2;
corner_verts_new[dst_corner_i + quad_ord[3]] = med_new_firstloop->v1;
corner_verts_new[dst_corner_i + quad_ord[0]] = (int)i1;
corner_verts_new[dst_corner_i + quad_ord[1]] = (int)i2;
corner_verts_new[dst_corner_i + quad_ord[2]] = (int)med_new_firstloop->v2;
corner_verts_new[dst_corner_i + quad_ord[3]] = (int)med_new_firstloop->v1;
corner_edges_new[dst_corner_i + quad_ord_ofs[0]] = (edge_offset + step +
(i * (step_tot - 1))) -
1;
corner_edges_new[dst_corner_i + quad_ord_ofs[1]] = totedge + i2;
corner_edges_new[dst_corner_i + quad_ord_ofs[2]] = i;
corner_edges_new[dst_corner_i + quad_ord_ofs[3]] = totedge + i1;
corner_edges_new[dst_corner_i + quad_ord_ofs[0]] =
(int)((edge_offset + step + (i * (step_tot - 1))) - 1);
corner_edges_new[dst_corner_i + quad_ord_ofs[1]] = (int)(totedge + i2);
corner_edges_new[dst_corner_i + quad_ord_ofs[2]] = (int)i;
corner_edges_new[dst_corner_i + quad_ord_ofs[3]] = (int)(totedge + i1);
}
mp_new++;

8
source/blender/modifiers/intern/MOD_solidify_extrude.c
View File

@ -24,10 +24,6 @@
#include "MOD_solidify_util.h" /* own include */
#include "MOD_util.h"
#ifdef __GNUC__
# pragma GCC diagnostic error "-Wsign-conversion"
#endif
/* -------------------------------------------------------------------- */
/** \name High Quality Normal Calculation Function
* \{ */
@ -265,7 +261,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
const int vert_i = orig_corner_verts[corner_i];
const int prev_vert_i = orig_corner_verts[corner_i_prev];
/* add edge user */
eidx = orig_corner_edges[corner_i_prev];
eidx = (int)(orig_corner_edges[corner_i_prev]);
if (edge_users[eidx] == INVALID_UNUSED) {
ed = orig_medge + eidx;
BLI_assert(ELEM(prev_vert_i, ed->v1, ed->v2) && ELEM(vert_i, ed->v1, ed->v2));
@ -530,7 +526,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
const int vert_i = orig_corner_verts[corner_i];
const int prev_vert_i = orig_corner_verts[prev_corner_i];
/* add edge user */
eidx = orig_corner_edges[prev_corner_i];
eidx = (int)orig_corner_edges[prev_corner_i];
const MEdge *ed = orig_medge + eidx;
BLI_assert(ELEM(prev_vert_i, ed->v1, ed->v2) && ELEM(vert_i, ed->v1, ed->v2));
char flip = (char)((prev_vert_i > vert_i) == (ed->v1 < ed->v2));

8
source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
View File

@ -22,10 +22,6 @@
#include "MOD_solidify_util.h" /* Own include. */
#include "MOD_util.h"
#ifdef __GNUC__
# pragma GCC diagnostic error "-Wsign-conversion"
#endif
/* -------------------------------------------------------------------- */
/** \name Local Utilities
* \{ */
@ -2531,8 +2527,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
valid_edges++;
const uint flip = (uint)(vm[orig_medge[new_edge->old_edge].v2] ==
vm[orig_corner_verts[loopstart + j]]);
BLI_assert(flip ||
vm[orig_medge[new_edge->old_edge].v1] == vm[orig_corner_verts[loopstart + j]]);
BLI_assert(flip || vm[orig_medge[new_edge->old_edge].v1] ==
vm[orig_corner_verts[loopstart + j]]);
/* The vert that's in the current loop. */
const uint new_v1 = new_edge->link_edge_groups[flip]->new_vert;
/* The vert that's in the next loop. */

16
source/blender/modifiers/intern/MOD_surfacedeform.c
View File

@ -290,15 +290,15 @@ static int buildAdjacencyMap(const MPoly *poly,
/* Find polygons adjacent to edges. */
for (int i = 0; i < polys_num; i++, poly++) {
for (int j = 0; j < poly->totloop; j++) {
const int edge = corner_edges[poly->loopstart + j];
if (edge_polys[edge].num == 0) {
edge_polys[edge].polys[0] = i;
edge_polys[edge].polys[1] = -1;
edge_polys[edge].num++;
const int edge_i = corner_edges[poly->loopstart + j];
if (edge_polys[edge_i].num == 0) {
edge_polys[edge_i].polys[0] = i;
edge_polys[edge_i].polys[1] = -1;
edge_polys[edge_i].num++;
}
else if (edge_polys[edge].num == 1) {
edge_polys[edge].polys[1] = i;
edge_polys[edge].num++;
else if (edge_polys[edge_i].num == 1) {
edge_polys[edge_i].polys[1] = i;
edge_polys[edge_i].num++;
}
else {
return MOD_SDEF_BIND_RESULT_NONMANY_ERR;

4
source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
View File

@ -125,8 +125,8 @@ static Mesh *hull_from_bullet(const Mesh *mesh, Span<float3> coords)
face.loopstart = j;
face.totloop = len;
for (const int k : IndexRange(len)) {
mesh_corner_verts[dst_corner_i] = src_corner_verts[loops[k]];
mesh_corner_edges[dst_corner_i] = src_corner_edges[loops[k]];
mesh_corner_verts[dst_corner_i] = mesh_corner_verts[loops[k]];
mesh_corner_edges[dst_corner_i] = mesh_corner_edges[loops[k]];
dst_corner_i++;
}
j += len;

10
source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
View File

@ -222,7 +222,7 @@ static void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
dst_poly_verts.copy_from(src_poly_verts);
for (const int i : IndexRange(size)) {
dst_poly_edges[i] = edge_map[dst_poly_edges[i]];
dst_poly_edges[i] = edge_map[src_poly_edges[i]];
}
}
}
@ -286,10 +286,10 @@ static void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
MutableSpan<int> dst_poly_edges = dst_corner_edges.slice(mp_dst.loopstart, size);
for (const int i : IndexRange(size)) {
dst_poly_verts[i] = vertex_map[dst_poly_verts[i]];
dst_poly_verts[i] = vertex_map[src_poly_verts[i]];
}
for (const int i : IndexRange(size)) {
dst_poly_edges[i] = edge_map[dst_poly_edges[i]];
dst_poly_edges[i] = edge_map[src_poly_edges[i]];
}
}
}
@ -781,8 +781,8 @@ static void compute_selected_mesh_data_from_poly_selection(const Mesh &mesh,
/* Add the vertices and the edges. */
for (const int corner : IndexRange(poly_src.loopstart, poly_src.totloop)) {
const int vert_i= corner_verts[corner];
const int edge_i= corner_edges[corner];
const int vert_i = corner_verts[corner];
const int edge_i = corner_edges[corner];
/* Check first if it has not yet been added. */
if (r_vertex_map[vert_i] == -1) {
r_vertex_map[vert_i] = selected_verts_num;

22
source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc
View File

@ -559,13 +559,14 @@ static void extrude_mesh_edges(Mesh &mesh,
* polygons that share an edge with the extruded edge. */
for (const int i_connected_poly : connected_polys.index_range()) {
const MPoly &connected_poly = polys[connected_polys[i_connected_poly]];
for (const int vert_i :
corner_verts.slice(connected_poly.loopstart, connected_poly.totloop)) {
for (const int corner_i :
IndexRange(connected_poly.loopstart, connected_poly.totloop)) {
const int vert_i = corner_verts[corner_i];
if (vert_i == orig_vert_1) {
mixer.mix_in(0, data[i_loop]);
mixer.mix_in(0, data[corner_i]);
}
if (vert_i == orig_vert_2) {
mixer.mix_in(1, data[i_loop]);
mixer.mix_in(1, data[corner_i]);
}
}
}
@ -576,10 +577,10 @@ static void extrude_mesh_edges(Mesh &mesh,
* simpler (though probably slower) to just match the corner data based on the vertex
* indices. */
for (const int i : IndexRange(4 * i_edge_selection, 4)) {
if (ELEM(new_loops[i].v, new_vert_1, orig_vert_1)) {
if (ELEM(new_corner_verts[i], new_vert_1, orig_vert_1)) {
new_data[i] = side_poly_corner_data.first();
}
else if (ELEM(new_loops[i].v, new_vert_2, orig_vert_2)) {
else if (ELEM(new_corner_verts[i], new_vert_2, orig_vert_2)) {
new_data[i] = side_poly_corner_data.last();
}
}
@ -943,10 +944,10 @@ static void extrude_mesh_face_regions(Mesh &mesh,
T data_1;
T data_2;
for (const int i_loop : IndexRange(poly.loopstart, poly.totloop)) {
if (loops[i_loop].v == new_vert_1) {
if (corner_verts[i_loop] == new_vert_1) {
data_1 = data[i_loop];
}
if (loops[i_loop].v == new_vert_2) {
if (corner_verts[i_loop] == new_vert_2) {
data_2 = data[i_loop];
}
}
@ -955,10 +956,10 @@ static void extrude_mesh_face_regions(Mesh &mesh,
* simpler (though probably slower) to just match the corner data based on the
* vertex indices. */
for (const int i : IndexRange(4 * i_boundary_edge, 4)) {
if (ELEM(new_loops[i].v, new_vert_1, orig_vert_1)) {
if (ELEM(new_corner_verts[i], new_vert_1, orig_vert_1)) {
new_data[i] = data_1;
}
else if (ELEM(new_loops[i].v, new_vert_2, orig_vert_2)) {
else if (ELEM(new_corner_verts[i], new_vert_2, orig_vert_2)) {
new_data[i] = data_2;
}
}
@ -1295,7 +1296,6 @@ static void extrude_individual_mesh_faces(Mesh &mesh,
MutableSpan<int> poly_edges = corner_edges.slice(poly.loopstart, poly.totloop);
for (const int i : IndexRange(poly.totloop)) {
const int corner_i = poly.loopstart + i;
poly_verts[i] = new_vert_range[poly_corner_range[i]];
poly_edges[i] = duplicate_edge_range[poly_corner_range[i]];
}

2
source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc
View File

@ -82,7 +82,7 @@ static VArray<float3> construct_uv_gvarray(const Mesh &mesh,
edge_evaluator.evaluate();
const IndexMask seam = edge_evaluator.get_evaluated_as_mask(0);
Array<float3> uv(loops.size(), float3(0));
Array<float3> uv(corner_verts.size(), float3(0));
ParamHandle *handle = GEO_uv_parametrizer_construct_begin();
for (const int mp_index : selection) {

6
source/blender/python/mathutils/mathutils_bvhtree.c
View File

@ -1173,9 +1173,9 @@ static PyObject *C_BVHTree_FromObject(PyObject *UNUSED(cls), PyObject *args, PyO
for (i = 0; i < tris_len; i++, lt++) {
float co[3][3];
tris[i][0] = corner_verts[lt->tri[0]];
tris[i][1] = corner_verts[lt->tri[1]];
tris[i][2] = corner_verts[lt->tri[2]];
tris[i][0] = (uint)corner_verts[lt->tri[0]];
tris[i][1] = (uint)corner_verts[lt->tri[1]];
tris[i][2] = (uint)corner_verts[lt->tri[2]];
copy_v3_v3(co[0], coords[tris[i][0]]);
copy_v3_v3(co[1], coords[tris[i][1]]);