tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

bmesh api cleanup, face creation args now accept an example face (as with vertex and edge), 

also replace BM_face_create_quad_tri_v with BM_face_create_verts
This commit is contained in:
Campbell Barton 2013-08-21 07:51:47 +00:00
parent 785a67f396
commit 9470754fd3
24 changed files with 85 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/intern/modifiers_bmesh.c
View File

@ -52,7 +52,7 @@ static BMFace *bm_face_create_from_mpoly(MPoly *mp, MLoop *ml,
edges[j] = etable[ml->e];
}
return BM_face_create(bm, verts, edges, mp->totloop, BM_CREATE_SKIP_CD);
return BM_face_create(bm, verts, edges, mp->totloop, NULL, BM_CREATE_SKIP_CD);
}
/**

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

@ -302,9 +302,7 @@ static BMFace *pbvh_bmesh_face_create(PBVH *bvh, int node_index,
/* ensure we never add existing face */
BLI_assert(BM_face_exists(v_tri, 3, NULL) == false);
f = BM_face_create(bvh->bm, v_tri, e_tri, 3, BM_CREATE_NOP);
// BM_elem_attrs_copy(bvh->bm, bvh->bm, f_example, f);
f->mat_nr = f_example->mat_nr;
f = BM_face_create(bvh->bm, v_tri, e_tri, 3, f_example, BM_CREATE_NOP);
if (!BLI_ghash_haskey(bvh->bm_face_to_node, f)) {

2
source/blender/bmesh/bmesh.h
View File

@ -251,8 +251,8 @@ extern "C" {
#include "intern/bmesh_operator_api.h"
#include "intern/bmesh_error.h"
#include "intern/bmesh_construct.h"
#include "intern/bmesh_core.h"
#include "intern/bmesh_construct.h"
#include "intern/bmesh_edgeloop.h"
#include "intern/bmesh_interp.h"
#include "intern/bmesh_iterators.h"

76
source/blender/bmesh/intern/bmesh_construct.c
View File

@ -65,64 +65,10 @@ static void bm_loop_attrs_copy(BMesh *source_mesh, BMesh *target_mesh,
BMFace *BM_face_create_quad_tri(BMesh *bm,
BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4,
const BMFace *example, const bool no_double)
const BMFace *f_example, const eBMCreateFlag create_flag)
{
BMVert *vtar[4] = {v1, v2, v3, v4};
return BM_face_create_quad_tri_v(bm, vtar, v4 ? 4 : 3, example, no_double);
}
BMFace *BM_face_create_quad_tri_v(BMesh *bm, BMVert **verts, int len, const BMFace *example, const bool no_double)
{
BMFace *f = NULL;
bool is_overlap = false;
/* sanity check - debug mode only */
if (len == 3) {
BLI_assert(verts[0] != verts[1]);
BLI_assert(verts[0] != verts[2]);
BLI_assert(verts[1] != verts[2]);
}
else if (len == 4) {
BLI_assert(verts[0] != verts[1]);
BLI_assert(verts[0] != verts[2]);
BLI_assert(verts[0] != verts[3]);
BLI_assert(verts[1] != verts[2]);
BLI_assert(verts[1] != verts[3]);
BLI_assert(verts[2] != verts[3]);
}
else {
BLI_assert(0);
}
if (no_double) {
/* check if face exists or overlaps */
is_overlap = BM_face_exists(verts, len, &f);
}
/* make new face */
if ((f == NULL) && (!is_overlap)) {
BMEdge *edar[4] = {NULL};
edar[0] = BM_edge_create(bm, verts[0], verts[1], NULL, BM_CREATE_NO_DOUBLE);
edar[1] = BM_edge_create(bm, verts[1], verts[2], NULL, BM_CREATE_NO_DOUBLE);
if (len == 4) {
edar[2] = BM_edge_create(bm, verts[2], verts[3], NULL, BM_CREATE_NO_DOUBLE);
edar[3] = BM_edge_create(bm, verts[3], verts[0], NULL, BM_CREATE_NO_DOUBLE);
}
else {
edar[2] = BM_edge_create(bm, verts[2], verts[0], NULL, BM_CREATE_NO_DOUBLE);
}
f = BM_face_create(bm, verts, edar, len, BM_CREATE_NOP);
if (example && f) {
BM_elem_attrs_copy(bm, bm, example, f);
}
}
return f;
return BM_face_create_verts(bm, vtar, v4 ? 4 : 3, f_example, create_flag, true);
}
/**
@ -199,7 +145,8 @@ void BM_face_copy_shared(BMesh *bm, BMFace *f,
* #BM_face_create should be considered over this function as it
* avoids some unnecessary work.
*/
BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, const int len, const int create_flag)
BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag)
{
BMEdge **edges_sort = BLI_array_alloca(edges_sort, len);
BMVert **verts_sort = BLI_array_alloca(verts_sort, len + 1);
@ -318,7 +265,7 @@ BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, c
BM_ELEM_API_FLAG_DISABLE(verts_sort[i], _FLAG_MV);
}
f = BM_face_create(bm, verts_sort, edges_sort, len, create_flag);
f = BM_face_create(bm, verts_sort, edges_sort, len, f_example, create_flag);
/* clean up flags */
for (i = 0; i < len; i++) {
@ -346,7 +293,8 @@ err:
* - Optionally create edges between vertices.
* - Uses verts so no need to find edges (handy when you only have verts)
*/
BMFace *BM_face_create_ngon_verts(BMesh *bm, BMVert **vert_arr, const int len, const int create_flag,
BMFace *BM_face_create_ngon_verts(BMesh *bm, BMVert **vert_arr, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag,
const bool calc_winding, const bool create_edges)
{
BMEdge **edge_arr = BLI_array_alloca(edge_arr, len);
@ -406,7 +354,8 @@ BMFace *BM_face_create_ngon_verts(BMesh *bm, BMVert **vert_arr, const int len, c
bm,
v_winding[winding[0]],
v_winding[winding[1]],
edge_arr, len, create_flag);
edge_arr, len,
f_example, create_flag);
}
@ -439,7 +388,8 @@ static int angle_index_pair_cmp(const void *e1, const void *e2)
*
* \note Since this is a vcloud there is no direction.
*/
BMFace *BM_face_create_ngon_vcloud(BMesh *bm, BMVert **vert_arr, int len, const int create_flag)
BMFace *BM_face_create_ngon_vcloud(BMesh *bm, BMVert **vert_arr, int len,
const BMFace *f_example, const eBMCreateFlag create_flag)
{
AngleIndexPair *vang = BLI_array_alloca(vang, len);
BMVert **vert_arr_map = BLI_array_alloca(vert_arr_map, len);
@ -552,7 +502,7 @@ BMFace *BM_face_create_ngon_vcloud(BMesh *bm, BMVert **vert_arr, int len, const
vert_arr_map[i] = vert_arr[vang[i].index];
}
f = BM_face_create_ngon_verts(bm, vert_arr_map, len, create_flag, true, true);
f = BM_face_create_ngon_verts(bm, vert_arr_map, len, f_example, create_flag, true, true);
return f;
}
@ -923,7 +873,7 @@ static BMFace *bm_mesh_copy_new_face(BMesh *bm_new, BMesh *bm_old,
j++;
} while ((l_iter = l_iter->next) != l_first);
f_new = BM_face_create(bm_new, verts, edges, f->len, BM_CREATE_SKIP_CD);
f_new = BM_face_create(bm_new, verts, edges, f->len, NULL, BM_CREATE_SKIP_CD);
if (UNLIKELY(f_new == NULL)) {
return NULL;

15
source/blender/bmesh/intern/bmesh_construct.h
View File

@ -29,21 +29,20 @@
struct BMAllocTemplate;
BMFace *BM_face_create_quad_tri_v(BMesh *bm,
BMVert **verts, int len,
const BMFace *example, const bool no_double);
BMFace *BM_face_create_quad_tri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4,
const BMFace *example, const bool no_double);
const BMFace *f_example, const eBMCreateFlag create_flag);
void BM_face_copy_shared(BMesh *bm, BMFace *f,
BMElemFilterFunc filter_fn, void *user_data);
BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, const int len, const int create_flag);
BMFace *BM_face_create_ngon_verts(BMesh *bm, BMVert **vert_arr, const int len, const int create_flag,
BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag);
BMFace *BM_face_create_ngon_verts(BMesh *bm, BMVert **vert_arr, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag,
const bool calc_winding, const bool create_edges);
BMFace *BM_face_create_ngon_vcloud(BMesh *bm, BMVert **vert_arr, int len, const int create_flag);
BMFace *BM_face_create_ngon_vcloud(BMesh *bm, BMVert **vert_arr, int len,
const BMFace *f_example, const eBMCreateFlag create_flag);
void BMO_remove_tagged_faces(BMesh *bm, const short oflag);
void BMO_remove_tagged_edges(BMesh *bm, const short oflag);

