Fix T42630: Triangulate returns invalid face-map

Triangulate with beautify caused a bug when there were existing edges
could make the bmesh-operator return an invalid face-map.

Now the beauty is calculated on the 2d-tri's resulting from polyfill,
its simpler and faster.
This commit is contained in:
Campbell Barton 2014-12-08 16:57:39 +01:00
parent 6076bedec0
commit a5c3de2e49
6 changed files with 585 additions and 78 deletions

@ -0,0 +1,39 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef __BLI_POLYFILL2D_BEAUTIFY_H__
#define __BLI_POLYFILL2D_BEAUTIFY_H__
struct EdgeHash;
struct Heap;
struct MemArena;
void BLI_polyfill_beautify(
const float (*coords)[2],
const unsigned int coords_tot,
unsigned int (*tris)[3],
/* structs for reuse */
struct MemArena *arena, struct Heap *eheap, struct EdgeHash *eh);
/* avoid realloc's when creating new structures for polyfill ngons */
#define BLI_POLYFILL_ALLOC_NGON_RESERVE 64
#endif /* __BLI_POLYFILL2D_BEAUTIFY_H__ */

@ -85,6 +85,7 @@ set(SRC
intern/noise.c intern/noise.c
intern/path_util.c intern/path_util.c
intern/polyfill2d.c intern/polyfill2d.c
intern/polyfill2d_beautify.c
intern/quadric.c intern/quadric.c
intern/rand.c intern/rand.c
intern/rct.c intern/rct.c
@ -161,6 +162,7 @@ set(SRC
BLI_noise.h BLI_noise.h
BLI_path_util.h BLI_path_util.h
BLI_polyfill2d.h BLI_polyfill2d.h
BLI_polyfill2d_beautify.h
BLI_quadric.h BLI_quadric.h
BLI_rand.h BLI_rand.h
BLI_rect.h BLI_rect.h

@ -0,0 +1,498 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/blenlib/intern/polyfill2d_beautify.c
* \ingroup bli
*
* This function is to improve the tessellation resulting from polyfill2d,
* creating optimal topology.
*
* The functionality here matches #BM_mesh_beautify_fill,
* but its far simpler to perform this operation in 2d,
* on a simple polygon representation where we _know_:
*
* - The polygon is primitive with no holes with a continuous boundary.
* - Tris have consistent winding.
* - 2d (saves some hassles projecting face pairs on an axis for every edge-rotation)
* also saves us having to store all previous edge-states (see #EdRotState in bmesh_beautify.c)
*
* \note
*
* No globals - keep threadsafe.
*/
#include "BLI_utildefines.h"
#include "BLI_math.h"
#include "BLI_memarena.h"
#include "BLI_edgehash.h"
#include "BLI_heap.h"
#include "BLI_polyfill2d_beautify.h" /* own include */
#include "BLI_strict_flags.h"
struct PolyEdge {
/** ordered vert indices (smaller first) */
unsigned int verts[2];
/** ordered face indices (depends on winding compared to the edge verts)
* - (verts[0], verts[1]) == faces[0]
* - (verts[1], verts[0]) == faces[1]
*/
unsigned int faces[2];
/**
* The face-index which isn't used by either of the edges verts [0 - 2].
* could be calculated each time, but cleaner to store for reuse.
*/
unsigned int faces_other_v[2];
};
#ifndef NDEBUG
/**
* Only to check for error-cases.
*/
static void polyfill_validate_tri(unsigned int (*tris)[3], unsigned int tri_index, EdgeHash *ehash)
{
const unsigned int *tri = tris[tri_index];
int j_curr;
BLI_assert(!ELEM(tri[0], tri[1], tri[2]) &&
!ELEM(tri[1], tri[0], tri[2]) &&
!ELEM(tri[2], tri[0], tri[1]));
for (j_curr = 0; j_curr < 3; j_curr++) {
struct PolyEdge *e;
unsigned int e_v1 = tri[(j_curr ) ];
unsigned int e_v2 = tri[(j_curr + 1) % 3];
e = BLI_edgehash_lookup(ehash, e_v1, e_v2);
if (e) {
if (e->faces[0] == tri_index) {
BLI_assert(e->verts[0] == e_v1);
BLI_assert(e->verts[1] == e_v2);
}
else if (e->faces[1] == tri_index) {
BLI_assert(e->verts[0] == e_v2);
BLI_assert(e->verts[1] == e_v1);
}
else {
BLI_assert(0);
}
BLI_assert(e->faces[0] != e->faces[1]);
BLI_assert(ELEM(e_v1, UNPACK3(tri)));
BLI_assert(ELEM(e_v2, UNPACK3(tri)));
BLI_assert(ELEM(e_v1, UNPACK2(e->verts)));
BLI_assert(ELEM(e_v2, UNPACK2(e->verts)));
BLI_assert(e_v1 != tris[e->faces[0]][e->faces_other_v[0]]);
BLI_assert(e_v1 != tris[e->faces[1]][e->faces_other_v[1]]);
BLI_assert(e_v2 != tris[e->faces[0]][e->faces_other_v[0]]);
BLI_assert(e_v2 != tris[e->faces[1]][e->faces_other_v[1]]);
BLI_assert(ELEM(tri_index, UNPACK2(e->faces)));
}
}
}
#endif
BLI_INLINE bool is_boundary_edge(unsigned int i_a, unsigned int i_b, const unsigned int coord_last)
{
BLI_assert(i_a < i_b);
return ((i_a + 1 == i_b) || UNLIKELY((i_a == 0) && (i_b == coord_last)));
}
/**
* Assuming we have 2 triangles sharing an edge (2 - 4),
* check if the edge running from (1 - 3) gives better results
* (negative number, lager == better).
*/
static float quad_v2_rotate_beauty_calc(
const float v1[2], const float v2[2], const float v3[2], const float v4[2])
{
/* not a loop (only to be able to break out) */
do {
bool is_zero_a, is_zero_b;
const float area_2x_234 = cross_tri_v2(v2, v3, v4);
const float area_2x_241 = cross_tri_v2(v2, v4, v1);
const float area_2x_123 = cross_tri_v2(v1, v2, v3);
const float area_2x_134 = cross_tri_v2(v1, v3, v4);
{
BLI_assert((ELEM(v1, v2, v3, v4) == false) &&
(ELEM(v2, v1, v3, v4) == false) &&
(ELEM(v3, v1, v2, v4) == false) &&
(ELEM(v4, v1, v2, v3) == false));
is_zero_a = (fabsf(area_2x_234) <= FLT_EPSILON);
is_zero_b = (fabsf(area_2x_241) <= FLT_EPSILON);
if (is_zero_a && is_zero_b) {
break;
}
}
if (is_zero_a == false && is_zero_b == false) {
/* both tri's are valid, check we make a concave quad */
if (!is_quad_convex_v2(v1, v2, v3, v4)) {
break;
}
}
else {
/* one of the tri's was degenerate, chech we're not rotating
* into a different degenerate shape or flipping the face */
if ((fabsf(area_2x_123) <= FLT_EPSILON) || (fabsf(area_2x_134) <= FLT_EPSILON)) {
/* one of the new rotations is degenerate */
break;
}
if ((area_2x_123 >= 0.0f) != (area_2x_134 >= 0.0f)) {
/* rotation would cause flipping */
break;
}
}
{
/* testing rule: the area divided by the perimeter,
* check if (1-3) beats the existing (2-4) edge rotation */
float area_a, area_b;
float prim_a, prim_b;
float fac_24, fac_13;
float len_12, len_23, len_34, len_41, len_24, len_13;
#define AREA_FROM_CROSS(f) (fabsf(f) / 2.0f)
/* edges around the quad */
len_12 = len_v2v2(v1, v2);
len_23 = len_v2v2(v2, v3);
len_34 = len_v2v2(v3, v4);
len_41 = len_v2v2(v4, v1);
/* edges crossing the quad interior */
len_13 = len_v2v2(v1, v3);
len_24 = len_v2v2(v2, v4);
/* edge (2-4), current state */
area_a = AREA_FROM_CROSS(area_2x_234);
area_b = AREA_FROM_CROSS(area_2x_241);
prim_a = len_23 + len_34 + len_24;
prim_b = len_24 + len_41 + len_12;
fac_24 = (area_a / prim_a) + (area_b / prim_b);
/* edge (1-3), new state */
area_a = AREA_FROM_CROSS(area_2x_123);
area_b = AREA_FROM_CROSS(area_2x_134);
prim_a = len_12 + len_23 + len_13;
prim_b = len_34 + len_41 + len_13;
fac_13 = (area_a / prim_a) + (area_b / prim_b);
#undef AREA_FROM_CROSS
/* negative number if (1-3) is an improved state */
return fac_24 - fac_13;
}
} while (false);
return FLT_MAX;
}
static float polyedge_rotate_beauty_calc(
const float (*coords)[2],
const unsigned int (*tris)[3],
const struct PolyEdge *e)
{
const float *v1, *v2, *v3, *v4;
v1 = coords[tris[e->faces[0]][e->faces_other_v[0]]];
v3 = coords[tris[e->faces[1]][e->faces_other_v[1]]];
v2 = coords[e->verts[0]];
v4 = coords[e->verts[1]];
return quad_v2_rotate_beauty_calc(v1, v2, v3, v4);
}
static void polyedge_beauty_cost_update_single(
const float (*coords)[2],
const unsigned int (*tris)[3],
const struct PolyEdge *edges,
struct PolyEdge *e,
Heap *eheap, HeapNode **eheap_table)
{
const unsigned int i = (unsigned int)(e - edges);
if (eheap_table[i]) {
BLI_heap_remove(eheap, eheap_table[i]);
eheap_table[i] = NULL;
}
{
/* recalculate edge */
const float cost = polyedge_rotate_beauty_calc(coords, tris, e);
if (cost < 0.0f) {
eheap_table[i] = BLI_heap_insert(eheap, cost, e);
}
else {
eheap_table[i] = NULL;
}
}
}
static void polyedge_beauty_cost_update(
const float (*coords)[2],
const unsigned int (*tris)[3],
const struct PolyEdge *edges,
struct PolyEdge *e,
Heap *eheap, HeapNode **eheap_table,
EdgeHash *ehash)
{
const unsigned int *tri_0 = tris[e->faces[0]];
const unsigned int *tri_1 = tris[e->faces[1]];
unsigned int i;
struct PolyEdge *e_arr[4] = {
BLI_edgehash_lookup(ehash,
tri_0[(e->faces_other_v[0] ) % 3],
tri_0[(e->faces_other_v[0] + 1) % 3]),
BLI_edgehash_lookup(ehash,
tri_0[(e->faces_other_v[0] + 2) % 3],
tri_0[(e->faces_other_v[0] ) % 3]),
BLI_edgehash_lookup(ehash,
tri_1[(e->faces_other_v[1] ) % 3],
tri_1[(e->faces_other_v[1] + 1) % 3]),
BLI_edgehash_lookup(ehash,
tri_1[(e->faces_other_v[1] + 2) % 3],
tri_1[(e->faces_other_v[1] ) % 3]),
};
for (i = 0; i < 4; i++) {
if (e_arr[i]) {
BLI_assert(!(ELEM(e_arr[i]->faces[0], UNPACK2(e->faces)) &&
ELEM(e_arr[i]->faces[1], UNPACK2(e->faces))));
polyedge_beauty_cost_update_single(
coords, tris, edges,
e_arr[i],
eheap, eheap_table);
}
}
}
static void polyedge_rotate(
unsigned int (*tris)[3],
struct PolyEdge *e,
EdgeHash *ehash)
{
unsigned int e_v1_new = tris[e->faces[0]][e->faces_other_v[0]];
unsigned int e_v2_new = tris[e->faces[1]][e->faces_other_v[1]];
#ifndef NDEBUG
polyfill_validate_tri(tris, e->faces[0], ehash);
polyfill_validate_tri(tris, e->faces[1], ehash);
#endif
BLI_assert(e_v1_new != e_v2_new);
BLI_assert(!ELEM(e_v2_new, UNPACK3(tris[e->faces[0]])));
BLI_assert(!ELEM(e_v1_new, UNPACK3(tris[e->faces[1]])));
tris[e->faces[0]][(e->faces_other_v[0] + 1) % 3] = e_v2_new;
tris[e->faces[1]][(e->faces_other_v[1] + 1) % 3] = e_v1_new;
e->faces_other_v[0] = (e->faces_other_v[0] + 2) % 3;
e->faces_other_v[1] = (e->faces_other_v[1] + 2) % 3;
BLI_assert((tris[e->faces[0]][e->faces_other_v[0]] != e_v1_new) &&
(tris[e->faces[0]][e->faces_other_v[0]] != e_v2_new));
BLI_assert((tris[e->faces[1]][e->faces_other_v[1]] != e_v1_new) &&
(tris[e->faces[1]][e->faces_other_v[1]] != e_v2_new));
BLI_edgehash_remove(ehash, e->verts[0], e->verts[1], NULL);
BLI_edgehash_insert(ehash, e_v1_new, e_v2_new, e);
if (e_v1_new < e_v2_new) {
e->verts[0] = e_v1_new;
e->verts[1] = e_v2_new;
}
else {
/* maintain winding info */
e->verts[0] = e_v2_new;
e->verts[1] = e_v1_new;
SWAP(unsigned int, e->faces[0], e->faces[1]);
SWAP(unsigned int, e->faces_other_v[0], e->faces_other_v[1]);
}
/* update adjacent data */
{
unsigned int e_side = 0;
for (e_side = 0; e_side < 2; e_side++) {
/* 't_other' which we need to swap out is always the same edge-order */
const unsigned int t_other = (((e->faces_other_v[e_side]) + 2)) % 3;
unsigned int t_index = e->faces[e_side];
unsigned int t_index_other = e->faces[!e_side];
unsigned int *tri = tris[t_index];
struct PolyEdge *e_other;
unsigned int e_v1 = tri[(t_other ) ];
unsigned int e_v2 = tri[(t_other + 1) % 3];
e_other = BLI_edgehash_lookup(ehash, e_v1, e_v2);
if (e_other) {
BLI_assert(t_index != e_other->faces[0] && t_index != e_other->faces[1]);
if (t_index_other == e_other->faces[0]) {
e_other->faces[0] = t_index;
e_other->faces_other_v[0] = (t_other + 2) % 3;
BLI_assert(!ELEM(tri[e_other->faces_other_v[0]], e_v1, e_v2));
}
else if (t_index_other == e_other->faces[1]) {
e_other->faces[1] = t_index;
e_other->faces_other_v[1] = (t_other + 2) % 3;
BLI_assert(!ELEM(tri[e_other->faces_other_v[1]], e_v1, e_v2));
}
else {
BLI_assert(0);
}
}
}
}
#ifndef NDEBUG
polyfill_validate_tri(tris, e->faces[0], ehash);
polyfill_validate_tri(tris, e->faces[1], ehash);
#endif
BLI_assert(!ELEM(tris[e->faces[0]][e->faces_other_v[0]], UNPACK2(e->verts)));
BLI_assert(!ELEM(tris[e->faces[1]][e->faces_other_v[1]], UNPACK2(e->verts)));
}
/**
* The intention is that this calculates the output of #BLI_polyfill_calc
*
*
* \note assumes the \a coords form a boundary,
* so any edges running along contiguous (wrapped) indices,
* are ignored since the edges wont share 2 faces.
*/
void BLI_polyfill_beautify(
const float (*coords)[2],
const unsigned int coords_tot,
unsigned int (*tris)[3],
/* structs for reuse */
MemArena *arena, Heap *eheap, EdgeHash *ehash)
{
const unsigned int coord_last = coords_tot - 1;
const unsigned int tris_tot = coords_tot - 2;
/* internal edges only (between 2 tris) */
const unsigned int edges_tot = tris_tot - 1;
unsigned int edges_tot_used = 0;
unsigned int i;
HeapNode **eheap_table;
struct PolyEdge *edges = BLI_memarena_alloc(arena, edges_tot * sizeof(*edges));
BLI_assert(BLI_heap_size(eheap) == 0);
BLI_assert(BLI_edgehash_size(ehash) == 0);
/* first build edges */
for (i = 0; i < tris_tot; i++) {
unsigned int j_prev, j_curr, j_next;
j_prev = 2;
j_next = 1;
for (j_curr = 0; j_curr < 3; j_next = j_prev, j_prev = j_curr++) {
int e_index;
unsigned int e_pair[2] = {
tris[i][j_prev],
tris[i][j_curr],
};
if (e_pair[0] > e_pair[1]) {
SWAP(unsigned int, e_pair[0], e_pair[1]);
e_index = 1;
}
else {
e_index = 0;
}
if (!is_boundary_edge(e_pair[0], e_pair[1], coord_last)) {
struct PolyEdge *e = BLI_edgehash_lookup(ehash, e_pair[0], e_pair[1]);
if (e == NULL) {
e = &edges[edges_tot_used++];
BLI_edgehash_insert(ehash, e_pair[0], e_pair[1], e);
memcpy(e->verts, e_pair, sizeof(e->verts));
#ifndef NDEBUG
e->faces[!e_index] = (unsigned int)-1;
#endif
}
else {
/* ensure each edge only ever has 2x users */
#ifndef NDEBUG
BLI_assert(e->faces[e_index] == (unsigned int)-1);
BLI_assert((e->verts[0] == e_pair[0]) &&
(e->verts[1] == e_pair[1]));
#endif
}
e->faces[e_index] = i;
e->faces_other_v[e_index] = j_next;
}
}
}
/* now perform iterative rotations */
eheap_table = BLI_memarena_alloc(arena, sizeof(HeapNode *) * (size_t)edges_tot);
// for (i = 0; i < tris_tot; i++) { polyfill_validate_tri(tris, i, eh); }
/* build heap */
for (i = 0; i < edges_tot; i++) {
struct PolyEdge *e = &edges[i];
const float cost = polyedge_rotate_beauty_calc(coords, (const unsigned int (*)[3])tris, e);
if (cost < 0.0f) {
eheap_table[i] = BLI_heap_insert(eheap, cost, e);
}
else {
eheap_table[i] = NULL;
}
}
while (BLI_heap_is_empty(eheap) == false) {
struct PolyEdge *e = BLI_heap_popmin(eheap);
i = (unsigned int)(e - edges);
eheap_table[i] = NULL;
polyedge_rotate(tris, e, ehash);
/* recalculate faces connected on the heap */
polyedge_beauty_cost_update(
coords, (const unsigned int (*)[3])tris, edges,
e,
eheap, eheap_table, ehash);
}
BLI_heap_clear(eheap, NULL);
BLI_edgehash_clear_ex(ehash, NULL, BLI_POLYFILL_ALLOC_NGON_RESERVE);
/* MEM_freeN(eheap_table); */ /* arena */
}

@ -37,6 +37,7 @@
#include "BLI_math.h" #include "BLI_math.h"
#include "BLI_memarena.h" #include "BLI_memarena.h"
#include "BLI_polyfill2d.h" #include "BLI_polyfill2d.h"
#include "BLI_polyfill2d_beautify.h"
#include "bmesh.h" #include "bmesh.h"
#include "bmesh_tools.h" #include "bmesh_tools.h"
@ -749,15 +750,14 @@ void BM_face_triangulate(
const int quad_method, const int quad_method,
const int ngon_method, const int ngon_method,
const bool use_tag, const bool use_tag,
MemArena *pf_arena,
MemArena *pf_arena) /* use for MOD_TRIANGULATE_NGON_BEAUTY only! */
struct Heap *pf_heap, struct EdgeHash *pf_ehash)
{ {
BMLoop *l_iter, *l_first, *l_new; BMLoop *l_iter, *l_first, *l_new;
BMFace *f_new; BMFace *f_new;
int orig_f_len = f->len;
int nf_i = 0; int nf_i = 0;
BMEdge **edge_array;
int edge_array_len;
bool use_beauty = (ngon_method == MOD_TRIANGULATE_NGON_BEAUTY); bool use_beauty = (ngon_method == MOD_TRIANGULATE_NGON_BEAUTY);
BLI_assert(BM_face_is_normal_valid(f)); BLI_assert(BM_face_is_normal_valid(f));
@ -859,8 +859,9 @@ void BM_face_triangulate(
pf_arena); pf_arena);
if (use_beauty) { if (use_beauty) {
edge_array = BLI_array_alloca(edge_array, orig_f_len - 3); BLI_polyfill_beautify(
edge_array_len = 0; (const float (*)[2])projverts, f->len, tris,
pf_arena, pf_heap, pf_ehash);
} }
/* loop over calculated triangles and create new geometry */ /* loop over calculated triangles and create new geometry */
@ -897,7 +898,7 @@ void BM_face_triangulate(
} }
/* we know any edge that we create and _isnt_ */ /* we know any edge that we create and _isnt_ */
if (use_beauty || use_tag) { if (use_tag) {
/* new faces loops */ /* new faces loops */
l_iter = l_first = l_new; l_iter = l_first = l_new;
do { do {
@ -907,82 +908,19 @@ void BM_face_triangulate(
bool is_new_edge = (l_iter == l_iter->radial_next); bool is_new_edge = (l_iter == l_iter->radial_next);
if (is_new_edge) { if (is_new_edge) {
if (use_beauty) { BM_elem_flag_enable(e, BM_ELEM_TAG);
edge_array[edge_array_len] = e;
edge_array_len++;
}
if (use_tag) {
BM_elem_flag_enable(e, BM_ELEM_TAG);
}
} }
/* note, never disable tag's */ /* note, never disable tag's */
} while ((l_iter = l_iter->next) != l_first); } while ((l_iter = l_iter->next) != l_first);
} }
} }
if ((!use_beauty) || (!r_faces_new)) { {
/* we can't delete the real face, because some of the callers expect it to remain valid. /* we can't delete the real face, because some of the callers expect it to remain valid.
* so swap data and delete the last created tri */ * so swap data and delete the last created tri */
bmesh_face_swap_data(f, f_new); bmesh_face_swap_data(f, f_new);
BM_face_kill(bm, f_new); BM_face_kill(bm, f_new);
} }
if (use_beauty) {
BLI_assert(edge_array_len <= orig_f_len - 3);
BM_mesh_beautify_fill(bm, edge_array, edge_array_len, 0, 0, 0, 0);
if (r_faces_new) {
/* beautify deletes and creates new faces
* we need to re-populate the r_faces_new array
* with the new faces
*/
int i;
#define FACE_USED_TEST(f) (BM_elem_index_get(f) == -2)
#define FACE_USED_SET(f) BM_elem_index_set(f, -2)
nf_i = 0;
for (i = 0; i < edge_array_len; i++) {
BMFace *f_pair[2];
BMEdge *e = edge_array[i];
int j;
#ifndef NDEBUG
const bool ok = BM_edge_face_pair(e, &f_pair[0], &f_pair[1]);
BLI_assert(ok);
#else
BM_edge_face_pair(e, &f_pair[0], &f_pair[1]);
#endif
for (j = 0; j < 2; j++) {
if (FACE_USED_TEST(f_pair[j]) == false) {
FACE_USED_SET(f_pair[j]); /* set_dirty */
if (nf_i < edge_array_len) {
r_faces_new[nf_i++] = f_pair[j];
}
else {
f_new = f_pair[j];
break;
}
}
}
}
#undef FACE_USED_TEST
#undef FACE_USED_SET
/* nf_i doesn't include the last face */
BLI_assert(nf_i <= orig_f_len - 3);
/* we can't delete the real face, because some of the callers expect it to remain valid.
* so swap data and delete the last created tri */
bmesh_face_swap_data(f, f_new);
BM_face_kill(bm, f_new);
}
}
} }
bm->elem_index_dirty |= BM_FACE; bm->elem_index_dirty |= BM_FACE;

