blender
/
blender
136
407
Fork 589
Code Issues 6.3k Pull Requests 767 Projects 19 Wiki Activity

EditMesh: wireframe tool, add offset and vgroup support (not used yet)

This commit is contained in:
Campbell Barton 2013-12-22 06:54:37 +11:00
parent c80c596194
commit 01acc2a7dc
6 changed files with 631 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/bmesh/CMakeLists.txt
View File

@ -136,6 +136,8 @@ set(SRC
tools/bmesh_path.h
tools/bmesh_triangulate.c
tools/bmesh_triangulate.h
tools/bmesh_wireframe.c
tools/bmesh_wireframe.h
bmesh_class.h

6
source/blender/bmesh/intern/bmesh_opdefines.c
View File

@ -1694,12 +1694,16 @@ static BMOpDefine bmo_wireframe_def = {
"wireframe",
/* slots_in */
{{"faces", BMO_OP_SLOT_ELEMENT_BUF, {BM_FACE}}, /* input faces */
{"thickness", BMO_OP_SLOT_FLT},
{"offset", BMO_OP_SLOT_FLT},
{"use_replace", BMO_OP_SLOT_BOOL},
{"use_boundary", BMO_OP_SLOT_BOOL},
{"use_even_offset", BMO_OP_SLOT_BOOL},
{"use_crease", BMO_OP_SLOT_BOOL},
{"crease_weight", BMO_OP_SLOT_FLT},
{"thickness", BMO_OP_SLOT_FLT},
{"use_relative_offset", BMO_OP_SLOT_BOOL},
{"depth", BMO_OP_SLOT_FLT},
{"material_offset", BMO_OP_SLOT_INT},
{{'\0'}},
},
/* slots_out */

409
source/blender/bmesh/operators/bmo_wireframe.c
View File

@ -28,408 +28,43 @@
#include "MEM_guardedalloc.h"
#include "BLI_math.h"
#include "DNA_material_types.h"
#include "BKE_customdata.h"
#include "BLI_sys_types.h"
#include "BLI_utildefines.h"
#include "bmesh.h"
#include "tools/bmesh_wireframe.h"
#include "intern/bmesh_operators_private.h" /* own include */
static BMLoop *bm_edge_tag_faceloop(BMEdge *e)
{
BMLoop *l, *l_first;
l = l_first = e->l;
do {
if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
return l;
}
} while ((l = l->radial_next) != l_first);
/* in the case this is used, we know this will never happen */
return NULL;
}
static void bm_vert_boundary_tangent(BMVert *v, float r_no[3], float r_no_face[3],
BMVert **r_va_other, BMVert **r_vb_other)
{
BMIter iter;
BMEdge *e_iter;
BMEdge *e_a = NULL, *e_b = NULL;
BMVert *v_a, *v_b;
BMLoop *l_a, *l_b;
float no_face[3], no_edge[3];
float tvec_a[3], tvec_b[3];
/* get 2 boundary edges, there should only _be_ 2,
* in case there are more - results wont be valid of course */
BM_ITER_ELEM (e_iter, &iter, v, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e_iter, BM_ELEM_TAG)) {
if (e_a == NULL) {
e_a = e_iter;
}
else {
e_b = e_iter;
break;
}
}
}
if (e_a && e_b) {
/* note, with an incorrectly flushed selection this can crash */
l_a = bm_edge_tag_faceloop(e_a);
l_b = bm_edge_tag_faceloop(e_b);
/* average edge face normal */
add_v3_v3v3(no_face, l_a->f->no, l_b->f->no);
/* average edge direction */
v_a = BM_edge_other_vert(e_a, v);
v_b = BM_edge_other_vert(e_b, v);
sub_v3_v3v3(tvec_a, v->co, v_a->co);
sub_v3_v3v3(tvec_b, v_b->co, v->co);
normalize_v3(tvec_a);
normalize_v3(tvec_b);
add_v3_v3v3(no_edge, tvec_a, tvec_b); /* not unit length but this is ok */
/* check are we flipped the right way */
BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
BM_edge_calc_face_tangent(e_b, l_b, tvec_b);
add_v3_v3(tvec_a, tvec_b);
*r_va_other = v_a;
*r_vb_other = v_b;
}
else {
/* degenerate case - vertex connects a boundary edged face to other faces,
* so we have only one boundary face - only use it for calculations */
l_a = bm_edge_tag_faceloop(e_a);
copy_v3_v3(no_face, l_a->f->no);
/* edge direction */
v_a = BM_edge_other_vert(e_a, v);
v_b = NULL;
sub_v3_v3v3(no_edge, v->co, v_a->co);
/* check are we flipped the right way */
BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
*r_va_other = NULL;
*r_vb_other = NULL;
}
/* find the normal */
cross_v3_v3v3(r_no, no_edge, no_face);
normalize_v3(r_no);
if (dot_v3v3(r_no, tvec_a) > 0.0f) {
negate_v3(r_no);
}
copy_v3_v3(r_no_face, no_face);
}
/* check if we are the only tagged loop-face around this edge */
static bool bm_loop_is_radial_boundary(BMLoop *l_first)
{
BMLoop *l = l_first->radial_next;
if (l == l_first) {
return true; /* a real boundary */
}
else {
do {
if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
return false;
}
} while ((l = l->radial_next) != l_first);
}
return true;
}
void bmo_wireframe_exec(BMesh *bm, BMOperator *op)
{
const float offset = BMO_slot_float_get(op->slots_in, "thickness");
const float offset_fac = BMO_slot_float_get(op->slots_in, "offset");
const bool use_replace = BMO_slot_bool_get(op->slots_in, "use_replace");
const bool use_boundary = BMO_slot_bool_get(op->slots_in, "use_boundary");
const bool use_even_offset = BMO_slot_bool_get(op->slots_in, "use_even_offset");
const bool use_relative_offset = BMO_slot_bool_get(op->slots_in, "use_relative_offset");
const bool use_crease = BMO_slot_bool_get(op->slots_in, "use_crease");
const float depth = BMO_slot_float_get(op->slots_in, "thickness");
const float inset = depth;
int cd_edge_crease_offset = use_crease ? CustomData_get_offset(&bm->edata, CD_CREASE) : -1;
const float crease_weight = 1.0f;
const float crease_weight = BMO_slot_float_get(op->slots_in, "crease_weight");
const int totvert_orig = bm->totvert;
BM_mesh_elem_hflag_disable_all(bm, BM_EDGE | BM_FACE, BM_ELEM_TAG, false);
BMO_slot_buffer_hflag_enable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, false);
BMOIter oiter;
BMIter iter;
BMIter itersub;
/* filled only with boundary verts */
BMVert **verts_src = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
BMVert **verts_neg = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
BMVert **verts_pos = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
/* will over-alloc, but makes for easy lookups by index to keep aligned */
BMVert **verts_boundary = use_boundary ?
MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__) : NULL;
float *verts_relfac = use_relative_offset ?
MEM_mallocN(sizeof(float) * totvert_orig, __func__) : NULL;
/* may over-alloc if not all faces have wire */
BMVert **verts_loop;
int verts_loop_tot = 0;
BMVert *v_src;
BMFace *f_src;
BMLoop *l;
float tvec[3];
float fac;
int i;
if (use_crease && cd_edge_crease_offset == -1) {
BM_data_layer_add(bm, &bm->edata, CD_CREASE);
cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
}
BM_mesh_elem_index_ensure(bm, BM_VERT);
BM_ITER_MESH_INDEX (v_src, &iter, bm, BM_VERTS_OF_MESH, i) {
BM_elem_flag_disable(v_src, BM_ELEM_TAG);
verts_src[i] = v_src;
}
/* setup tags, all faces and verts will be tagged which will be duplicated */
BM_mesh_elem_hflag_disable_all(bm, BM_FACE | BM_EDGE, BM_ELEM_TAG, false);
BMO_ITER (f_src, &oiter, op->slots_in, "faces", BM_FACE) {
verts_loop_tot += f_src->len;
BM_elem_flag_enable(f_src, BM_ELEM_TAG);
BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
/* also tag boundary edges */
BM_elem_flag_set(l->e, BM_ELEM_TAG, bm_loop_is_radial_boundary(l));
}
}
/* duplicate tagged verts */
for (i = 0; i < totvert_orig; i++) {
v_src = verts_src[i];
if (BM_elem_flag_test(v_src, BM_ELEM_TAG)) {
fac = depth;
if (use_relative_offset) {
verts_relfac[i] = BM_vert_calc_mean_tagged_edge_length(v_src);
fac *= verts_relfac[i];
}
madd_v3_v3v3fl(tvec, v_src->co, v_src->no, -fac);
verts_neg[i] = BM_vert_create(bm, tvec, v_src, BM_CREATE_NOP);
madd_v3_v3v3fl(tvec, v_src->co, v_src->no, fac);
verts_pos[i] = BM_vert_create(bm, tvec, v_src, BM_CREATE_NOP);
}
else {
/* could skip this */
verts_src[i] = NULL;
verts_neg[i] = NULL;
verts_pos[i] = NULL;
}
/* conflicts with BM_vert_calc_mean_tagged_edge_length */
if (use_relative_offset == false) {
BM_elem_flag_disable(v_src, BM_ELEM_TAG);
}
}
if (use_relative_offset) {
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
}
verts_loop = MEM_mallocN(sizeof(BMVert *) * verts_loop_tot, __func__);
verts_loop_tot = 0; /* count up again */
BMO_ITER (f_src, &oiter, op->slots_in, "faces", BM_FACE) {
BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
BM_elem_index_set(l, verts_loop_tot); /* set_loop */
BM_loop_calc_face_tangent(l, tvec);
/* create offset vert */
fac = inset;
if (use_even_offset) {
fac *= shell_angle_to_dist(((float)M_PI - BM_loop_calc_face_angle(l)) * 0.5f);
}
if (use_relative_offset) {
fac *= verts_relfac[BM_elem_index_get(l->v)];
}
madd_v3_v3v3fl(tvec, l->v->co, tvec, fac);
verts_loop[verts_loop_tot] = BM_vert_create(bm, tvec, l->v, BM_CREATE_NOP);
if (use_boundary) {
if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) { /* is this a boundary? */
BMLoop *l_pair[2] = {l, l->next};
BM_elem_flag_enable(l->e, BM_ELEM_TAG);
for (i = 0; i < 2; i++) {
if (!BM_elem_flag_test(l_pair[i]->v, BM_ELEM_TAG)) {
float no_face[3];
BMVert *va_other;
BMVert *vb_other;
BM_elem_flag_enable(l_pair[i]->v, BM_ELEM_TAG);
bm_vert_boundary_tangent(l_pair[i]->v, tvec, no_face, &va_other, &vb_other);
/* create offset vert */
/* similar to code above but different angle calc */
fac = inset;
if (use_even_offset) {
if (va_other) { /* for verts with only one boundary edge - this will be NULL */
fac *= shell_angle_to_dist(((float)M_PI - angle_on_axis_v3v3v3_v3(va_other->co,
l_pair[i]->v->co,
vb_other->co,
no_face)) * 0.5f);
}
}
if (use_relative_offset) {
fac *= verts_relfac[BM_elem_index_get(l_pair[i]->v)];
}
madd_v3_v3v3fl(tvec, l_pair[i]->v->co, tvec, fac);
verts_boundary[BM_elem_index_get(l_pair[i]->v)] = BM_vert_create(bm, tvec, l_pair[i]->v, BM_CREATE_NOP);
}
}
}
}
verts_loop_tot++;
}
}
BMO_ITER (f_src, &oiter, op->slots_in, "faces", BM_FACE) {
BM_elem_flag_disable(f_src, BM_ELEM_TAG);
BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
BMFace *f_new;
BMLoop *l_new;
BMLoop *l_next = l->next;
BMVert *v_l1 = verts_loop[BM_elem_index_get(l)];
BMVert *v_l2 = verts_loop[BM_elem_index_get(l_next)];
BMVert *v_src_l1 = l->v;
BMVert *v_src_l2 = l_next->v;
const int i_1 = BM_elem_index_get(v_src_l1);
const int i_2 = BM_elem_index_get(v_src_l2);
BMVert *v_neg1 = verts_neg[i_1];
BMVert *v_neg2 = verts_neg[i_2];
BMVert *v_pos1 = verts_pos[i_1];
BMVert *v_pos2 = verts_pos[i_2];
f_new = BM_face_create_quad_tri(bm, v_l1, v_l2, v_neg2, v_neg1, f_src, false);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l, l_new);
BM_elem_attrs_copy(bm, bm, l, l_new->prev);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
f_new = BM_face_create_quad_tri(bm, v_l2, v_l1, v_pos1, v_pos2, f_src, false);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
BM_elem_attrs_copy(bm, bm, l, l_new->next);
BM_elem_attrs_copy(bm, bm, l, l_new->next->next);
if (use_boundary) {
if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) {
/* we know its a boundary and this is the only face user (which is being wire'd) */
/* we know we only touch this edge/face once */
BMVert *v_b1 = verts_boundary[i_1];
BMVert *v_b2 = verts_boundary[i_2];
f_new = BM_face_create_quad_tri(bm, v_b2, v_b1, v_neg1, v_neg2, f_src, false);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
BM_elem_attrs_copy(bm, bm, l, l_new->next);
BM_elem_attrs_copy(bm, bm, l, l_new->next->next);
f_new = BM_face_create_quad_tri(bm, v_b1, v_b2, v_pos2, v_pos1, f_src, false);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l, l_new);
BM_elem_attrs_copy(bm, bm, l, l_new->prev);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
if (use_crease) {
BMEdge *e_new;
e_new = BM_edge_exists(v_pos1, v_b1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_pos2, v_b2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg1, v_b1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg2, v_b2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
}
}
}
if (use_crease) {
BMEdge *e_new;
e_new = BM_edge_exists(v_pos1, v_l1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_pos2, v_l2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg1, v_l1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg2, v_l2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
}
}
}
if (use_boundary) {
MEM_freeN(verts_boundary);
}
if (use_relative_offset) {
MEM_freeN(verts_relfac);
}
MEM_freeN(verts_src);
MEM_freeN(verts_neg);
MEM_freeN(verts_pos);
MEM_freeN(verts_loop);
BM_mesh_wireframe(
bm,
offset, offset_fac, 0.0f,
use_replace,
use_boundary,
use_even_offset, use_relative_offset,
use_crease, crease_weight,
/* dummy vgroup */
-1, false,
0, MAXMAT,
true);
BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "faces.out", BM_FACE, BM_ELEM_TAG);
}