49
source/blender/bmesh/intern/bmesh_core.c
View File

@ -56,7 +56,8 @@
/**
* \brief Main function for creating a new vertex.
*/
BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example, const eBMCreateFlag create_flag)
BMVert *BM_vert_create(BMesh *bm, const float co[3],
const BMVert *v_example, const eBMCreateFlag create_flag)
{
BMVert *v = BLI_mempool_calloc(bm->vpool);
@ -86,10 +87,10 @@ BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example, cons
}
if (!(create_flag & BM_CREATE_SKIP_CD)) {
if (example) {
if (v_example) {
int *keyi;
BM_elem_attrs_copy(bm, bm, example, v);
BM_elem_attrs_copy(bm, bm, v_example, v);
/* exception: don't copy the original shapekey index */
keyi = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_SHAPE_KEYINDEX);
@ -113,7 +114,8 @@ BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example, cons
* \note Duplicate edges are supported by the API however users should _never_ see them.
* so unless you need a unique edge or know the edge won't exist, you should call with \a no_double = true
*/
BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, const eBMCreateFlag create_flag)
BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2,
const BMEdge *e_example, const eBMCreateFlag create_flag)
{
BMEdge *e;
@ -148,8 +150,8 @@ BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example,
bmesh_disk_edge_append(e, e->v2);
if (!(create_flag & BM_CREATE_SKIP_CD)) {
if (example) {
BM_elem_attrs_copy(bm, bm, example, e);
if (e_example) {
BM_elem_attrs_copy(bm, bm, e_example, e);
}
else {
CustomData_bmesh_set_default(&bm->edata, &e->head.data);
@ -190,7 +192,8 @@ static BMLoop *bm_loop_create(BMesh *bm, BMVert *v, BMEdge *e, BMFace *f,
return l;
}
static BMLoop *bm_face_boundary_add(BMesh *bm, BMFace *f, BMVert *startv, BMEdge *starte, const int create_flag)
static BMLoop *bm_face_boundary_add(BMesh *bm, BMFace *f, BMVert *startv, BMEdge *starte,
const eBMCreateFlag create_flag)
{
#ifdef USE_BMESH_HOLES
BMLoopList *lst = BLI_mempool_calloc(bm->looplistpool);
@ -251,7 +254,7 @@ BMFace *BM_face_copy(BMesh *bm_dst, BMesh *bm_src, BMFace *f,
v1 = verts[(i + 1) % f->len];
}
edges[i] = BM_edge_create(bm_dst, v1, v2, l_iter->e, BM_CREATE_NOP);
edges[i] = BM_edge_create(bm_dst, v1, v2, l_iter->e, BM_CREATE_NOP);
}
else {
edges[i] = l_iter->e;
@ -259,7 +262,7 @@ BMFace *BM_face_copy(BMesh *bm_dst, BMesh *bm_src, BMFace *f,
i++;
} while ((l_iter = l_iter->next) != l_first);
f_copy = BM_face_create(bm_dst, verts, edges, f->len, BM_CREATE_SKIP_CD);
f_copy = BM_face_create(bm_dst, verts, edges, f->len, NULL, BM_CREATE_SKIP_CD);
BM_elem_attrs_copy(bm_src, bm_dst, f, f_copy);
@ -320,11 +323,12 @@ BLI_INLINE BMFace *bm_face_create__internal(BMesh *bm, const eBMCreateFlag creat
* \param len Length of the face
* \param create_flag Options for creating the face
*/
BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, const eBMCreateFlag create_flag)
BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag)
{
BMFace *f = NULL;
BMLoop *l, *startl, *lastl;
int i, overlap;
int i;
if (len == 0) {
/* just return NULL for now */
@ -333,8 +337,8 @@ BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len,
if (create_flag & BM_CREATE_NO_DOUBLE) {
/* Check if face already exists */
overlap = BM_face_exists(verts, len, &f);
if (overlap) {
const bool is_overlap = BM_face_exists(verts, len, &f);
if (is_overlap) {
return f;
}
else {
@ -364,6 +368,15 @@ BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len,
f->len = len;
if (!(create_flag & BM_CREATE_SKIP_CD)) {
if (f_example) {
BM_elem_attrs_copy(bm, bm, f_example, f);
}
else {
CustomData_bmesh_set_default(&bm->pdata, &f->head.data);
}
}
BM_CHECK_ELEMENT(f);
return f;
@ -372,8 +385,8 @@ BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len,
/**
* Wrapper for #BM_face_create when you don't have an edge array
*/
BMFace *BM_face_create_verts(BMesh *bm, BMVert **vert_arr, const int len, const eBMCreateFlag create_flag,
const bool create_edges)
BMFace *BM_face_create_verts(BMesh *bm, BMVert **vert_arr, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag, const bool create_edges)
{
BMEdge **edge_arr = BLI_array_alloca(edge_arr, len);
int i, i_prev = len - 1;
@ -392,7 +405,7 @@ BMFace *BM_face_create_verts(BMesh *bm, BMVert **vert_arr, const int len, const
i_prev = i;
}
return BM_face_create(bm, vert_arr, edge_arr, len, create_flag);
return BM_face_create(bm, vert_arr, edge_arr, len, f_example, create_flag);
}
#ifndef NDEBUG
@ -1079,7 +1092,7 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
}
/* create region face */
f_new = tote ? BM_face_create_ngon(bm, v1, v2, edges, tote, BM_CREATE_NOP) : NULL;
f_new = tote ? BM_face_create_ngon(bm, v1, v2, edges, tote, faces[0], BM_CREATE_NOP) : NULL;
if (UNLIKELY(!f_new || BMO_error_occurred(bm))) {
if (!BMO_error_occurred(bm))
err = N_("Invalid boundary region to join faces");
@ -1106,8 +1119,6 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
BM_elem_attrs_copy(bm, bm, l2, l_iter);
}
} while ((l_iter = l_iter->next) != l_first);
BM_elem_attrs_copy(bm, bm, faces[0], f_new);
#ifdef USE_BMESH_HOLES
/* add holes */

12
source/blender/bmesh/intern/bmesh_core.h
View File

@ -40,10 +40,14 @@ typedef enum eBMCreateFlag {
BM_CREATE_SKIP_CD = (1 << 2),
} eBMCreateFlag;
BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example, const eBMCreateFlag create_flag);
BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, const eBMCreateFlag create_flag);
BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, const eBMCreateFlag create_flag);
BMFace *BM_face_create_verts(BMesh *bm, BMVert **verts, const int len, const eBMCreateFlag create_flag,
BMVert *BM_vert_create(BMesh *bm, const float co[3],
const BMVert *v_example, const eBMCreateFlag create_flag);
BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2,
const BMEdge *e_example, const eBMCreateFlag create_flag);
BMFace *BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag);
BMFace *BM_face_create_verts(BMesh *bm, BMVert **verts, const int len,
const BMFace *f_example, const eBMCreateFlag create_flag,
const bool create_edges);
void BM_face_edges_kill(BMesh *bm, BMFace *f);

2
source/blender/bmesh/intern/bmesh_log.c
View File

@ -294,7 +294,7 @@ static void bm_log_faces_restore(BMesh *bm, BMLog *log, GHash *faces)
bm_log_vert_from_id(log, lf->v_ids[2])};
BMFace *f;
f = BM_face_create_quad_tri_v(bm, v, 3, NULL, false);
f = BM_face_create_verts(bm, v, 3, NULL, BM_CREATE_NOP, true);
bm_log_face_id_set(log, f, GET_INT_FROM_POINTER(key));
}
}