@ -27,6 +27,9 @@
* \ingroup bmesh * \ingroup bmesh
*/ */
struct EdgeHash;
struct Heap;
#include "BLI_compiler_attrs.h" #include "BLI_compiler_attrs.h"
void BM_bmesh_calc_tessellation(BMesh *bm, BMLoop *(*looptris)[3], int *r_looptris_tot); void BM_bmesh_calc_tessellation(BMesh *bm, BMLoop *(*looptris)[3], int *r_looptris_tot);
@ -62,7 +65,9 @@ void BM_face_triangulate(
int *r_faces_new_tot, int *r_faces_new_tot,
const int quad_method, const int ngon_method, const int quad_method, const int ngon_method,
const bool use_tag, const bool use_tag,
struct MemArena *pf_arena) ATTR_NONNULL(1, 2); struct MemArena *pf_arena,
struct Heap *pf_heap, struct EdgeHash *pf_ehash
) ATTR_NONNULL(1, 2);
void BM_face_splits_check_legal(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len) ATTR_NONNULL(); void BM_face_splits_check_legal(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len) ATTR_NONNULL();
void BM_face_splits_check_optimal(BMFace *f, BMLoop *(*loops)[2], int len) ATTR_NONNULL(); void BM_face_splits_check_optimal(BMFace *f, BMLoop *(*loops)[2], int len) ATTR_NONNULL();

