Changeset View
Changeset View
Standalone View
Standalone View
source/blender/editors/transform/transform_conversions_mesh.c
- This file was added.
| /* | |||||
| * 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. | |||||
| * | |||||
| * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. | |||||
| * All rights reserved. | |||||
| */ | |||||
| /** \file | |||||
| * \ingroup edtransform | |||||
| */ | |||||
| #include "DNA_mesh_types.h" | |||||
| #include "DNA_meshdata_types.h" | |||||
| #include "MEM_guardedalloc.h" | |||||
| #include "BLI_math.h" | |||||
| #include "BLI_linklist_stack.h" | |||||
| #include "BKE_context.h" | |||||
| #include "BKE_crazyspace.h" | |||||
| #include "BKE_editmesh.h" | |||||
| #include "BKE_mesh.h" | |||||
| #include "BKE_modifier.h" | |||||
| #include "BKE_scene.h" | |||||
| #include "ED_mesh.h" | |||||
| #include "WM_api.h" /* for WM_event_add_notifier to deal with stabilization nodes */ | |||||
| #include "DEG_depsgraph.h" | |||||
| #include "DEG_depsgraph_query.h" | |||||
| #include "transform.h" | |||||
| #include "transform_conversions.h" | |||||
| #include "bmesh.h" | |||||
| static bool bmesh_test_dist_add(BMVert *v, | |||||
| BMVert *v_other, | |||||
| float *dists, | |||||
| const float *dists_prev, | |||||
| /* optionally track original index */ | |||||
| int *index, | |||||
| const int *index_prev, | |||||
| float mtx[3][3]) | |||||
| { | |||||
| if ((BM_elem_flag_test(v_other, BM_ELEM_SELECT) == 0) && | |||||
| (BM_elem_flag_test(v_other, BM_ELEM_HIDDEN) == 0)) { | |||||
| const int i = BM_elem_index_get(v); | |||||
| const int i_other = BM_elem_index_get(v_other); | |||||
| float vec[3]; | |||||
| float dist_other; | |||||
| sub_v3_v3v3(vec, v->co, v_other->co); | |||||
| mul_m3_v3(mtx, vec); | |||||
| dist_other = dists_prev[i] + len_v3(vec); | |||||
| if (dist_other < dists[i_other]) { | |||||
| dists[i_other] = dist_other; | |||||
| if (index != NULL) { | |||||
| index[i_other] = index_prev[i]; | |||||
| } | |||||
| return true; | |||||
| } | |||||
| } | |||||
| return false; | |||||
| } | |||||
| /** | |||||
| * \param mtx: Measure distance in this space. | |||||
| * \param dists: Store the closest connected distance to selected vertices. | |||||
| * \param index: Optionally store the original index we're measuring the distance to (can be NULL). | |||||
| */ | |||||
| static void editmesh_set_connectivity_distance(BMesh *bm, | |||||
| float mtx[3][3], | |||||
| float *dists, | |||||
| int *index) | |||||
| { | |||||
| BLI_LINKSTACK_DECLARE(queue, BMVert *); | |||||
| /* any BM_ELEM_TAG'd vertex is in 'queue_next', so we don't add in twice */ | |||||
| BLI_LINKSTACK_DECLARE(queue_next, BMVert *); | |||||
| BLI_LINKSTACK_INIT(queue); | |||||
| BLI_LINKSTACK_INIT(queue_next); | |||||
| { | |||||
| BMIter viter; | |||||
| BMVert *v; | |||||
| int i; | |||||
| BM_ITER_MESH_INDEX (v, &viter, bm, BM_VERTS_OF_MESH, i) { | |||||
| float dist; | |||||
| BM_elem_index_set(v, i); /* set_inline */ | |||||
| BM_elem_flag_disable(v, BM_ELEM_TAG); | |||||
| if (BM_elem_flag_test(v, BM_ELEM_SELECT) == 0 || BM_elem_flag_test(v, BM_ELEM_HIDDEN)) { | |||||
| dist = FLT_MAX; | |||||
| if (index != NULL) { | |||||
| index[i] = i; | |||||
| } | |||||
| } | |||||
| else { | |||||
| BLI_LINKSTACK_PUSH(queue, v); | |||||
| dist = 0.0f; | |||||
| if (index != NULL) { | |||||
| index[i] = i; | |||||
| } | |||||
| } | |||||
| dists[i] = dist; | |||||
| } | |||||
| bm->elem_index_dirty &= ~BM_VERT; | |||||
| } | |||||
| /* need to be very careful of feedback loops here, store previous dist's to avoid feedback */ | |||||
| float *dists_prev = MEM_dupallocN(dists); | |||||
| int *index_prev = MEM_dupallocN(index); /* may be NULL */ | |||||
| do { | |||||
| BMVert *v; | |||||
| LinkNode *lnk; | |||||
| /* this is correct but slow to do each iteration, | |||||
| * instead sync the dist's while clearing BM_ELEM_TAG (below) */ | |||||
| #if 0 | |||||
| memcpy(dists_prev, dists, sizeof(float) * bm->totvert); | |||||
| #endif | |||||
| while ((v = BLI_LINKSTACK_POP(queue))) { | |||||
| BLI_assert(dists[BM_elem_index_get(v)] != FLT_MAX); | |||||
| /* connected edge-verts */ | |||||
| if (v->e != NULL) { | |||||
| BMEdge *e_iter, *e_first; | |||||
| e_iter = e_first = v->e; | |||||
| /* would normally use BM_EDGES_OF_VERT, but this runs so often, | |||||
| * its faster to iterate on the data directly */ | |||||
| do { | |||||
| if (BM_elem_flag_test(e_iter, BM_ELEM_HIDDEN) == 0) { | |||||
| /* edge distance */ | |||||
| { | |||||
| BMVert *v_other = BM_edge_other_vert(e_iter, v); | |||||
| if (bmesh_test_dist_add(v, v_other, dists, dists_prev, index, index_prev, mtx)) { | |||||
| if (BM_elem_flag_test(v_other, BM_ELEM_TAG) == 0) { | |||||
| BM_elem_flag_enable(v_other, BM_ELEM_TAG); | |||||
| BLI_LINKSTACK_PUSH(queue_next, v_other); | |||||
| } | |||||
| } | |||||
| } | |||||
| /* face distance */ | |||||
| if (e_iter->l) { | |||||
| BMLoop *l_iter_radial, *l_first_radial; | |||||
| /** | |||||
| * imaginary edge diagonally across quad, | |||||
| * \note, this takes advantage of the rules of winding that we | |||||
| * know 2 or more of a verts edges wont reference the same face twice. | |||||
| * Also, if the edge is hidden, the face will be hidden too. | |||||
| */ | |||||
| l_iter_radial = l_first_radial = e_iter->l; | |||||
| do { | |||||
| if ((l_iter_radial->v == v) && (l_iter_radial->f->len == 4) && | |||||
| (BM_elem_flag_test(l_iter_radial->f, BM_ELEM_HIDDEN) == 0)) { | |||||
| BMVert *v_other = l_iter_radial->next->next->v; | |||||
| if (bmesh_test_dist_add(v, v_other, dists, dists_prev, index, index_prev, mtx)) { | |||||
| if (BM_elem_flag_test(v_other, BM_ELEM_TAG) == 0) { | |||||
| BM_elem_flag_enable(v_other, BM_ELEM_TAG); | |||||
| BLI_LINKSTACK_PUSH(queue_next, v_other); | |||||
| } | |||||
| } | |||||
| } | |||||
| } while ((l_iter_radial = l_iter_radial->radial_next) != l_first_radial); | |||||
| } | |||||
| } | |||||
| } while ((e_iter = BM_DISK_EDGE_NEXT(e_iter, v)) != e_first); | |||||
| } | |||||
| } | |||||
| /* clear for the next loop */ | |||||
| for (lnk = queue_next; lnk; lnk = lnk->next) { | |||||
| BMVert *v_link = lnk->link; | |||||
| const int i = BM_elem_index_get(v_link); | |||||
| BM_elem_flag_disable(v_link, BM_ELEM_TAG); | |||||
| /* keep in sync, avoid having to do full memcpy each iteration */ | |||||
| dists_prev[i] = dists[i]; | |||||
| if (index != NULL) { | |||||
| index_prev[i] = index[i]; | |||||
| } | |||||
| } | |||||
| BLI_LINKSTACK_SWAP(queue, queue_next); | |||||
| /* none should be tagged now since 'queue_next' is empty */ | |||||
| BLI_assert(BM_iter_mesh_count_flag(BM_VERTS_OF_MESH, bm, BM_ELEM_TAG, true) == 0); | |||||
| } while (BLI_LINKSTACK_SIZE(queue)); | |||||
| BLI_LINKSTACK_FREE(queue); | |||||
| BLI_LINKSTACK_FREE(queue_next); | |||||
| MEM_freeN(dists_prev); | |||||
| if (index_prev != NULL) { | |||||
| MEM_freeN(index_prev); | |||||
| } | |||||
| } | |||||
| static struct TransIslandData *editmesh_islands_info_calc(BMEditMesh *em, | |||||
| int *r_island_tot, | |||||
| int **r_island_vert_map, | |||||
| bool calc_single_islands) | |||||
| { | |||||
| BMesh *bm = em->bm; | |||||
| struct TransIslandData *trans_islands; | |||||
| char htype; | |||||
| char itype; | |||||
| int i; | |||||
| /* group vars */ | |||||
| int *groups_array; | |||||
| int(*group_index)[2]; | |||||
| int group_tot; | |||||
| void **ele_array; | |||||
| int *vert_map; | |||||
| if (em->selectmode & (SCE_SELECT_VERTEX | SCE_SELECT_EDGE)) { | |||||
| groups_array = MEM_mallocN(sizeof(*groups_array) * bm->totedgesel, __func__); | |||||
| group_tot = BM_mesh_calc_edge_groups( | |||||
| bm, groups_array, &group_index, NULL, NULL, BM_ELEM_SELECT); | |||||
| htype = BM_EDGE; | |||||
| itype = BM_VERTS_OF_EDGE; | |||||
| } | |||||
| else { /* (bm->selectmode & SCE_SELECT_FACE) */ | |||||
| groups_array = MEM_mallocN(sizeof(*groups_array) * bm->totfacesel, __func__); | |||||
| group_tot = BM_mesh_calc_face_groups( | |||||
| bm, groups_array, &group_index, NULL, NULL, BM_ELEM_SELECT, BM_VERT); | |||||
| htype = BM_FACE; | |||||
| itype = BM_VERTS_OF_FACE; | |||||
| } | |||||
| trans_islands = MEM_mallocN(sizeof(*trans_islands) * group_tot, __func__); | |||||
| vert_map = MEM_mallocN(sizeof(*vert_map) * bm->totvert, __func__); | |||||
| /* we shouldn't need this, but with incorrect selection flushing | |||||
| * its possible we have a selected vertex that's not in a face, | |||||
| * for now best not crash in that case. */ | |||||
| copy_vn_i(vert_map, bm->totvert, -1); | |||||
| BM_mesh_elem_table_ensure(bm, htype); | |||||
| ele_array = (htype == BM_FACE) ? (void **)bm->ftable : (void **)bm->etable; | |||||
| BM_mesh_elem_index_ensure(bm, BM_VERT); | |||||
| /* may be an edge OR a face array */ | |||||
| for (i = 0; i < group_tot; i++) { | |||||
| BMEditSelection ese = {NULL}; | |||||
| const int fg_sta = group_index[i][0]; | |||||
| const int fg_len = group_index[i][1]; | |||||
| float co[3], no[3], tangent[3]; | |||||
| int j; | |||||
| zero_v3(co); | |||||
| zero_v3(no); | |||||
| zero_v3(tangent); | |||||
| ese.htype = htype; | |||||
| /* loop on each face in this group: | |||||
| * - assign r_vert_map | |||||
| * - calculate (co, no) | |||||
| */ | |||||
| for (j = 0; j < fg_len; j++) { | |||||
| float tmp_co[3], tmp_no[3], tmp_tangent[3]; | |||||
| ese.ele = ele_array[groups_array[fg_sta + j]]; | |||||
| BM_editselection_center(&ese, tmp_co); | |||||
| BM_editselection_normal(&ese, tmp_no); | |||||
| BM_editselection_plane(&ese, tmp_tangent); | |||||
| add_v3_v3(co, tmp_co); | |||||
| add_v3_v3(no, tmp_no); | |||||
| add_v3_v3(tangent, tmp_tangent); | |||||
| { | |||||
| /* setup vertex map */ | |||||
| BMIter iter; | |||||
| BMVert *v; | |||||
| /* connected edge-verts */ | |||||
| BM_ITER_ELEM (v, &iter, ese.ele, itype) { | |||||
| vert_map[BM_elem_index_get(v)] = i; | |||||
| } | |||||
| } | |||||
| } | |||||
| mul_v3_v3fl(trans_islands[i].co, co, 1.0f / (float)fg_len); | |||||
| if (createSpaceNormalTangent(trans_islands[i].axismtx, no, tangent)) { | |||||
| /* pass */ | |||||
| } | |||||
| else { | |||||
| if (normalize_v3(no) != 0.0f) { | |||||
| axis_dominant_v3_to_m3(trans_islands[i].axismtx, no); | |||||
| invert_m3(trans_islands[i].axismtx); | |||||
| } | |||||
| else { | |||||
| unit_m3(trans_islands[i].axismtx); | |||||
| } | |||||
| } | |||||
| } | |||||
| MEM_freeN(groups_array); | |||||
| MEM_freeN(group_index); | |||||
| /* for PET we need islands of 1 so connected vertices can use it with V3D_AROUND_LOCAL_ORIGINS */ | |||||
| if (calc_single_islands) { | |||||
| BMIter viter; | |||||
| BMVert *v; | |||||
| int group_tot_single = 0; | |||||
| BM_ITER_MESH_INDEX (v, &viter, bm, BM_VERTS_OF_MESH, i) { | |||||
| if (BM_elem_flag_test(v, BM_ELEM_SELECT) && (vert_map[i] == -1)) { | |||||
| group_tot_single += 1; | |||||
| } | |||||
| } | |||||
| if (group_tot_single != 0) { | |||||
| trans_islands = MEM_reallocN(trans_islands, | |||||
| sizeof(*trans_islands) * (group_tot + group_tot_single)); | |||||
| BM_ITER_MESH_INDEX (v, &viter, bm, BM_VERTS_OF_MESH, i) { | |||||
| if (BM_elem_flag_test(v, BM_ELEM_SELECT) && (vert_map[i] == -1)) { | |||||
| struct TransIslandData *v_island = &trans_islands[group_tot]; | |||||
| vert_map[i] = group_tot; | |||||
| copy_v3_v3(v_island->co, v->co); | |||||
| if (is_zero_v3(v->no) != 0.0f) { | |||||
| axis_dominant_v3_to_m3(v_island->axismtx, v->no); | |||||
| invert_m3(v_island->axismtx); | |||||
| } | |||||
| else { | |||||
| unit_m3(v_island->axismtx); | |||||
| } | |||||
| group_tot += 1; | |||||
| } | |||||
| } | |||||
| } | |||||
| } | |||||
| *r_island_tot = group_tot; | |||||
| *r_island_vert_map = vert_map; | |||||
| return trans_islands; | |||||
| } | |||||
| /* way to overwrite what data is edited with transform */ | |||||
| static void VertsToTransData(TransInfo *t, | |||||
| TransData *td, | |||||
| TransDataExtension *tx, | |||||
| BMEditMesh *em, | |||||
| BMVert *eve, | |||||
| float *bweight, | |||||
| struct TransIslandData *v_island, | |||||
| const bool no_island_center) | |||||
| { | |||||
| float *no, _no[3]; | |||||
| BLI_assert(BM_elem_flag_test(eve, BM_ELEM_HIDDEN) == 0); | |||||
| td->flag = 0; | |||||
| // if (key) | |||||
| // td->loc = key->co; | |||||
| // else | |||||
| td->loc = eve->co; | |||||
| copy_v3_v3(td->iloc, td->loc); | |||||
| if ((t->mode == TFM_SHRINKFATTEN) && (em->selectmode & SCE_SELECT_FACE) && | |||||
| BM_elem_flag_test(eve, BM_ELEM_SELECT) && | |||||
| (BM_vert_calc_normal_ex(eve, BM_ELEM_SELECT, _no))) { | |||||
| no = _no; | |||||
| } | |||||
| else { | |||||
| no = eve->no; | |||||
| } | |||||
| if (v_island) { | |||||
| if (no_island_center) { | |||||
| copy_v3_v3(td->center, td->loc); | |||||
| } | |||||
| else { | |||||
| copy_v3_v3(td->center, v_island->co); | |||||
| } | |||||
| copy_m3_m3(td->axismtx, v_island->axismtx); | |||||
| } | |||||
| else if (t->around == V3D_AROUND_LOCAL_ORIGINS) { | |||||
| copy_v3_v3(td->center, td->loc); | |||||
| createSpaceNormal(td->axismtx, no); | |||||
| } | |||||
| else { | |||||
| copy_v3_v3(td->center, td->loc); | |||||
| /* Setting normals */ | |||||
| copy_v3_v3(td->axismtx[2], no); | |||||
| td->axismtx[0][0] = td->axismtx[0][1] = td->axismtx[0][2] = td->axismtx[1][0] = | |||||
| td->axismtx[1][1] = td->axismtx[1][2] = 0.0f; | |||||
| } | |||||
| td->ext = NULL; | |||||
| td->val = NULL; | |||||
| td->extra = NULL; | |||||
| if (t->mode == TFM_BWEIGHT) { | |||||
| td->val = bweight; | |||||
| td->ival = *bweight; | |||||
| } | |||||
| else if (t->mode == TFM_SKIN_RESIZE) { | |||||
| MVertSkin *vs = CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MVERT_SKIN); | |||||
| if (vs) { | |||||
| /* skin node size */ | |||||
| td->ext = tx; | |||||
| copy_v3_v3(tx->isize, vs->radius); | |||||
| tx->size = vs->radius; | |||||
| td->val = vs->radius; | |||||
| } | |||||
| else { | |||||
| td->flag |= TD_SKIP; | |||||
| } | |||||
| } | |||||
| else if (t->mode == TFM_SHRINKFATTEN) { | |||||
| td->ext = tx; | |||||
| tx->isize[0] = BM_vert_calc_shell_factor_ex(eve, no, BM_ELEM_SELECT); | |||||
| } | |||||
| } | |||||
| void createTransEditVerts(TransInfo *t) | |||||
| { | |||||
| FOREACH_TRANS_DATA_CONTAINER (t, tc) { | |||||
| TransData *tob = NULL; | |||||
| TransDataExtension *tx = NULL; | |||||
| BMEditMesh *em = BKE_editmesh_from_object(tc->obedit); | |||||
| Mesh *me = tc->obedit->data; | |||||
| BMesh *bm = em->bm; | |||||
| BMVert *eve; | |||||
| BMIter iter; | |||||
| float(*mappedcos)[3] = NULL, (*quats)[4] = NULL; | |||||
| float mtx[3][3], smtx[3][3], (*defmats)[3][3] = NULL, (*defcos)[3] = NULL; | |||||
| float *dists = NULL; | |||||
| int a; | |||||
| const int prop_mode = (t->flag & T_PROP_EDIT) ? (t->flag & T_PROP_EDIT_ALL) : 0; | |||||
| int mirror = 0; | |||||
| int cd_vert_bweight_offset = -1; | |||||
| bool use_topology = (me->editflag & ME_EDIT_MIRROR_TOPO) != 0; | |||||
| struct TransIslandData *island_info = NULL; | |||||
| int island_info_tot; | |||||
| int *island_vert_map = NULL; | |||||
| /* Snap rotation along normal needs a common axis for whole islands, | |||||
| * otherwise one get random crazy results, see T59104. | |||||
| * However, we do not want to use the island center for the pivot/translation reference. */ | |||||
| const bool is_snap_rotate = ((t->mode == TFM_TRANSLATION) && | |||||
| /* There is not guarantee that snapping | |||||
| * is initialized yet at this point... */ | |||||
| (usingSnappingNormal(t) || | |||||
| (t->settings->snap_flag & SCE_SNAP_ROTATE) != 0) && | |||||
| (t->around != V3D_AROUND_LOCAL_ORIGINS)); | |||||
| /* Even for translation this is needed because of island-orientation, see: T51651. */ | |||||
| const bool is_island_center = (t->around == V3D_AROUND_LOCAL_ORIGINS) || is_snap_rotate; | |||||
| /* Original index of our connected vertex when connected distances are calculated. | |||||
| * Optional, allocate if needed. */ | |||||
| int *dists_index = NULL; | |||||
| if (tc->mirror.axis_flag) { | |||||
| EDBM_verts_mirror_cache_begin(em, 0, false, (t->flag & T_PROP_EDIT) == 0, use_topology); | |||||
| mirror = 1; | |||||
| } | |||||
| /** | |||||
| * Quick check if we can transform. | |||||
| * | |||||
| * \note ignore modes here, even in edge/face modes, | |||||
| * transform data is created by selected vertices. | |||||
| * \note in prop mode we need at least 1 selected. | |||||
| */ | |||||
| if (bm->totvertsel == 0) { | |||||
| goto cleanup; | |||||
| } | |||||
| if (t->mode == TFM_BWEIGHT) { | |||||
| BM_mesh_cd_flag_ensure(bm, BKE_mesh_from_object(tc->obedit), ME_CDFLAG_VERT_BWEIGHT); | |||||
| cd_vert_bweight_offset = CustomData_get_offset(&bm->vdata, CD_BWEIGHT); | |||||
| } | |||||
| if (prop_mode) { | |||||
| unsigned int count = 0; | |||||
| BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) { | |||||
| if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { | |||||
| count++; | |||||
| } | |||||
| } | |||||
| tc->data_len = count; | |||||
| /* allocating scratch arrays */ | |||||
| if (prop_mode & T_PROP_CONNECTED) { | |||||
| dists = MEM_mallocN(em->bm->totvert * sizeof(float), __func__); | |||||
| if (is_island_center) { | |||||
| dists_index = MEM_mallocN(em->bm->totvert * sizeof(int), __func__); | |||||
| } | |||||
| } | |||||
| } | |||||
| else { | |||||
| tc->data_len = bm->totvertsel; | |||||
| } | |||||
| tob = tc->data = MEM_callocN(tc->data_len * sizeof(TransData), "TransObData(Mesh EditMode)"); | |||||
| if (ELEM(t->mode, TFM_SKIN_RESIZE, TFM_SHRINKFATTEN)) { | |||||
| /* warning, this is overkill, we only need 2 extra floats, | |||||
| * but this stores loads of extra stuff, for TFM_SHRINKFATTEN its even more overkill | |||||
| * since we may not use the 'alt' transform mode to maintain shell thickness, | |||||
| * but with generic transform code its hard to lazy init vars */ | |||||
| tx = tc->data_ext = MEM_callocN(tc->data_len * sizeof(TransDataExtension), | |||||
| "TransObData ext"); | |||||
| } | |||||
| copy_m3_m4(mtx, tc->obedit->obmat); | |||||
| /* we use a pseudo-inverse so that when one of the axes is scaled to 0, | |||||
| * matrix inversion still works and we can still moving along the other */ | |||||
| pseudoinverse_m3_m3(smtx, mtx, PSEUDOINVERSE_EPSILON); | |||||
| if (prop_mode & T_PROP_CONNECTED) { | |||||
| editmesh_set_connectivity_distance(em->bm, mtx, dists, dists_index); | |||||
| } | |||||
| if (is_island_center) { | |||||
| /* In this specific case, near-by vertices will need to know | |||||
| * the island of the nearest connected vertex. */ | |||||
| const bool calc_single_islands = ((prop_mode & T_PROP_CONNECTED) && | |||||
| (t->around == V3D_AROUND_LOCAL_ORIGINS) && | |||||
| (em->selectmode & SCE_SELECT_VERTEX)); | |||||
| island_info = editmesh_islands_info_calc( | |||||
| em, &island_info_tot, &island_vert_map, calc_single_islands); | |||||
| } | |||||
| /* detect CrazySpace [tm] */ | |||||
| if (modifiers_getCageIndex(t->scene, tc->obedit, NULL, 1) != -1) { | |||||
| int totleft = -1; | |||||
| if (modifiers_isCorrectableDeformed(t->scene, tc->obedit)) { | |||||
| BKE_scene_graph_evaluated_ensure(t->depsgraph, CTX_data_main(t->context)); | |||||
| /* Use evaluated state because we need b-bone cache. */ | |||||
| Scene *scene_eval = (Scene *)DEG_get_evaluated_id(t->depsgraph, &t->scene->id); | |||||
| Object *obedit_eval = (Object *)DEG_get_evaluated_id(t->depsgraph, &tc->obedit->id); | |||||
| BMEditMesh *em_eval = BKE_editmesh_from_object(obedit_eval); | |||||
| /* check if we can use deform matrices for modifier from the | |||||
| * start up to stack, they are more accurate than quats */ | |||||
| totleft = BKE_crazyspace_get_first_deform_matrices_editbmesh( | |||||
| t->depsgraph, scene_eval, obedit_eval, em_eval, &defmats, &defcos); | |||||
| } | |||||
| /* if we still have more modifiers, also do crazyspace | |||||
| * correction with quats, relative to the coordinates after | |||||
| * the modifiers that support deform matrices (defcos) */ | |||||
| #if 0 /* TODO, fix crazyspace+extrude so it can be enabled for general use - campbell */ | |||||
| if ((totleft > 0) || (totleft == -1)) | |||||
| #else | |||||
| if (totleft > 0) | |||||
| #endif | |||||
| { | |||||
| mappedcos = BKE_crazyspace_get_mapped_editverts(t->depsgraph, tc->obedit); | |||||
| quats = MEM_mallocN(em->bm->totvert * sizeof(*quats), "crazy quats"); | |||||
| BKE_crazyspace_set_quats_editmesh(em, defcos, mappedcos, quats, !prop_mode); | |||||
| if (mappedcos) { | |||||
| MEM_freeN(mappedcos); | |||||
| } | |||||
| } | |||||
| if (defcos) { | |||||
| MEM_freeN(defcos); | |||||
| } | |||||
| } | |||||
| /* find out which half we do */ | |||||
| if (mirror) { | |||||
| BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) { | |||||
| if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && eve->co[0] != 0.0f) { | |||||
| if (eve->co[0] < 0.0f) { | |||||
| tc->mirror.sign = -1.0f; | |||||
| mirror = -1; | |||||
| } | |||||
| break; | |||||
| } | |||||
| } | |||||
| } | |||||
| BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, a) { | |||||
| if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { | |||||
| if (prop_mode || BM_elem_flag_test(eve, BM_ELEM_SELECT)) { | |||||
| struct TransIslandData *v_island = NULL; | |||||
| float *bweight = (cd_vert_bweight_offset != -1) ? | |||||
| BM_ELEM_CD_GET_VOID_P(eve, cd_vert_bweight_offset) : | |||||
| NULL; | |||||
| if (island_info) { | |||||
| const int connected_index = (dists_index && dists_index[a] != -1) ? dists_index[a] : a; | |||||
| v_island = (island_vert_map[connected_index] != -1) ? | |||||
| &island_info[island_vert_map[connected_index]] : | |||||
| NULL; | |||||
| } | |||||
| /* Do not use the island center in case we are using islands | |||||
| * only to get axis for snap/rotate to normal... */ | |||||
| VertsToTransData(t, tob, tx, em, eve, bweight, v_island, is_snap_rotate); | |||||
| if (tx) { | |||||
| tx++; | |||||
| } | |||||
| /* selected */ | |||||
| if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { | |||||
| tob->flag |= TD_SELECTED; | |||||
| } | |||||
| if (prop_mode) { | |||||
| if (prop_mode & T_PROP_CONNECTED) { | |||||
| tob->dist = dists[a]; | |||||
| } | |||||
| else { | |||||
| tob->flag |= TD_NOTCONNECTED; | |||||
| tob->dist = FLT_MAX; | |||||
| } | |||||
| } | |||||
| /* CrazySpace */ | |||||
| const bool use_quats = quats && BM_elem_flag_test(eve, BM_ELEM_TAG); | |||||
| if (use_quats || defmats) { | |||||
| float mat[3][3], qmat[3][3], imat[3][3]; | |||||
| /* Use both or either quat and defmat correction. */ | |||||
| if (use_quats) { | |||||
| quat_to_mat3(qmat, quats[BM_elem_index_get(eve)]); | |||||
| if (defmats) { | |||||
| mul_m3_series(mat, defmats[a], qmat, mtx); | |||||
| } | |||||
| else { | |||||
| mul_m3_m3m3(mat, mtx, qmat); | |||||
| } | |||||
| } | |||||
| else { | |||||
| mul_m3_m3m3(mat, mtx, defmats[a]); | |||||
| } | |||||
| invert_m3_m3(imat, mat); | |||||
| copy_m3_m3(tob->smtx, imat); | |||||
| copy_m3_m3(tob->mtx, mat); | |||||
| } | |||||
| else { | |||||
| copy_m3_m3(tob->smtx, smtx); | |||||
| copy_m3_m3(tob->mtx, mtx); | |||||
| } | |||||
| /* Mirror? */ | |||||
| if ((mirror > 0 && tob->iloc[0] > 0.0f) || (mirror < 0 && tob->iloc[0] < 0.0f)) { | |||||
| BMVert *vmir = EDBM_verts_mirror_get(em, eve); // t->obedit, em, eve, tob->iloc, a); | |||||
| if (vmir && vmir != eve) { | |||||
| tob->extra = vmir; | |||||
| } | |||||
| } | |||||
| tob++; | |||||
| } | |||||
| } | |||||
| } | |||||
| if (island_info) { | |||||
| MEM_freeN(island_info); | |||||
| MEM_freeN(island_vert_map); | |||||
| } | |||||
| if (mirror != 0) { | |||||
| tob = tc->data; | |||||
| for (a = 0; a < tc->data_len; a++, tob++) { | |||||
| if (ABS(tob->loc[0]) <= 0.00001f) { | |||||
| tob->flag |= TD_MIRROR_EDGE; | |||||
| } | |||||
| } | |||||
| } | |||||
| cleanup: | |||||
| /* crazy space free */ | |||||
| if (quats) { | |||||
| MEM_freeN(quats); | |||||
| } | |||||
| if (defmats) { | |||||
| MEM_freeN(defmats); | |||||
| } | |||||
| if (dists) { | |||||
| MEM_freeN(dists); | |||||
| } | |||||
| if (dists_index) { | |||||
| MEM_freeN(dists_index); | |||||
| } | |||||
| if (tc->mirror.axis_flag) { | |||||
| EDBM_verts_mirror_cache_end(em); | |||||
| } | |||||
| } | |||||
| } | |||||