2
source/blender/bmesh/intern/bmesh_mesh_conv.c
View File

@ -212,7 +212,7 @@ static BMFace *bm_face_create_from_mpoly(MPoly *mp, MLoop *ml,
edges[j] = etable[ml->e];
}
return BM_face_create(bm, verts, edges, mp->totloop, BM_CREATE_SKIP_CD);
return BM_face_create(bm, verts, edges, mp->totloop, NULL, BM_CREATE_SKIP_CD);
}

4
source/blender/bmesh/operators/bmo_bridge.c
View File

@ -343,7 +343,7 @@ static void bridge_loop_pair(BMesh *bm,
BMVert *v_arr[4] = {v_a, v_b, v_b_next, v_a_next};
if (BM_face_exists(v_arr, 4, &f) == false) {
/* copy if loop data if its is missing on one ring */
f = BM_face_create_verts(bm, v_arr, 4, BM_CREATE_NOP, true);
f = BM_face_create_verts(bm, v_arr, 4, NULL, BM_CREATE_NOP, true);
l_iter = BM_FACE_FIRST_LOOP(f);
if (l_b) BM_elem_attrs_copy(bm, bm, l_b, l_iter); l_iter = l_iter->next;
@ -356,7 +356,7 @@ static void bridge_loop_pair(BMesh *bm,
BMVert *v_arr[3] = {v_a, v_b, v_a_next};
if (BM_face_exists(v_arr, 3, &f) == false) {
/* fan-fill a triangle */
f = BM_face_create_verts(bm, v_arr, 3, BM_CREATE_NOP, true);
f = BM_face_create_verts(bm, v_arr, 3, NULL, BM_CREATE_NOP, true);
l_iter = BM_FACE_FIRST_LOOP(f);
if (l_b) BM_elem_attrs_copy(bm, bm, l_b, l_iter); l_iter = l_iter->next;

2
source/blender/bmesh/operators/bmo_create.c
View File

@ -283,7 +283,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op)
BMFace *f;
BMO_iter_as_array(op->slots_in, "geom", BM_VERT, (void **)vert_arr, totv);
f = BM_face_create_ngon_vcloud(bm, vert_arr, totv, BM_CREATE_NO_DOUBLE);
f = BM_face_create_ngon_vcloud(bm, vert_arr, totv, NULL, BM_CREATE_NO_DOUBLE);
if (f) {
BMO_elem_flag_enable(bm, f, ELE_OUT);

4
source/blender/bmesh/operators/bmo_dupe.c
View File

@ -156,12 +156,10 @@ static BMFace *copy_face(BMOperator *op,
}
/* create new face */
target_face = BM_face_create(target_mesh, vtar, edar, source_face->len, BM_CREATE_SKIP_CD);
target_face = BM_face_create(target_mesh, vtar, edar, source_face->len, source_face, BM_CREATE_SKIP_CD);
BMO_slot_map_elem_insert(op, slot_facemap_out, source_face, target_face);
BMO_slot_map_elem_insert(op, slot_facemap_out, target_face, source_face);
BM_elem_attrs_copy(source_mesh, target_mesh, source_face, target_face);
/* mark the face for output */
BMO_elem_flag_enable(target_mesh, target_face, DUPE_NEW);

6
source/blender/bmesh/operators/bmo_extrude.c
View File

@ -77,7 +77,7 @@ void bmo_extrude_discrete_faces_exec(BMesh *bm, BMOperator *op)
f_side = BM_face_create_quad_tri(bm,
l_org->next->v, l_new->next->v, l_new->v, l_org->v,
f_org, false);
f_org, BM_CREATE_NOP);
l_side_iter = BM_FACE_FIRST_LOOP(f_side);
@ -185,7 +185,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op)
f_verts[3] = e_new->v2;
}
/* not sure what to do about example face, pass NULL for now */
f = BM_face_create_quad_tri_v(bm, f_verts, 4, NULL, false);
f = BM_face_create_verts(bm, f_verts, 4, NULL, BM_CREATE_NOP, true);
bm_extrude_copy_face_loop_attributes(bm, f);
if (BMO_elem_flag_test(bm, e, EXT_INPUT))
@ -401,7 +401,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op)
}
/* not sure what to do about example face, pass NULL for now */
f = BM_face_create_quad_tri_v(bm, f_verts, 4, NULL, false);
f = BM_face_create_verts(bm, f_verts, 4, NULL, BM_CREATE_NOP, true);
bm_extrude_copy_face_loop_attributes(bm, f);
}

