Blender V5.3
transform_convert_mesh_skin.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "DNA_mesh_types.h"
10#include "DNA_meshdata_types.h"
11
12#include "MEM_guardedalloc.h"
13
14#include "BLI_math_matrix_c.hh"
15#include "BLI_math_vector_c.hh"
17
18#include "BKE_context.hh"
19#include "BKE_editmesh.hh"
20
21#include "transform.hh"
23
24#include "transform_convert.hh"
25
26namespace blender::ed::transform {
27
28/* -------------------------------------------------------------------- */
31
32static float *mesh_skin_transdata_center(const TransIslandData *island_data,
33 const int island_index,
34 BMVert *eve)
35{
36 if (island_data->center && island_index != -1) {
37 return island_data->center[island_index];
38 }
39 return eve->co;
40}
41
43 BMVert *eve,
44 const TransIslandData *island_data,
45 const int island_index,
46 const int cd_skin_radius_offset)
47{
49 td->flag = 0;
50 if (cd_skin_radius_offset != -1) {
51 float2 *radius = static_cast<float2 *>(BM_ELEM_CD_GET_VOID_P(eve, cd_skin_radius_offset));
52 copy_v2_v2(td->iloc, *radius);
53 td->loc = *radius;
54 }
55 else {
56 td->flag |= TD_SKIP;
57 }
58
60 td->flag |= TD_SELECTED;
61 }
62
63 copy_v3_v3(td->center, mesh_skin_transdata_center(island_data, island_index, eve));
64 td->extra = eve;
65}
66
67static void createTransMeshSkin(bContext * /*C*/, TransInfo *t)
68{
71 BMEditMesh *em = BKE_editmesh_from_object(tc->obedit);
72 Mesh *mesh = id_cast<Mesh *>(tc->obedit->data);
74 BMVert *eve;
75 BMIter iter;
76 float mtx[3][3], smtx[3][3];
77 int a;
78 const int prop_mode = (t->flag & T_PROP_EDIT) ? (t->flag & T_PROP_EDIT_ALL) : 0;
79
80 TransIslandData island_data = {nullptr};
81 TransMirrorData mirror_data = {nullptr};
82 TransMeshDataCrazySpace crazyspace_data = {nullptr};
83
90
91 const int cd_skin_radius_offset = CustomData_get_offset_named(
92 &bm->vdata, CD_PROP_FLOAT2, "skin_modifier_radius");
93 if (cd_skin_radius_offset == -1) {
94 continue;
95 }
96
97 /* Support other objects using proportional editing to adjust these, unless connected is
98 * enabled. */
99 if ((!prop_mode || (prop_mode & T_PROP_CONNECTED)) && (bm->totvertsel == 0)) {
100 continue;
101 }
102
103 int data_len = 0;
104 if (prop_mode) {
105 BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
107 data_len++;
108 }
109 }
110 }
111 else {
112 data_len = bm->totvertsel;
113 }
114
115 if (data_len == 0) {
116 continue;
117 }
118
119 const bool is_island_center = (t->around == V3D_AROUND_LOCAL_ORIGINS);
120 if (is_island_center) {
121 /* In this specific case, near-by vertices will need to know
122 * the island of the nearest connected vertex. */
123 const bool calc_single_islands = ((prop_mode & T_PROP_CONNECTED) &&
126
127 const bool calc_island_center = false;
128 const bool calc_island_axismtx = false;
129
131 em, bm, calc_single_islands, calc_island_center, calc_island_axismtx, &island_data);
132 }
133
134 copy_m3_m4(mtx, tc->obedit->object_to_world().ptr());
135 /* We use a pseudo-inverse so that when one of the axes is scaled to 0,
136 * matrix inversion still works and we can still moving along the other. */
138
139 /* Original index of our connected vertex when connected distances are calculated.
140 * Optional, allocate if needed. */
141 int *dists_index = nullptr;
142 float *dists = nullptr;
143 if (prop_mode & T_PROP_CONNECTED) {
145 if (is_island_center) {
146 dists_index = MEM_new_array_uninitialized<int>(bm->totvert, __func__);
147 }
148 transform_convert_mesh_connectivity_distance(bm, mtx, dists, dists_index);
149 }
150
151 /* Create TransDataMirror. */
152 if (tc->use_mirror_axis_any) {
153 bool use_topology = (mesh->editflag & ME_EDIT_MIRROR_TOPO) != 0;
154 bool use_select = (t->flag & T_PROP_EDIT) == 0;
155 const bool mirror_axis[3] = {
156 bool(tc->use_mirror_axis_x), bool(tc->use_mirror_axis_y), bool(tc->use_mirror_axis_z)};
158 em, bm, use_select, use_topology, mirror_axis, &mirror_data);
159
160 if (mirror_data.vert_map) {
161 tc->data_mirror_len = mirror_data.mirror_elem_len;
162 tc->data_mirror = MEM_new_array_zeroed<TransDataMirror>(mirror_data.mirror_elem_len,
163 __func__);
164
165 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, a) {
166 if (prop_mode || BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
167 if (mirror_data.vert_map[a].index != -1) {
168 data_len--;
169 }
170 }
171 }
172 }
173 }
174
175 /* Detect CrazySpace [TM]. */
176 transform_convert_mesh_crazyspace_detect(t, tc, &crazyspace_data);
177
178 /* Create TransData. */
179 BLI_assert(data_len >= 1);
180 tc->data_len = data_len;
181 tc->data = MEM_new_array_zeroed<TransData>(data_len, "TransObData(Mesh EditMode)");
182
183 TransData *td = tc->data;
184 TransDataMirror *td_mirror = tc->data_mirror;
185 BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, a) {
187 continue;
188 }
189
190 int island_index = -1;
191 if (island_data.island_vert_map) {
192 const int connected_index = (dists_index && dists_index[a] != -1) ? dists_index[a] : a;
193 island_index = island_data.island_vert_map[connected_index];
194 }
195
196 if (mirror_data.vert_map && mirror_data.vert_map[a].index != -1) {
197 mesh_skin_transdata_create(static_cast<TransDataBasic *>(td_mirror),
198 eve,
199 &island_data,
200 island_index,
201 cd_skin_radius_offset);
202
203 int elem_index = mirror_data.vert_map[a].index;
204 BMVert *v_src = BM_vert_at_index(bm, elem_index);
205 float2 *radius_src = static_cast<float2 *>(
206 BM_ELEM_CD_GET_VOID_P(v_src, cd_skin_radius_offset));
207
208 td_mirror->flag |= mirror_data.vert_map[a].flag;
209 td_mirror->loc_src = *radius_src;
210 td_mirror++;
211 }
212 else if (prop_mode || BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
214 eve,
215 &island_data,
216 island_index,
217 cd_skin_radius_offset);
218
220 createSpaceNormal(td->axismtx, eve->no);
221 }
222 else {
223 /* Setting normals. */
224 copy_v3_v3(td->axismtx[2], eve->no);
225 td->axismtx[0][0] = td->axismtx[0][1] = td->axismtx[0][2] = td->axismtx[1][0] =
226 td->axismtx[1][1] = td->axismtx[1][2] = 0.0f;
227 }
228
229 if (prop_mode) {
230 if (prop_mode & T_PROP_CONNECTED) {
231 td->dist = dists[a];
232 }
233 else {
234 td->dist = FLT_MAX;
235 }
236 }
237
238 /* CrazySpace. */
240 mtx,
241 smtx,
242 !crazyspace_data.defmats.is_empty() ? crazyspace_data.defmats[a].ptr() : nullptr,
243 crazyspace_data.quats && BM_elem_flag_test(eve, BM_ELEM_TAG) ?
244 crazyspace_data.quats[a] :
245 nullptr,
246 td);
247
248 td++;
249 }
250 }
251
255 if (dists) {
256 MEM_delete(dists);
257 }
258 if (dists_index) {
259 MEM_delete(dists_index);
260 }
261 }
262}
263
265
266/* -------------------------------------------------------------------- */
269
271{
273 if (tc->use_mirror_axis_any) {
274 TransDataMirror *td_mirror = tc->data_mirror;
275 for (int i = 0; i < tc->data_mirror_len; i++, td_mirror++) {
276 copy_v3_v3(td_mirror->loc, td_mirror->loc_src);
277 }
278 }
279 }
280}
281
283{
284 bool is_canceling = t->state == TRANS_CANCEL;
285 /* Mirror modifier clipping? */
286 if (!is_canceling) {
287 if (!(t->flag & T_NO_MIRROR)) {
289 }
290 }
291
293 DEG_id_tag_update(tc->obedit->data, ID_RECALC_GEOMETRY);
294 BMEditMesh *em = BKE_editmesh_from_object(tc->obedit);
296 }
297}
298
300
302 /*flags*/ (T_EDIT | T_POINTS),
303 /*create_trans_data*/ createTransMeshSkin,
304 /*recalc_data*/ recalcData_mesh_skin,
305 /*special_aftertrans_update*/ nullptr,
306};
307
308} // namespace blender::ed::transform
#define PSEUDOINVERSE_EPSILON
Read Blender memory allocation and freeing.
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_elem_flag_test(ele, hflag)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_ITER_MESH_INDEX(ele, iter, bm, itype, indexvar)
#define FLT_MAX
void transform_convert_mesh_crazyspace_detect(TransInfo *t, TransDataContainer *tc, TransMeshDataCrazySpace *r_crazyspace_data)
static float * mesh_skin_transdata_center(const TransIslandData *island_data, const int island_index, BMVert *eve)
void transform_convert_mesh_mirrordata_calc(BMEditMesh *em, BMesh *bm, bool use_select, bool use_topology, const bool mirror_axis[3], TransMirrorData *r_mirror_data)
void transform_convert_mesh_mirrordata_free(TransMirrorData *mirror_data)
void transform_convert_mesh_islanddata_free(TransIslandData *island_data)
void transform_convert_mesh_crazyspace_free(TransMeshDataCrazySpace *r_crazyspace_data)
void transform_convert_mesh_islands_calc(BMEditMesh *em, BMesh *bm, bool calc_single_islands, bool calc_island_center, bool calc_island_axismtx, TransIslandData *r_island_data)
static void mesh_skin_apply_to_mirror(TransInfo *t)
void transform_convert_mesh_crazyspace_transdata_set(const float mtx[3][3], const float smtx[3][3], const float defmat[3][3], const float quat[4], TransData *r_td)
bool createSpaceNormal(float mat[3][3], const float normal[3])
static void createTransMeshSkin(bContext *, TransInfo *t)
TransConvertTypeInfo TransConvertType_MeshSkin
static void mesh_skin_transdata_create(TransDataBasic *td, BMVert *eve, const TransIslandData *island_data, const int island_index, const int cd_skin_radius_offset)
void transform_convert_mesh_connectivity_distance(BMesh *bm, const float mtx[3][3], float *dists, int *index)
static void recalcData_mesh_skin(TransInfo *t)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
Definition editmesh.cc:79
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void copy_m3_m4(float m1[3][3], const float m2[4][4])
MINLINE void copy_v2_v2(float r[2], const float a[2])
@ V3D_AROUND_LOCAL_ORIGINS
VecBase< float, 2 > float2
@ ME_EDIT_MIRROR_TOPO
void DEG_id_tag_update(ID *id, unsigned int flags)
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
void BKE_editmesh_looptris_and_normals_calc(BMEditMesh *em, BMesh *bm)
Definition editmesh.cc:122
BLI_INLINE BMVert * BM_vert_at_index(BMesh *bm, const int index)
BMEditMesh * BKE_editmesh_from_object(Object *ob)
Return the BMEditMesh for a given object.
Definition editmesh.cc:59
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
void pseudoinverse_m3_m3(float inverse[3][3], const float mat[3][3], float epsilon)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
CustomData vdata
#define T_PROP_EDIT_ALL
Definition transform.hh:34
#define FOREACH_TRANS_DATA_CONTAINER(t, th)
Definition transform.hh:48
conversion and adaptation of different datablocks to a common struct.