archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
e2a37db1d1c3a38b203159fdd5c0260ff6583d81
blender-archive/source/blender/bmesh/operators/bmo_inset.c

906 lines
27 KiB
C
Raw Blame History

/*
* ***** 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.
*
* Contributor(s): Campbell Barton
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/bmesh/operators/bmo_inset.c
* \ingroup bmesh
*
* Inset face regions.
* Inset individual faces.
*
*/
#include "MEM_guardedalloc.h"
#include "BLI_math.h"
#include "BLI_array.h"
#include "BLI_memarena.h"
#include "BKE_customdata.h"
#include "bmesh.h"
#include "intern/bmesh_operators_private.h" /* own include */
#define ELE_NEW 1
/* -------------------------------------------------------------------- */
/* Inset Individual */
/* Holds Per-Face Inset Edge Data */
typedef struct EdgeInsetInfo {
float no[3];
BMEdge *e_old;
BMEdge *e_new;
} EdgeInsetInfo;
/**
* Individual Face Inset.
* Find all tagged faces (f), duplicate edges around faces, inset verts of
* created edges, create new faces between old and new edges, fill face
* between connected new edges, kill old face (f).
*/
void bmo_inset_individual_exec(BMesh *bm, BMOperator *op)
{
BMEdge **f_edges = NULL;
BMVert **f_verts = NULL;
BMFace *f;
BMOIter oiter;
EdgeInsetInfo *eiinfo_arr = NULL;
BLI_array_declare(eiinfo_arr);
BLI_array_declare(f_edges);
BLI_array_declare(f_verts);
const float thickness = BMO_slot_float_get(op->slots_in, "thickness");
const float depth = BMO_slot_float_get(op->slots_in, "depth");
const bool use_even_offset = BMO_slot_bool_get(op->slots_in, "use_even_offset");
const bool use_interpolate = BMO_slot_bool_get(op->slots_in, "use_interpolate");
/* Only tag faces in slot */
BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, false);
BMO_slot_buffer_hflag_enable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, false);
BMO_ITER(f, &oiter, op->slots_in, "faces", BM_FACE) {
BMFace *f_new_inner;
BMLoop *l_iter, *l_first;
BMLoop *l_iter_inner = NULL;
int i;
BLI_array_empty(f_verts);
BLI_array_empty(f_edges);
BLI_array_empty(eiinfo_arr);
BLI_array_grow_items(f_verts, f->len);
BLI_array_grow_items(f_edges, f->len);
BLI_array_grow_items(eiinfo_arr, f->len);
/* create verts */
i = 0;
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do {
f_verts[i] = BM_vert_create(bm, l_iter->v->co, l_iter->v, 0);
i++;
} while ((l_iter = l_iter->next) != l_first);
/* make edges */
i = 0;
l_iter = l_first;
do {
f_edges[i] = BM_edge_create(bm, f_verts[i], f_verts[(i + 1) % f->len], l_iter->e, 0);
eiinfo_arr[i].e_new = f_edges[i];
eiinfo_arr[i].e_old = l_iter->e;
BM_edge_calc_face_tangent(l_iter->e, l_iter, eiinfo_arr[i].no);
/* Tagging (old elements) required when iterating over edges
* connected to verts for translation vector calculation */
BM_elem_flag_enable(l_iter->e, BM_ELEM_TAG);
BM_elem_index_set(l_iter->e, i); /* set_dirty! */
i++;
} while ((l_iter = l_iter->next) != l_first);
/* done with edges */
bm->elem_index_dirty |= BM_EDGE;
/* Calculate translation vector for new */
l_iter = l_first;
do {
EdgeInsetInfo *ei_prev = &eiinfo_arr[BM_elem_index_get(l_iter->prev->e)];
EdgeInsetInfo *ei_next = &eiinfo_arr[BM_elem_index_get(l_iter->e)];
float tvec[3];
float v_new_co[3];
int index = 0;
add_v3_v3v3(tvec, ei_prev->no, ei_next->no);
normalize_v3(tvec);
/* l->e is traversed in order */
index = BM_elem_index_get(l_iter->e);
copy_v3_v3(v_new_co, eiinfo_arr[index].e_new->v1->co);
if (use_even_offset) {
mul_v3_fl(tvec, shell_angle_to_dist(angle_normalized_v3v3(ei_prev->no, ei_next->no) / 2.0f));
}
/* Modify vertices and their normals */
madd_v3_v3fl(v_new_co, tvec, thickness);
/* Set normal, add depth and write new vertex position*/
copy_v3_v3(eiinfo_arr[index].e_new->v1->no, f->no);
madd_v3_v3fl(v_new_co, f->no, depth);
copy_v3_v3(eiinfo_arr[index].e_new->v1->co, v_new_co);
} while ((l_iter = l_iter->next) != l_first);
/* Create New Inset Faces */
f_new_inner = BM_face_create(bm, f_verts, f_edges, f->len, 0);
BLI_assert(f_new_inner != NULL); /* no reason it should fail */
// Don't tag, gives more useful inner/outer select option
// BMO_elem_flag_enable(bm, f_new_inner, ELE_NEW);
/* Copy Face Data */
/* interpolate loop data or just stretch */
if (use_interpolate) {
BM_face_interp_from_face(bm, f_new_inner, f, true);
}
else {
BM_elem_attrs_copy(bm, bm, f, f_new_inner);
}
l_iter_inner = BM_FACE_FIRST_LOOP(f_new_inner);
l_iter = l_first;
do {
BMFace *f_new_outer;
BMLoop *l_a;
BMLoop *l_b;
if (use_interpolate == false) {
BM_elem_attrs_copy(bm, bm, l_iter, l_iter_inner);
}
f_new_outer = BM_face_create_quad_tri(bm,
l_iter->v,
l_iter->next->v,
l_iter_inner->next->v,
l_iter_inner->v,
f, false);
BLI_assert(f_new_outer != NULL); /* no reason it should fail */
BM_elem_attrs_copy(bm, bm, f, f_new_outer);
BMO_elem_flag_enable(bm, f_new_outer, ELE_NEW);
BM_elem_flag_enable(f_new_outer, BM_ELEM_TAG);
/* Copy Loop Data */
l_a = BM_FACE_FIRST_LOOP(f_new_outer);
l_b = l_a->next;
/* first pair */
BM_elem_attrs_copy(bm, bm, l_iter, l_a);
BM_elem_attrs_copy(bm, bm, l_iter->next, l_b);
/* Move to the last two loops in new face */
l_a = l_b->next;
l_b = l_a->next;
/* This loop should always have >1 radials
* (associated edge connects new and old face) */
BM_elem_attrs_copy(bm, bm, l_iter_inner, l_b);
BM_elem_attrs_copy(bm, bm, use_interpolate ? l_iter_inner->next : l_iter->next, l_a);
} while ((l_iter_inner = l_iter_inner->next),
(l_iter = l_iter->next) != l_first);
BM_face_kill(bm, f);
}
/* we could flag new edges/verts too, is it useful? */
BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, ELE_NEW);
BLI_array_free(f_verts);
BLI_array_free(f_edges);
BLI_array_free(eiinfo_arr);
}
/* -------------------------------------------------------------------- */
/* Inset Region */
typedef struct SplitEdgeInfo {
float no[3];
float length;
BMEdge *e_old;
BMEdge *e_new;
BMLoop *l;
} SplitEdgeInfo;
/**
* Interpolation, this is more complex for regions since we're not creating new faces
* and throwing away old ones, so instead, store face data needed for interpolation.
*
* \note This uses CustomData functions in quite a low-level way which should be
* avoided, but in this case its hard to do without storing a duplicate mesh. */
/* just enough of a face to store interpolation data we can use once the inset is done */
typedef struct InterpFace {
BMFace *f;
void **blocks_l;
void **blocks_v;
float (*cos_2d)[2];
float axis_mat[3][3];
} InterpFace;
/* basically a clone of #BM_vert_interp_from_face */
static void bm_interp_face_store(InterpFace *iface, BMesh *bm, BMFace *f, MemArena *interp_arena)
{
BMLoop *l_iter, *l_first;
void **blocks_l = iface->blocks_l = BLI_memarena_alloc(interp_arena, sizeof(*iface->blocks_l) * f->len);
void **blocks_v = iface->blocks_v = BLI_memarena_alloc(interp_arena, sizeof(*iface->blocks_v) * f->len);
float (*cos_2d)[2] = iface->cos_2d = BLI_memarena_alloc(interp_arena, sizeof(*iface->cos_2d) * f->len);
void *axis_mat = iface->axis_mat;
int i;
axis_dominant_v3_to_m3(axis_mat, f->no);
iface->f = f;
i = 0;
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do {
mul_v2_m3v3(cos_2d[i], axis_mat, l_iter->v->co);
blocks_l[i] = NULL;
CustomData_bmesh_copy_data(&bm->ldata, &bm->ldata, l_iter->head.data, &blocks_l[i]);
/* if we were not modifying the loops later we would do... */
// blocks[i] = l_iter->head.data;
blocks_v[i] = NULL;
CustomData_bmesh_copy_data(&bm->vdata, &bm->vdata, l_iter->v->head.data, &blocks_v[i]);
/* use later for index lookups */
BM_elem_index_set(l_iter, i); /* set_ok */
} while (i++, (l_iter = l_iter->next) != l_first);
}
static void bm_interp_face_free(InterpFace *iface, BMesh *bm)
{
void **blocks_l = iface->blocks_l;
void **blocks_v = iface->blocks_v;
int i;
for (i = 0; i < iface->f->len; i++) {
CustomData_bmesh_free_block(&bm->ldata, &blocks_l[i]);
CustomData_bmesh_free_block(&bm->vdata, &blocks_v[i]);
}
}
/**
* return the tag loop where there is...
* - only 1 tagged face attached to this edge.
* - 1 or more untagged faces.
*
* \note this function looks to be expensive
* but in most cases it will only do 2 iterations.
*/
static BMLoop *bm_edge_is_mixed_face_tag(BMLoop *l)
{
if (LIKELY(l != NULL)) {
int tot_tag = 0;
int tot_untag = 0;
BMLoop *l_iter;
BMLoop *l_tag = NULL;
l_iter = l;
do {
if (BM_elem_flag_test(l_iter->f, BM_ELEM_TAG)) {
/* more than one tagged face - bail out early! */
if (tot_tag == 1) {
return NULL;
}
l_tag = l_iter;
tot_tag++;
}
else {
tot_untag++;
}
} while ((l_iter = l_iter->radial_next) != l);
return ((tot_tag == 1) && (tot_untag >= 1)) ? l_tag : NULL;
}
else {
return NULL;
}
}
/**
* implementation is as follows...
*
* - set all faces as tagged/untagged based on selection.
* - find all edges that have 1 tagged, 1 untagged face.
* - separate these edges and tag vertices, set their index to point to the original edge.
* - build faces between old/new edges.
* - inset the new edges into their faces.
*/
void bmo_inset_region_exec(BMesh *bm, BMOperator *op)
{
const bool use_outset = BMO_slot_bool_get(op->slots_in, "use_outset");
const bool use_boundary = BMO_slot_bool_get(op->slots_in, "use_boundary") && (use_outset == false);
const bool use_even_offset = BMO_slot_bool_get(op->slots_in, "use_even_offset");
const bool use_even_boundry = use_even_offset; /* could make own option */
const bool use_relative_offset = BMO_slot_bool_get(op->slots_in, "use_relative_offset");
const bool use_interpolate = BMO_slot_bool_get(op->slots_in, "use_interpolate");
const float thickness = BMO_slot_float_get(op->slots_in, "thickness");
const float depth = BMO_slot_float_get(op->slots_in, "depth");
int edge_info_len = 0;
BMIter iter;
SplitEdgeInfo *edge_info;
SplitEdgeInfo *es;
/* Interpolation Vars */
/* an array alligned with faces but only fill items which are used. */
InterpFace **iface_array = NULL;
int iface_array_len;
MemArena *interp_arena = NULL;
BMVert *v;
BMEdge *e;
BMFace *f;
int i, j, k;
if (use_interpolate) {
interp_arena = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE, __func__);
/* warning, we could be more clever here and not over alloc */
iface_array = MEM_callocN(sizeof(*iface_array) * bm->totface, __func__);
iface_array_len = bm->totface;
}
if (use_outset == false) {
BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, false);
BMO_slot_buffer_hflag_enable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, false);
}
else {
BM_mesh_elem_hflag_enable_all(bm, BM_FACE, BM_ELEM_TAG, false);
BMO_slot_buffer_hflag_disable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, false);
}
/* first count all inset edges we will split */
/* fill in array and initialize tagging */
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (
/* tag if boundary is enabled */
(use_boundary && BM_edge_is_boundary(e) && BM_elem_flag_test(e->l->f, BM_ELEM_TAG)) ||
/* tag if edge is an interior edge inbetween a tagged and untagged face */
(bm_edge_is_mixed_face_tag(e->l)))
{
/* tag */
BM_elem_flag_enable(e->v1, BM_ELEM_TAG);
BM_elem_flag_enable(e->v2, BM_ELEM_TAG);
BM_elem_flag_enable(e, BM_ELEM_TAG);
BM_elem_index_set(e, edge_info_len); /* set_dirty! */
edge_info_len++;
}
else {
BM_elem_flag_disable(e->v1, BM_ELEM_TAG);
BM_elem_flag_disable(e->v2, BM_ELEM_TAG);
BM_elem_flag_disable(e, BM_ELEM_TAG);
BM_elem_index_set(e, -1); /* set_dirty! */
}
}
bm->elem_index_dirty |= BM_EDGE;
edge_info = MEM_mallocN(edge_info_len * sizeof(SplitEdgeInfo), __func__);
/* fill in array and initialize tagging */
es = edge_info;
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
i = BM_elem_index_get(e);
if (i != -1) {
/* calc edge-split info */
es->length = BM_edge_calc_length(e);
es->e_old = e;
es++;
/* initialize no and e_new after */
}
}
for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
if ((es->l = bm_edge_is_mixed_face_tag(es->e_old->l))) {
/* do nothing */
}
else {
es->l = es->e_old->l; /* must be a boundary */
}
/* run the separate arg */
bmesh_edge_separate(bm, es->e_old, es->l);
/* calc edge-split info */
es->e_new = es->l->e;
BM_edge_calc_face_tangent(es->e_new, es->l, es->no);
if (es->e_new == es->e_old) { /* happens on boundary edges */
/* take care here, we're creating this double edge which _must_ have its verts replaced later on */
es->e_old = BM_edge_create(bm, es->e_new->v1, es->e_new->v2, es->e_new, 0);
}
/* store index back to original in 'edge_info' */
BM_elem_index_set(es->e_new, i);
BM_elem_flag_enable(es->e_new, BM_ELEM_TAG);
/* important to tag again here */
BM_elem_flag_enable(es->e_new->v1, BM_ELEM_TAG);
BM_elem_flag_enable(es->e_new->v2, BM_ELEM_TAG);
/* initialize interpolation vars */
/* this could go in its own loop,
* only use the 'es->l->f' so we don't store loops for faces which have no mixed selection
*
* note: faces on the other side of the inset will be interpolated too since this is hard to
* detect, just allow it even though it will cause some redundant interpolation */
if (use_interpolate) {
BMIter viter;
BM_ITER_ELEM (v, &viter, es->l->e, BM_VERTS_OF_EDGE) {
BMIter fiter;
BM_ITER_ELEM (f, &fiter, v, BM_FACES_OF_VERT) {
const int j = BM_elem_index_get(f);
if (iface_array[j] == NULL) {
InterpFace *iface = BLI_memarena_alloc(interp_arena, sizeof(*iface));
bm_interp_face_store(iface, bm, f, interp_arena);
iface_array[j] = iface;
}
}
}
}
/* done interpolation */
}
/* show edge normals for debugging */
#if 0
for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
float tvec[3];
BMVert *v1, *v2;
mid_v3_v3v3(tvec, es->e_new->v1->co, es->e_new->v2->co);
v1 = BM_vert_create(bm, tvec, NULL);
v2 = BM_vert_create(bm, tvec, NULL);
madd_v3_v3fl(v2->co, es->no, 0.1f);
BM_edge_create(bm, v1, v2, NULL, 0);
}
#endif
/* execute the split and position verts, it would be most obvious to loop over verts
* here but don't do this since we will be splitting them off (iterating stuff you modify is bad juju)
* instead loop over edges then their verts */
for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
for (j = 0; j < 2; j++) {
v = (j == 0) ? es->e_new->v1 : es->e_new->v2;
/* end confusing part - just pretend this is a typical loop on verts */
/* only split of tagged verts - used by separated edges */
/* comment the first part because we know this verts in a tagged face */
if (/* v->e && */BM_elem_flag_test(v, BM_ELEM_TAG)) {
BMVert **vout;
int r_vout_len;
BMVert *v_glue = NULL;
/* disable touching twice, this _will_ happen if the flags not disabled */
BM_elem_flag_disable(v, BM_ELEM_TAG);
bmesh_vert_separate(bm, v, &vout, &r_vout_len);
v = NULL; /* don't use again */
/* in some cases the edge doesn't split off */
if (r_vout_len == 1) {
MEM_freeN(vout);
continue;
}
for (k = 0; k < r_vout_len; k++) {
BMVert *v_split = vout[k]; /* only to avoid vout[k] all over */
/* need to check if this vertex is from a */
int vert_edge_tag_tot = 0;
int vecpair[2];
/* find adjacent */
BM_ITER_ELEM (e, &iter, v_split, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e, BM_ELEM_TAG) &&
e->l && BM_elem_flag_test(e->l->f, BM_ELEM_TAG))
{
if (vert_edge_tag_tot < 2) {
vecpair[vert_edge_tag_tot] = BM_elem_index_get(e);
BLI_assert(vecpair[vert_edge_tag_tot] != -1);
}
vert_edge_tag_tot++;
}
}
if (vert_edge_tag_tot != 0) {
float tvec[3];
if (vert_edge_tag_tot >= 2) { /* 2 edge users - common case */
/* now there are 2 cases to check for,
*
* if both edges use the same face OR both faces have the same normal,
* ...then we can calculate an edge that fits nicely between the 2 edge normals.
*
* Otherwise use the shared edge OR the corner defined by these 2 face normals,
* when both edges faces are adjacent this works best but even when this vertex
* fans out faces it should work ok.
*/
SplitEdgeInfo *e_info_a = &edge_info[vecpair[0]];
SplitEdgeInfo *e_info_b = &edge_info[vecpair[1]];
BMFace *f_a = e_info_a->l->f;
BMFace *f_b = e_info_b->l->f;
/* we use this as either the normal OR to find the right direction for the
* cross product between both face normals */
add_v3_v3v3(tvec, e_info_a->no, e_info_b->no);
/* epsilon increased to fix [#32329] */
if ((f_a == f_b) || compare_v3v3(f_a->no, f_b->no, 0.001f)) {
normalize_v3(tvec);
}
else {
/* these lookups are very quick */
BMLoop *l_other_a = BM_loop_other_vert_loop(e_info_a->l, v_split);
BMLoop *l_other_b = BM_loop_other_vert_loop(e_info_b->l, v_split);
if (l_other_a->v == l_other_b->v) {
/* both edges faces are adjacent, but we don't need to know the shared edge
* having both verts is enough. */
sub_v3_v3v3(tvec, l_other_a->v->co, v_split->co);
}
else {
/* faces don't touch,
* just get cross product of their normals, its *good enough*
*/
float tno[3];
cross_v3_v3v3(tno, f_a->no, f_b->no);
if (dot_v3v3(tvec, tno) < 0.0f) {
negate_v3(tno);
}
copy_v3_v3(tvec, tno);
}
normalize_v3(tvec);
}
/* scale by edge angle */
if (use_even_offset) {
mul_v3_fl(tvec, shell_angle_to_dist(angle_normalized_v3v3(e_info_a->no,
e_info_b->no) / 2.0f));
}
/* scale relative to edge lengths */
if (use_relative_offset) {
mul_v3_fl(tvec, (edge_info[vecpair[0]].length + edge_info[vecpair[1]].length) / 2.0f);
}
}
else if (vert_edge_tag_tot == 1) { /* 1 edge user - boundary vert, not so common */
const float *e_no_a = edge_info[vecpair[0]].no;
if (use_even_boundry) {
/* This case where only one edge attached to v_split
* is used - ei - the face to inset is on a boundary.
*
* We want the inset to align flush with the
* boundary edge, not the normal of the interior
* <--- edge which would give an unsightly bump.
* --+-------------------------+---------------+--
* |^v_other ^e_other /^v_split |
* | / |
* | / |
* | / <- tag split edge |
* | / |
* | / |
* | / |
* --+-----------------+-----------------------+--
* | |
* | |
*
* note, the fact we are doing location comparisons on verts that are moved about
* doesn't matter because the direction will remain the same in this case.
*/
BMEdge *e_other;
BMVert *v_other;
/* loop will always be either next of prev */
BMLoop *l = v_split->e->l;
if (l->prev->v == v_split) {
l = l->prev;
}
else if (l->next->v == v_split) {
l = l->next;
}
else if (l->v == v_split) {
/* pass */
}
else {
/* should never happen */
BLI_assert(0);
}
/* find the edge which is _not_ being split here */
if (!BM_elem_flag_test(l->e, BM_ELEM_TAG)) {
e_other = l->e;
}
else if (!BM_elem_flag_test(l->prev->e, BM_ELEM_TAG)) {
e_other = l->prev->e;
}
else {
BLI_assert(0);
e_other = NULL;
}
v_other = BM_edge_other_vert(e_other, v_split);
sub_v3_v3v3(tvec, v_other->co, v_split->co);
normalize_v3(tvec);
if (use_even_offset) {
mul_v3_fl(tvec, shell_angle_to_dist(angle_normalized_v3v3(e_no_a, tvec)));
}
}
else {
copy_v3_v3(tvec, e_no_a);
}
/* use_even_offset - doesn't apply here */
/* scale relative to edge length */
if (use_relative_offset) {
mul_v3_fl(tvec, edge_info[vecpair[0]].length);
}
}
else {
/* should never happen */
BLI_assert(0);
zero_v3(tvec);
}
/* apply the offset */
madd_v3_v3fl(v_split->co, tvec, thickness);
}
/* this saves expensive/slow glue check for common cases */
if (r_vout_len > 2) {
bool ok = true;
/* last step, NULL this vertex if has a tagged face */
BM_ITER_ELEM (f, &iter, v_split, BM_FACES_OF_VERT) {
if (BM_elem_flag_test(f, BM_ELEM_TAG)) {
ok = false;
break;
}
}
if (ok) {
if (v_glue == NULL) {
v_glue = v_split;
}
else {
BM_vert_splice(bm, v_split, v_glue);
}
}
}
/* end glue */
}
MEM_freeN(vout);
}
}
}
if (use_interpolate) {
for (i = 0; i < iface_array_len; i++) {
if (iface_array[i]) {
InterpFace *iface = iface_array[i];
BM_face_interp_from_face_ex(bm, iface->f, iface->f, true,
iface->blocks_l, iface->blocks_v, iface->cos_2d, iface->axis_mat);
}
}
}
/* create faces */
for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
BMVert *varr[4] = {NULL};
/* get the verts in the correct order */
BM_edge_ordered_verts_ex(es->e_new, &varr[1], &varr[0], es->l);
#if 0
if (varr[0] == es->e_new->v1) {
varr[2] = es->e_old->v2;
varr[3] = es->e_old->v1;
}
else {
varr[2] = es->e_old->v1;
varr[3] = es->e_old->v2;
}
j = 4;
#else
/* slightly trickier check - since we can't assume the verts are split */
j = 2; /* 2 edges are set */
if (varr[0] == es->e_new->v1) {
if (es->e_old->v2 != es->e_new->v2) { varr[j++] = es->e_old->v2; }
if (es->e_old->v1 != es->e_new->v1) { varr[j++] = es->e_old->v1; }
}
else {
if (es->e_old->v1 != es->e_new->v1) { varr[j++] = es->e_old->v1; }
if (es->e_old->v2 != es->e_new->v2) { varr[j++] = es->e_old->v2; }
}
if (j == 2) {
/* can't make face! */
continue;
}
#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);
BMO_elem_flag_enable(bm, f, ELE_NEW);
/* copy for loop data, otherwise UV's and vcols are no good.
* tiny speedup here we could be more clever and copy from known adjacent data
* also - we could attempt to interpolate the loop data, this would be much slower but more useful too */
#if 0
/* don't use this because face boundaries have no adjacent loops and won't be filled in.
* instead copy from the opposite side with the code below */
BM_face_copy_shared(bm, f);
#else
{
/* 2 inner loops on the edge between the new face and the original */
BMLoop *l_a;
BMLoop *l_b;
BMLoop *l_a_other;
BMLoop *l_b_other;
l_a = BM_FACE_FIRST_LOOP(f);
l_b = l_a->next;
/* we know this side has a radial_next because of the order of created verts in the quad */
l_a_other = BM_edge_other_loop(l_a->e, l_a);
l_b_other = BM_edge_other_loop(l_a->e, l_b);
BM_elem_attrs_copy(bm, bm, l_a_other, l_a);
BM_elem_attrs_copy(bm, bm, l_b_other, l_b);
/* step around to the opposite side of the quad - warning, this may have no other edges! */
l_a = l_a->next->next;
l_b = l_a->next;
/* swap a<->b intentionally */
if (use_interpolate) {
InterpFace *iface = iface_array[BM_elem_index_get(es->l->f)];
const int i_a = BM_elem_index_get(l_a_other);
const int i_b = BM_elem_index_get(l_b_other);
CustomData_bmesh_copy_data(&bm->ldata, &bm->ldata, iface->blocks_l[i_a], &l_b->head.data);
CustomData_bmesh_copy_data(&bm->ldata, &bm->ldata, iface->blocks_l[i_b], &l_a->head.data);
}
else {
BM_elem_attrs_copy(bm, bm, l_a_other, l_b);
BM_elem_attrs_copy(bm, bm, l_b_other, l_a);
}
}
}
#endif
if (use_interpolate) {
for (i = 0; i < iface_array_len; i++) {
if (iface_array[i]) {
bm_interp_face_free(iface_array[i], bm);
}
}
BLI_memarena_free(interp_arena);
MEM_freeN(iface_array);
}
/* we could flag new edges/verts too, is it useful? */
BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, ELE_NEW);
/* cheap feature to add depth to the inset */
if (depth != 0.0f) {
float (*varr_co)[3];
BMOIter oiter;
/* we need to re-calculate tagged normals, but for this purpose we can copy tagged verts from the
* faces they inset from, */
for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
zero_v3(es->e_new->v1->no);
zero_v3(es->e_new->v2->no);
}
for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
float *no = es->l->f->no;
add_v3_v3(es->e_new->v1->no, no);
add_v3_v3(es->e_new->v2->no, no);
}
for (i = 0, es = edge_info; i < edge_info_len; i++, es++) {
/* annoying, avoid normalizing twice */
if (len_squared_v3(es->e_new->v1->no) != 1.0f) {
normalize_v3(es->e_new->v1->no);
}
if (len_squared_v3(es->e_new->v2->no) != 1.0f) {
normalize_v3(es->e_new->v2->no);
}
}
/* done correcting edge verts normals */
/* untag verts */
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
/* tag face verts */
BMO_ITER (f, &oiter, op->slots_in, "faces", BM_FACE) {
BM_ITER_ELEM (v, &iter, f, BM_VERTS_OF_FACE) {
BM_elem_flag_enable(v, BM_ELEM_TAG);
}
}
/* do in 2 passes so moving the verts doesn't feed back into face angle checks
* which BM_vert_calc_shell_factor uses. */
/* over allocate */
varr_co = MEM_callocN(sizeof(*varr_co) * bm->totvert, __func__);
BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
const float fac = (depth *
(use_relative_offset ? BM_vert_calc_mean_tagged_edge_length(v) : 1.0f) *
(use_even_boundry ? BM_vert_calc_shell_factor(v) : 1.0f));
madd_v3_v3v3fl(varr_co[i], v->co, v->no, fac);
}
}
BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(v, BM_ELEM_TAG)) {
copy_v3_v3(v->co, varr_co[i]);
}
}
MEM_freeN(varr_co);
}
MEM_freeN(edge_info);
}
View Git Blame Copy Permalink