2
source/blender/bmesh/operators/bmo_fill_edgeloop.c
View File

@ -140,7 +140,7 @@ void bmo_edgeloop_fill_exec(BMesh *bm, BMOperator *op)
BMFace *f;
/* don't use calc_edges option because we already have the edges */
f = BM_face_create_ngon_verts(bm, f_verts, i, BM_CREATE_NOP, true, false);
f = BM_face_create_ngon_verts(bm, f_verts, i, NULL, BM_CREATE_NOP, true, false);
BMO_elem_flag_enable(bm, f, ELE_OUT);
f->mat_nr = mat_nr;
if (use_smooth) {

4
source/blender/bmesh/operators/bmo_fill_grid.c
View File

@ -218,7 +218,7 @@ static void bm_grid_fill_array(BMesh *bm, BMVert **v_grid, const int xtot, const
v_grid[XY(x + 1, y + 1)], /* TR */
v_grid[XY(x + 1, y + 0)], /* BR */
NULL,
false);
BM_CREATE_NOP);
}
else {
f = BM_face_create_quad_tri(
@ -228,7 +228,7 @@ static void bm_grid_fill_array(BMesh *bm, BMVert **v_grid, const int xtot, const
v_grid[XY(x, y + 1)], /* TL */
v_grid[XY(x, y + 0)], /* BL */
NULL,
false);
BM_CREATE_NOP);
}
BMO_elem_flag_enable(bm, f, FACE_OUT);
f->mat_nr = mat_nr;