541
source/blender/bmesh/tools/bmesh_wireframe.c Normal file
View File

@ -0,0 +1,541 @@
/*
* ***** 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/bmesh_wireframe.c
* \ingroup bmesh
*
* Creates a solid wireframe from conected faces.
*/
#include "MEM_guardedalloc.h"
#include "DNA_object_types.h"
#include "DNA_meshdata_types.h"
#include "BLI_math.h"
#include "bmesh.h"
#include "BKE_deform.h"
#include "BKE_customdata.h"
#include "bmesh_wireframe.h"
static BMLoop *bm_edge_tag_faceloop(BMEdge *e)
{
BMLoop *l, *l_first;
l = l_first = e->l;
do {
if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
return l;
}
} while ((l = l->radial_next) != l_first);
/* in the case this is used, we know this will never happen */
return NULL;
}
static void bm_vert_boundary_tangent(BMVert *v, float r_no[3], float r_no_face[3],
BMVert **r_va_other, BMVert **r_vb_other)
{
BMIter iter;
BMEdge *e_iter;
BMEdge *e_a = NULL, *e_b = NULL;
BMVert *v_a, *v_b;
BMLoop *l_a, *l_b;
float no_face[3], no_edge[3];
float tvec_a[3], tvec_b[3];
/* get 2 boundary edges, there should only _be_ 2,
* in case there are more - results wont be valid of course */
BM_ITER_ELEM (e_iter, &iter, v, BM_EDGES_OF_VERT) {
if (BM_elem_flag_test(e_iter, BM_ELEM_TAG)) {
if (e_a == NULL) {
e_a = e_iter;
}
else {
e_b = e_iter;
break;
}
}
}
if (e_a && e_b) {
/* note, with an incorrectly flushed selection this can crash */
l_a = bm_edge_tag_faceloop(e_a);
l_b = bm_edge_tag_faceloop(e_b);
/* average edge face normal */
add_v3_v3v3(no_face, l_a->f->no, l_b->f->no);
/* average edge direction */
v_a = BM_edge_other_vert(e_a, v);
v_b = BM_edge_other_vert(e_b, v);
sub_v3_v3v3(tvec_a, v->co, v_a->co);
sub_v3_v3v3(tvec_b, v_b->co, v->co);
normalize_v3(tvec_a);
normalize_v3(tvec_b);
add_v3_v3v3(no_edge, tvec_a, tvec_b); /* not unit length but this is ok */
/* check are we flipped the right way */
BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
BM_edge_calc_face_tangent(e_b, l_b, tvec_b);
add_v3_v3(tvec_a, tvec_b);
*r_va_other = v_a;
*r_vb_other = v_b;
}
else {
/* degenerate case - vertex connects a boundary edged face to other faces,
* so we have only one boundary face - only use it for calculations */
l_a = bm_edge_tag_faceloop(e_a);
copy_v3_v3(no_face, l_a->f->no);
/* edge direction */
v_a = BM_edge_other_vert(e_a, v);
v_b = NULL;
sub_v3_v3v3(no_edge, v->co, v_a->co);
/* check are we flipped the right way */
BM_edge_calc_face_tangent(e_a, l_a, tvec_a);
*r_va_other = NULL;
*r_vb_other = NULL;
}
/* find the normal */
cross_v3_v3v3(r_no, no_edge, no_face);
normalize_v3(r_no);
if (dot_v3v3(r_no, tvec_a) > 0.0f) {
negate_v3(r_no);
}
copy_v3_v3(r_no_face, no_face);
}
/* check if we are the only tagged loop-face around this edge */
static bool bm_loop_is_radial_boundary(BMLoop *l_first)
{
BMLoop *l = l_first->radial_next;
if (l == l_first) {
return true; /* a real boundary */
}
else {
do {
if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) {
return false;
}
} while ((l = l->radial_next) != l_first);
}
return true;
}
/**
* \param def_nr -1 for no vertex groups.
*
* \note All edge tags must be cleared.
* \note Behavior matches MOD_solidify.c
*/
void BM_mesh_wireframe(
BMesh *bm,
const float offset,
const float offset_fac,
const float offset_fac_vg,
const bool use_replace,
const bool use_boundary,
const bool use_even_offset,
const bool use_relative_offset,
const bool use_crease,
const float crease_weight,
const int defgrp_index,
const bool defgrp_invert,
const short mat_offset,
const short mat_max,
/* for operators */
const bool use_tag
)
{
const float ofs_orig = -(((-offset_fac + 1.0f) * 0.5f) * offset);
const float ofs_new = offset + ofs_orig;
const float ofs_mid = (ofs_orig + ofs_new) / 2.0f;
const float inset = offset / 2.0f;
int cd_edge_crease_offset = use_crease ? CustomData_get_offset(&bm->edata, CD_CREASE) : -1;
const int cd_dvert_offset = (defgrp_index != -1) ? CustomData_get_offset(&bm->vdata, CD_MDEFORMVERT) : -1;
const float offset_fac_vg_inv = 1.0f - offset_fac_vg;
const int totvert_orig = bm->totvert;
BMIter iter;
BMIter itersub;
/* filled only with boundary verts */
BMVert **verts_src = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
BMVert **verts_neg = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
BMVert **verts_pos = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__);
/* will over-alloc, but makes for easy lookups by index to keep aligned */
BMVert **verts_boundary = use_boundary ?
MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__) : NULL;
float *verts_relfac = (use_relative_offset || (cd_dvert_offset != -1)) ?
MEM_mallocN(sizeof(float) * totvert_orig, __func__) : NULL;
/* may over-alloc if not all faces have wire */
BMVert **verts_loop;
int verts_loop_tot = 0;
BMVert *v_src;
BMFace *f_src;
BMLoop *l;
float tvec[3];
float fac, fac_shell;
int i;
if (use_crease && cd_edge_crease_offset == -1) {
BM_data_layer_add(bm, &bm->edata, CD_CREASE);
cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE);
}
BM_mesh_elem_index_ensure(bm, BM_VERT);
BM_ITER_MESH_INDEX (v_src, &iter, bm, BM_VERTS_OF_MESH, i) {
BM_elem_flag_disable(v_src, BM_ELEM_TAG);
verts_src[i] = v_src;
}
/* setup tags, all faces and verts will be tagged which will be duplicated */
BM_ITER_MESH (f_src, &iter, bm, BM_FACES_OF_MESH) {
if (use_tag) {
if (!BM_elem_flag_test(f_src, BM_ELEM_TAG)) {
continue;
}
}
else {
BM_elem_flag_enable(f_src, BM_ELEM_TAG);
}
verts_loop_tot += f_src->len;
BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
BM_elem_flag_enable(l->v, BM_ELEM_TAG);
/* also tag boundary edges */
BM_elem_flag_set(l->e, BM_ELEM_TAG, bm_loop_is_radial_boundary(l));
}
}
/* duplicate tagged verts */
for (i = 0; i < totvert_orig; i++) {
v_src = verts_src[i];
if (BM_elem_flag_test(v_src, BM_ELEM_TAG)) {
fac = 1.0f;
if (verts_relfac) {
if (use_relative_offset) {
verts_relfac[i] = BM_vert_calc_mean_tagged_edge_length(v_src);
}
else {
verts_relfac[i] = 1.0f;
}
if (cd_dvert_offset != -1) {
MDeformVert *dvert = BM_ELEM_CD_GET_VOID_P(v_src, cd_dvert_offset);
float defgrp_fac = defvert_find_weight(dvert, defgrp_index);
if (defgrp_invert) {
defgrp_fac = 1.0f - defgrp_fac;
}
if (offset_fac_vg > 0.0f) {
defgrp_fac = (offset_fac_vg + (defgrp_fac * offset_fac_vg_inv));
}
verts_relfac[i] *= defgrp_fac;
}
fac *= verts_relfac[i];
}
verts_neg[i] = BM_vert_create(bm, NULL, v_src, BM_CREATE_NOP);
verts_pos[i] = BM_vert_create(bm, NULL, v_src, BM_CREATE_NOP);
if (offset == 0.0f) {
madd_v3_v3v3fl(verts_neg[i]->co, v_src->co, v_src->no, ofs_orig * fac);
madd_v3_v3v3fl(verts_pos[i]->co, v_src->co, v_src->no, ofs_new * fac);
}
else {
madd_v3_v3v3fl(tvec, v_src->co, v_src->no, ofs_mid * fac);
madd_v3_v3v3fl(verts_neg[i]->co, tvec, v_src->no, (ofs_mid - ofs_orig) * fac);
madd_v3_v3v3fl(verts_pos[i]->co, tvec, v_src->no, (ofs_mid - ofs_new) * fac);
}
}
else {
/* could skip this */
verts_neg[i] = NULL;
verts_pos[i] = NULL;
}
/* conflicts with BM_vert_calc_mean_tagged_edge_length */
if (use_relative_offset == false) {
BM_elem_flag_disable(v_src, BM_ELEM_TAG);
}
}
if (use_relative_offset) {
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
}
verts_loop = MEM_mallocN(sizeof(BMVert *) * verts_loop_tot, __func__);
verts_loop_tot = 0; /* count up again */
BM_ITER_MESH (f_src, &iter, bm, BM_FACES_OF_MESH) {
if (use_tag && !BM_elem_flag_test(f_src, BM_ELEM_TAG)) {
continue;
}
BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
BM_elem_index_set(l, verts_loop_tot); /* set_loop */
BM_loop_calc_face_tangent(l, tvec);
/* create offset vert */
fac = 1.0f;
if (verts_relfac) {
fac *= verts_relfac[BM_elem_index_get(l->v)];
}
fac_shell = fac;
if (use_even_offset) {
fac_shell *= shell_angle_to_dist(((float)M_PI - BM_loop_calc_face_angle(l)) * 0.5f);
}
madd_v3_v3v3fl(tvec, l->v->co, tvec, inset * fac_shell);
if (offset != 0.0f) {
madd_v3_v3fl(tvec, l->v->no, ofs_mid * fac);
}
verts_loop[verts_loop_tot] = BM_vert_create(bm, tvec, l->v, BM_CREATE_NOP);
if (use_boundary) {
if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) { /* is this a boundary? */
BMVert *v_pair[2] = {l->v, l->next->v};
for (i = 0; i < 2; i++) {
BMVert *v_boundary = v_pair[i];
if (!BM_elem_flag_test(v_boundary, BM_ELEM_TAG)) {
const int v_boundary_index = BM_elem_index_get(v_boundary);
float no_face[3];
BMVert *va_other;
BMVert *vb_other;
BM_elem_flag_enable(v_boundary, BM_ELEM_TAG);
bm_vert_boundary_tangent(v_boundary, tvec, no_face, &va_other, &vb_other);
/* create offset vert */
/* similar to code above but different angle calc */
fac = 1.0f;
if (verts_relfac) {
fac *= verts_relfac[v_boundary_index];
}
fac_shell = fac;
if (use_even_offset) {
if (va_other) { /* for verts with only one boundary edge - this will be NULL */
fac_shell *= shell_angle_to_dist(((float)M_PI -
angle_on_axis_v3v3v3_v3(va_other->co,
v_boundary->co,
vb_other->co,
no_face)) * 0.5f);
}
}
madd_v3_v3v3fl(tvec, v_boundary->co, tvec, inset * fac_shell);
if (offset != 0.0f) {
madd_v3_v3fl(tvec, v_boundary->no, ofs_mid * fac);
}
verts_boundary[v_boundary_index] = BM_vert_create(bm, tvec, v_boundary, BM_CREATE_NOP);
}
}
}
}
verts_loop_tot++;
}
}
BM_ITER_MESH (f_src, &iter, bm, BM_FACES_OF_MESH) {
/* skip recently added faces */
if (BM_elem_index_get(f_src) == -1) {
continue;
}
if (use_tag && !BM_elem_flag_test(f_src, BM_ELEM_TAG)) {
continue;
}
BM_elem_flag_disable(f_src, BM_ELEM_TAG);
BM_ITER_ELEM (l, &itersub, f_src, BM_LOOPS_OF_FACE) {
BMFace *f_new;
BMLoop *l_new;
BMLoop *l_next = l->next;
BMVert *v_l1 = verts_loop[BM_elem_index_get(l)];
BMVert *v_l2 = verts_loop[BM_elem_index_get(l_next)];
BMVert *v_src_l1 = l->v;
BMVert *v_src_l2 = l_next->v;
const int i_1 = BM_elem_index_get(v_src_l1);
const int i_2 = BM_elem_index_get(v_src_l2);
BMVert *v_neg1 = verts_neg[i_1];
BMVert *v_neg2 = verts_neg[i_2];
BMVert *v_pos1 = verts_pos[i_1];
BMVert *v_pos2 = verts_pos[i_2];
f_new = BM_face_create_quad_tri(bm, v_l1, v_l2, v_neg2, v_neg1, f_src, false);
if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l, l_new);
BM_elem_attrs_copy(bm, bm, l, l_new->prev);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
f_new = BM_face_create_quad_tri(bm, v_l2, v_l1, v_pos1, v_pos2, f_src, false);
if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
BM_elem_attrs_copy(bm, bm, l, l_new->next);
BM_elem_attrs_copy(bm, bm, l, l_new->next->next);
if (use_boundary) {
if (BM_elem_flag_test(l->e, BM_ELEM_TAG)) {
/* we know its a boundary and this is the only face user (which is being wire'd) */
/* we know we only touch this edge/face once */
BMVert *v_b1 = verts_boundary[i_1];
BMVert *v_b2 = verts_boundary[i_2];
f_new = BM_face_create_quad_tri(bm, v_b2, v_b1, v_neg1, v_neg2, f_src, false);
if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new);
BM_elem_attrs_copy(bm, bm, l_next, l_new->prev);
BM_elem_attrs_copy(bm, bm, l, l_new->next);
BM_elem_attrs_copy(bm, bm, l, l_new->next->next);
f_new = BM_face_create_quad_tri(bm, v_b1, v_b2, v_pos2, v_pos1, f_src, false);
if (mat_offset) f_new->mat_nr = CLAMPIS(f_new->mat_nr + mat_offset, 0, mat_max);
BM_elem_flag_enable(f_new, BM_ELEM_TAG);
l_new = BM_FACE_FIRST_LOOP(f_new);
BM_elem_attrs_copy(bm, bm, l, l_new);
BM_elem_attrs_copy(bm, bm, l, l_new->prev);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next);
BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next);
if (use_crease) {
BMEdge *e_new;
e_new = BM_edge_exists(v_pos1, v_b1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_pos2, v_b2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg1, v_b1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg2, v_b2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
}
}
}
if (use_crease) {
BMEdge *e_new;
e_new = BM_edge_exists(v_pos1, v_l1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_pos2, v_l2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg1, v_l1);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
e_new = BM_edge_exists(v_neg2, v_l2);
BM_ELEM_CD_SET_FLOAT(e_new, cd_edge_crease_offset, crease_weight);
}
}
}
if (use_boundary) {
MEM_freeN(verts_boundary);
}
if (verts_relfac) {
MEM_freeN(verts_relfac);
}
if (use_replace) {
for (i = 0; i < totvert_orig; i++) {
BM_vert_kill(bm, verts_src[i]);
}
}
MEM_freeN(verts_src);
MEM_freeN(verts_neg);
MEM_freeN(verts_pos);
MEM_freeN(verts_loop);
}