@ -27,13 +27,20 @@
* *
*/ */
#include "DNA_modifier_types.h" /* for MOD_TRIANGULATE_NGON_BEAUTY only */
#include "MEM_guardedalloc.h" #include "MEM_guardedalloc.h"
#include "BLI_utildefines.h" #include "BLI_utildefines.h"
#include "BLI_alloca.h" #include "BLI_alloca.h"
#include "BLI_memarena.h" #include "BLI_memarena.h"
#include "BLI_listbase.h" #include "BLI_listbase.h"
#include "BLI_polyfill2d.h" /* only for define */ #include "BLI_heap.h"
#include "BLI_edgehash.h"
/* only for defines */
#include "BLI_polyfill2d.h"
#include "BLI_polyfill2d_beautify.h"
#include "bmesh.h" #include "bmesh.h"
@ -48,7 +55,9 @@ static void bm_face_triangulate_mapping(
const bool use_tag, const bool use_tag,
BMOperator *op, BMOpSlot *slot_facemap_out, BMOperator *op, BMOpSlot *slot_facemap_out,
MemArena *pf_arena) MemArena *pf_arena,
/* use for MOD_TRIANGULATE_NGON_BEAUTY only! */
struct Heap *pf_heap, struct EdgeHash *pf_ehash)
{ {
int faces_array_tot = face->len - 3; int faces_array_tot = face->len - 3;
BMFace **faces_array = BLI_array_alloca(faces_array, faces_array_tot); BMFace **faces_array = BLI_array_alloca(faces_array, faces_array_tot);
@ -57,7 +66,8 @@ static void bm_face_triangulate_mapping(
BM_face_triangulate( BM_face_triangulate(
bm, face, faces_array, &faces_array_tot, bm, face, faces_array, &faces_array_tot,
quad_method, ngon_method, use_tag, quad_method, ngon_method, use_tag,
pf_arena); pf_arena,
pf_heap, pf_ehash);
if (faces_array_tot) { if (faces_array_tot) {
int i; int i;
@ -76,9 +86,16 @@ void BM_mesh_triangulate(
BMIter iter; BMIter iter;
BMFace *face; BMFace *face;
MemArena *pf_arena; MemArena *pf_arena;
Heap *pf_heap;
EdgeHash *pf_ehash;
pf_arena = BLI_memarena_new(BLI_POLYFILL_ARENA_SIZE, __func__); pf_arena = BLI_memarena_new(BLI_POLYFILL_ARENA_SIZE, __func__);
if (ngon_method == MOD_TRIANGULATE_NGON_BEAUTY) {
pf_heap = BLI_heap_new_ex(BLI_POLYFILL_ALLOC_NGON_RESERVE);
pf_ehash = BLI_edgehash_new_ex(__func__, BLI_POLYFILL_ALLOC_NGON_RESERVE);
}
if (slot_facemap_out) { if (slot_facemap_out) {
/* same as below but call: bm_face_triangulate_mapping() */ /* same as below but call: bm_face_triangulate_mapping() */
BM_ITER_MESH (face, &iter, bm, BM_FACES_OF_MESH) { BM_ITER_MESH (face, &iter, bm, BM_FACES_OF_MESH) {
@ -88,7 +105,9 @@ void BM_mesh_triangulate(
bm, face, quad_method, bm, face, quad_method,
ngon_method, tag_only, ngon_method, tag_only,
op, slot_facemap_out, op, slot_facemap_out,
pf_arena);
pf_arena,
pf_heap, pf_ehash);
} }
} }
} }
@ -100,11 +119,17 @@ void BM_mesh_triangulate(
BM_face_triangulate( BM_face_triangulate(
bm, face, NULL, NULL, bm, face, NULL, NULL,
quad_method, ngon_method, tag_only, quad_method, ngon_method, tag_only,
pf_arena); pf_arena,
pf_heap, pf_ehash);
} }
} }
} }
} }
BLI_memarena_free(pf_arena); BLI_memarena_free(pf_arena);
if (ngon_method == MOD_TRIANGULATE_NGON_BEAUTY) {
BLI_heap_free(pf_heap, NULL);
BLI_edgehash_free(pf_ehash, NULL);
}
} }