2
source/blender/bmesh/operators/bmo_hull.c
View File

@ -135,7 +135,7 @@ static void hull_output_triangles(BMesh *bm, GHash *hull_triangles)
}
/* Create new hull face */
f = BM_face_create_quad_tri_v(bm, t->v, 3, example, true);
f = BM_face_create_verts(bm, t->v, 3, example, BM_CREATE_NO_DOUBLE, true);
BM_face_copy_shared(bm, f, NULL, NULL);
}
/* Mark face for 'geom.out' slot and select */

4
source/blender/bmesh/operators/bmo_inset.c
View File

@ -162,7 +162,7 @@ static void bmo_face_inset_individual(
v_other_next,
l_iter->next->v,
l_iter->v,
f, false);
f, BM_CREATE_NOP);
BMO_elem_flag_enable(bm, f_new_outer, ELE_NEW);
/* copy loop data */
@ -811,7 +811,7 @@ void bmo_inset_region_exec(BMesh *bm, BMOperator *op)
#endif
/* no need to check doubles, we KNOW there won't be any */
/* yes - reverse face is correct in this case */
f = BM_face_create_quad_tri_v(bm, varr, j, es->l->f, false);
f = BM_face_create_verts(bm, varr, j, es->l->f, BM_CREATE_NOP, true);
BMO_elem_flag_enable(bm, f, ELE_NEW);
/* copy for loop data, otherwise UV's and vcols are no good.

4
source/blender/bmesh/operators/bmo_removedoubles.c
View File

@ -189,10 +189,8 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op)
v2 = BMO_slot_map_elem_get(slot_targetmap, v2);
}
f_new = BM_face_create_ngon(bm, v, v2, edges, a, BM_CREATE_NO_DOUBLE);
f_new = BM_face_create_ngon(bm, v, v2, edges, a, f, BM_CREATE_NO_DOUBLE);
if (f_new && (f_new != f)) {
BM_elem_attrs_copy(bm, bm, f, f_new);
a = 0;
BM_ITER_ELEM (l, &liter, f_new, BM_LOOPS_OF_FACE) {
l_new = loops[a];

6
source/blender/bmesh/operators/bmo_symmetrize.c
View File

@ -362,7 +362,7 @@ static bool symm_poly_next_crossing(const Symm *symm,
return false;
}
static BMFace *symm_face_create_v(BMesh *bm, BMFace *example,
static BMFace *symm_face_create_v(BMesh *bm, BMFace *f_example,
BMVert **fv, BMEdge **fe, int len)
{
BMFace *f_new;
@ -382,9 +382,7 @@ static BMFace *symm_face_create_v(BMesh *bm, BMFace *example,
BMO_elem_flag_enable(bm, fe[i], SYMM_OUTPUT_GEOM);
}
}
f_new = BM_face_create(bm, fv, fe, len, BM_CREATE_NO_DOUBLE);
if (example)
BM_elem_attrs_copy(bm, bm, example, f_new);
f_new = BM_face_create(bm, fv, fe, len, f_example, BM_CREATE_NO_DOUBLE);
BM_face_select_set(bm, f_new, true);
BMO_elem_flag_enable(bm, f_new, SYMM_OUTPUT_GEOM);

14
source/blender/bmesh/tools/bmesh_bevel.c
View File

@ -255,20 +255,8 @@ static BMFace *bev_create_ngon(BMesh *bm, BMVert **vert_arr, const int totv,
BMFace *f, *interp_f;
int i;
if (totv == 3) {
f = BM_face_create_quad_tri_v(bm, vert_arr, 3, facerep, FALSE);
}
else if (totv == 4) {
f = BM_face_create_quad_tri_v(bm, vert_arr, 4, facerep, FALSE);
}
else {
BMEdge **ee = BLI_array_alloca(ee, totv);
f = BM_face_create_verts(bm, vert_arr, totv, facerep, BM_CREATE_NOP, true);
for (i = 0; i < totv; i++) {
ee[i] = BM_edge_create(bm, vert_arr[i], vert_arr[(i + 1) % totv], NULL, BM_CREATE_NO_DOUBLE);
}
f = BM_face_create(bm, vert_arr, ee, totv, BM_CREATE_NOP);
}
if ((facerep || (face_arr && face_arr[0])) && f) {
BM_elem_attrs_copy(bm, bm, facerep ? facerep : face_arr[0], f);
if (do_interp) {

2
source/blender/bmesh/tools/bmesh_edgenet.c
View File

@ -193,7 +193,7 @@ static BMFace *bm_edgenet_face_from_path(
}
#endif
f = BM_face_create(bm, vert_arr, edge_arr, (int)path_len, BM_CREATE_NOP);
f = BM_face_create(bm, vert_arr, edge_arr, (int)path_len, NULL, BM_CREATE_NOP);
return f;
}

2
source/blender/editors/mesh/editmesh_rip.c
View File

@ -494,7 +494,7 @@ static void edbm_tagged_loop_pairs_do_fill_faces(BMesh *bm, UnorderedLoopPair *u
/* face should never exist */
BLI_assert(BM_face_exists(f_verts, f_verts[3] ? 4 : 3, &f) == false);
f = BM_face_create_quad_tri_v(bm, f_verts, f_verts[3] ? 4 : 3, f_example, false);
f = BM_face_create_verts(bm, f_verts, f_verts[3] ? 4 : 3, f_example, BM_CREATE_NOP, true);
l_iter = BM_FACE_FIRST_LOOP(f);

