Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/blender/bmesh/tools/bmesh_wireframe.c
diff options
context:
space:
mode:
Diffstat (limited to 'source/blender/bmesh/tools/bmesh_wireframe.c')
-rw-r--r--source/blender/bmesh/tools/bmesh_wireframe.c541
1 files changed, 541 insertions, 0 deletions
diff --git a/source/blender/bmesh/tools/bmesh_wireframe.c b/source/blender/bmesh/tools/bmesh_wireframe.c
new file mode 100644
index 00000000000..c9ec5a9f54d
--- /dev/null
+++ b/source/blender/bmesh/tools/bmesh_wireframe.c
@@ -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);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-09 08:16:02 +0300