50
source/blender/bmesh/tools/bmesh_wireframe.h Normal file
View File

@ -0,0 +1,50 @@
/*
* ***** 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/tools/bmesh_wireframe.h
* \ingroup bmesh
*
* Wire Frame.
*
*/
#ifndef __BMESH_WIREFRAME_H__
#define __BMESH_WIREFRAME_H__
void BM_mesh_wireframe(
BMesh *bm,
const float offset,
const float offset_fac,
const float offset_fac_vg,
const bool use_replace,
const bool use_boundary,
const bool use_even_offset,
const bool use_relative_offset,
const bool use_crease,
const float crease_weight,
const int defgrp_index,
const bool defgrp_invert,
const short mat_offset,
const short mat_max,
const bool use_tag);
#endif /* __BMESH_WIREFRAME_H__ */

29
source/blender/editors/mesh/editmesh_tools.c
View File

@ -4513,25 +4513,18 @@ static int edbm_wireframe_exec(bContext *C, wmOperator *op)
const bool use_replace = RNA_boolean_get(op->ptr, "use_replace");
const bool use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_offset");
const bool use_crease = RNA_boolean_get(op->ptr, "use_crease");
const float crease_weight = RNA_float_get(op->ptr, "crease_weight");
const float thickness = RNA_float_get(op->ptr, "thickness");
const float offset = RNA_float_get(op->ptr, "offset");
EDBM_op_init(em, &bmop, op,
"wireframe faces=%hf use_boundary=%b use_even_offset=%b use_relative_offset=%b use_crease=%b "
"thickness=%f",
BM_ELEM_SELECT, use_boundary, use_even_offset, use_relative_offset, use_crease,
thickness);
"wireframe faces=%hf use_replace=%b use_boundary=%b use_even_offset=%b use_relative_offset=%b "
"use_crease=%b crease_weight=%f thickness=%f offset=%f",
BM_ELEM_SELECT, use_replace, use_boundary, use_even_offset, use_relative_offset,
use_crease, crease_weight, thickness, offset);
BMO_op_exec(em->bm, &bmop);
if (use_replace) {
BM_mesh_elem_hflag_disable_all(em->bm, BM_FACE, BM_ELEM_TAG, false);
BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_in, "faces", BM_FACE, BM_ELEM_TAG, false);
BMO_op_callf(em->bm, BMO_FLAG_DEFAULTS,
"delete geom=%hvef context=%i",
BM_ELEM_TAG, DEL_FACES);
}
BM_mesh_elem_hflag_disable_all(em->bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, false);
BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
@ -4564,14 +4557,14 @@ void MESH_OT_wireframe(wmOperatorType *ot)
RNA_def_boolean(ot->srna, "use_boundary", true, "Boundary", "Inset face boundaries");
RNA_def_boolean(ot->srna, "use_even_offset", true, "Offset Even", "Scale the offset to give more even thickness");
RNA_def_boolean(ot->srna, "use_relative_offset", false, "Offset Relative", "Scale the offset by surrounding geometry");
RNA_def_boolean(ot->srna, "use_crease", false, "Crease", "Crease hub edges for improved subsurf");
RNA_def_boolean(ot->srna, "use_replace", true, "Replace", "Remove original faces");
prop = RNA_def_float(ot->srna, "thickness", 0.01f, 0.0f, FLT_MAX, "Thickness", "", 0.0f, 10.0f);
/* use 1 rather then 10 for max else dragging the button moves too far */
RNA_def_property_ui_range(prop, 0.0, 1.0, 0.01, 4);
RNA_def_boolean(ot->srna, "use_replace", true, "Replace", "Remove original faces");
RNA_def_float(ot->srna, "offset", 0.01f, 0.0f, FLT_MAX, "Offset", "", 0.0f, 10.0f);
RNA_def_boolean(ot->srna, "use_crease", false, "Crease", "Crease hub edges for improved subsurf");
prop = RNA_def_float(ot->srna, "crease_weight", 0.01f, 0.0f, FLT_MAX, "Crease weight", "", 0.0f, 1.0f);
RNA_def_property_ui_range(prop, 0.0, 1.0, 0.1, 2);
}
#ifdef WITH_BULLET