2
source/blender/modifiers/intern/MOD_skin.c
View File

@ -940,7 +940,7 @@ static void add_poly(SkinOutput *so,
BLI_assert(v3 != v4);
BLI_assert(v1 && v2 && v3);
f = BM_face_create_verts(so->bm, verts, v4 ? 4 : 3, BM_CREATE_NO_DOUBLE, true);
f = BM_face_create_verts(so->bm, verts, v4 ? 4 : 3, NULL, BM_CREATE_NO_DOUBLE, true);
if (so->smd->flag & MOD_SKIN_SMOOTH_SHADING)
BM_elem_flag_enable(f, BM_ELEM_SMOOTH);
f->mat_nr = so->mat_nr;

7
source/blender/python/bmesh/bmesh_py_types.c
View File

@ -2020,7 +2020,8 @@ static PyObject *bpy_bmfaceseq_new(BPy_BMElemSeq *self, PyObject *args)
/* Go ahead and make the face!
* --------------------------- */
f_new = BM_face_create_verts(bm, vert_array, vert_seq_len, BM_CREATE_NOP, true);
f_new = BM_face_create_verts(bm, vert_array, vert_seq_len,
py_face_example ? py_face_example->f : NULL, BM_CREATE_NOP, true);
if (UNLIKELY(f_new == NULL)) {
PyErr_SetString(PyExc_ValueError,
@ -2028,10 +2029,6 @@ static PyObject *bpy_bmfaceseq_new(BPy_BMElemSeq *self, PyObject *args)
goto cleanup;
}
if (py_face_example) {
BM_elem_attrs_copy(py_face_example->bm, bm, py_face_example->f, f_new);
}
ret = BPy_BMFace_CreatePyObject(bm, f_new);
/* pass through */