Blender V5.3
bmesh_interp.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2007 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include <algorithm>
12
13#include "MEM_guardedalloc.h"
14
15#include "DNA_meshdata_types.h"
16
17#include "BLI_array.hh"
18#include "BLI_linklist.hh"
19#include "BLI_math_geom_c.hh"
20#include "BLI_math_matrix_c.hh"
21#include "BLI_math_vector_c.hh"
23#include "BLI_memarena.hh"
24#include "BLI_task_c.hh"
25
26#include "BKE_attribute.h"
27#include "BKE_attribute.hh"
29#include "BKE_customdata.hh"
30#include "BKE_multires.hh"
31
32#include "bmesh.hh"
34
35namespace blender {
36
37/* edge and vertex share, currently there's no need to have different logic */
38static void bm_data_interp_from_elem(CustomData *data_layer,
39 const BMElem *ele_src_1,
40 const BMElem *ele_src_2,
41 BMElem *ele_dst,
42 const float fac)
43{
44 if (ele_src_1->head.data && ele_src_2->head.data) {
45 /* first see if we can avoid interpolation */
46 if (fac <= 0.0f) {
47 if (ele_src_1 == ele_dst) {
48 /* do nothing */
49 }
50 else {
51 CustomData_bmesh_copy_block(*data_layer, ele_src_1->head.data, &ele_dst->head.data);
52 }
53 }
54 else if (fac >= 1.0f) {
55 if (ele_src_2 == ele_dst) {
56 /* do nothing */
57 }
58 else {
59 CustomData_bmesh_copy_block(*data_layer, ele_src_2->head.data, &ele_dst->head.data);
60 }
61 }
62 else {
63 const void *src[2];
64 float w[2];
65
66 src[0] = ele_src_1->head.data;
67 src[1] = ele_src_2->head.data;
68 w[0] = 1.0f - fac;
69 w[1] = fac;
70 CustomData_bmesh_interp(data_layer, src, w, 2, ele_dst->head.data);
71 }
72 }
73}
74
76 BMesh *bm, const BMVert *v_src_1, const BMVert *v_src_2, BMVert *v_dst, const float fac)
77{
79 reinterpret_cast<const BMElem *>(v_src_1),
80 reinterpret_cast<const BMElem *>(v_src_2),
81 reinterpret_cast<BMElem *>(v_dst),
82 fac);
83}
84
86 BMesh *bm, const BMEdge *e_src_1, const BMEdge *e_src_2, BMEdge *e_dst, const float fac)
87{
89 reinterpret_cast<const BMElem *>(e_src_1),
90 reinterpret_cast<const BMElem *>(e_src_2),
91 reinterpret_cast<BMElem *>(e_dst),
92 fac);
93}
94
101static void UNUSED_FUNCTION(BM_Data_Vert_Average)(BMesh * /*bm*/, BMFace * /*f*/)
102{
103 // BMIter iter;
104}
105
107 const BMVert *v_src_1,
108 const BMVert * /*v_src_2*/,
109 BMVert *v,
110 BMEdge *e,
111 const float fac)
112{
113 float w[2];
114 BMLoop *l_v1 = nullptr, *l_v = nullptr, *l_v2 = nullptr;
115 BMLoop *l_iter = nullptr;
116
117 if (!e->l) {
118 return;
119 }
120
121 w[1] = 1.0f - fac;
122 w[0] = fac;
123
124 l_iter = e->l;
125 do {
126 if (l_iter->v == v_src_1) {
127 l_v1 = l_iter;
128 l_v = l_v1->next;
129 l_v2 = l_v->next;
130 }
131 else if (l_iter->v == v) {
132 l_v1 = l_iter->next;
133 l_v = l_iter;
134 l_v2 = l_iter->prev;
135 }
136
137 if (!l_v1 || !l_v2) {
138 return;
139 }
140
141 const void *src[2];
142 src[0] = l_v1->head.data;
143 src[1] = l_v2->head.data;
144
145 CustomData_bmesh_interp(&bm->ldata, src, w, 2, l_v->head.data);
146 } while ((l_iter = l_iter->radial_next) != e->l);
147}
148
150 BMFace *f_dst,
151 const BMFace *f_src,
152 const bool do_vertex,
153 const void **blocks_l,
154 const void **blocks_v,
155 float (*cos_2d)[2],
156 float axis_mat[3][3])
157{
158 BMLoop *l_iter;
159 BMLoop *l_first;
160
162 float co[2];
163
164 /* interpolate */
165 l_iter = l_first = BM_FACE_FIRST_LOOP(f_dst);
166 do {
167 mul_v2_m3v3(co, axis_mat, l_iter->v->co);
168 interp_weights_poly_v2(w.data(), cos_2d, f_src->len, co);
169 CustomData_bmesh_interp(&bm->ldata, blocks_l, w.data(), f_src->len, l_iter->head.data);
170 if (do_vertex) {
171 CustomData_bmesh_interp(&bm->vdata, blocks_v, w.data(), f_src->len, l_iter->v->head.data);
172 }
173 } while ((l_iter = l_iter->next) != l_first);
174}
175
176void BM_face_interp_from_face(BMesh *bm, BMFace *f_dst, const BMFace *f_src, const bool do_vertex)
177{
178 BMLoop *l_iter;
179 BMLoop *l_first;
180
182 Array<const void *, BM_DEFAULT_NGON_STACK_SIZE> blocks_v_buf(do_vertex ? f_src->len : 0);
184 const void **blocks_l = blocks_l_buf.data();
185 const void **blocks_v = do_vertex ? blocks_v_buf.data() : nullptr;
186 float (*cos_2d)[2] = reinterpret_cast<float (*)[2]>(cos_2d_buf.data());
187 float axis_mat[3][3]; /* use normal to transform into 2d xy coords */
188 int i;
189
190 /* convert the 3d coords into 2d for projection */
192 axis_dominant_v3_to_m3(axis_mat, f_src->no);
193
194 i = 0;
195 l_iter = l_first = BM_FACE_FIRST_LOOP(f_src);
196 do {
197 mul_v2_m3v3(cos_2d[i], axis_mat, l_iter->v->co);
198 blocks_l[i] = l_iter->head.data;
199 if (do_vertex) {
200 blocks_v[i] = l_iter->v->head.data;
201 }
202 } while ((void)i++, (l_iter = l_iter->next) != l_first);
203
204 BM_face_interp_from_face_ex(bm, f_dst, f_src, do_vertex, blocks_l, blocks_v, cos_2d, axis_mat);
205}
206
221static int compute_mdisp_quad(const BMLoop *l,
222 const float l_f_center[3],
223 float v1[3],
224 float v2[3],
225 float v3[3],
226 float v4[3],
227 float e1[3],
228 float e2[3])
229{
230 float n[3], p[3];
231
232#ifndef NDEBUG
233 {
234 float cent[3];
235 /* computer center */
237 BLI_assert(equals_v3v3(cent, l_f_center));
238 }
239#endif
240
241 mid_v3_v3v3(p, l->prev->v->co, l->v->co);
242 mid_v3_v3v3(n, l->next->v->co, l->v->co);
243
244 copy_v3_v3(v1, l_f_center);
245 copy_v3_v3(v2, p);
246 copy_v3_v3(v3, l->v->co);
247 copy_v3_v3(v4, n);
248
249 sub_v3_v3v3(e1, v2, v1);
250 sub_v3_v3v3(e2, v3, v4);
251
252 return 1;
253}
254
255static bool quad_co(const float v1[3],
256 const float v2[3],
257 const float v3[3],
258 const float v4[3],
259 const float p[3],
260 const float n[3],
261 float r_uv[2])
262{
263 float projverts[5][3], n2[3];
264 const float origin[2] = {0.0f, 0.0f};
265 int i;
266
267 /* project points into 2d along normal */
268 copy_v3_v3(projverts[0], v1);
269 copy_v3_v3(projverts[1], v2);
270 copy_v3_v3(projverts[2], v3);
271 copy_v3_v3(projverts[3], v4);
272 copy_v3_v3(projverts[4], p);
273
274 normal_quad_v3(n2, projverts[0], projverts[1], projverts[2], projverts[3]);
275
276 if (dot_v3v3(n, n2) < -FLT_EPSILON) {
277 return false;
278 }
279
280 /* rotate */
281 poly_rotate_plane(n, projverts, 5);
282
283 /* subtract origin */
284 for (i = 0; i < 4; i++) {
285 sub_v2_v2(projverts[i], projverts[4]);
286 }
287
288 if (!isect_point_quad_v2(origin, projverts[0], projverts[1], projverts[2], projverts[3])) {
289 return false;
290 }
291
292 resolve_quad_uv_v2(r_uv, origin, projverts[0], projverts[3], projverts[2], projverts[1]);
293
294 return true;
295}
296
297static void mdisp_axis_from_quad(const float v1[3],
298 const float v2[3],
299 float /*v3*/[3],
300 const float v4[3],
301 float r_axis_x[3],
302 float r_axis_y[3])
303{
304 sub_v3_v3v3(r_axis_x, v4, v1);
305 sub_v3_v3v3(r_axis_y, v2, v1);
306
307 normalize_v3(r_axis_x);
308 normalize_v3(r_axis_y);
309}
310
317static bool mdisp_in_mdispquad(BMLoop *l_src,
318 BMLoop *l_dst,
319 const float l_dst_f_center[3],
320 const float p[3],
321 int res,
322 float r_axis_x[3],
323 float r_axis_y[3],
324 float r_uv[2])
325{
326 float v1[3], v2[3], c[3], v3[3], v4[3], e1[3], e2[3];
327 float eps = FLT_EPSILON * 4000;
328
329 if (is_zero_v3(l_src->v->no)) {
331 }
332 if (is_zero_v3(l_dst->v->no)) {
334 }
335
336 compute_mdisp_quad(l_dst, l_dst_f_center, v1, v2, v3, v4, e1, e2);
337
338 /* expand quad a bit */
339 mid_v3_v3v3v3v3(c, v1, v2, v3, v4);
340
341 sub_v3_v3(v1, c);
342 sub_v3_v3(v2, c);
343 sub_v3_v3(v3, c);
344 sub_v3_v3(v4, c);
345 mul_v3_fl(v1, 1.0f + eps);
346 mul_v3_fl(v2, 1.0f + eps);
347 mul_v3_fl(v3, 1.0f + eps);
348 mul_v3_fl(v4, 1.0f + eps);
349 add_v3_v3(v1, c);
350 add_v3_v3(v2, c);
351 add_v3_v3(v3, c);
352 add_v3_v3(v4, c);
353
354 if (!quad_co(v1, v2, v3, v4, p, l_src->v->no, r_uv)) {
355 return false;
356 }
357
358 mul_v2_fl(r_uv, float(res - 1));
359
360 mdisp_axis_from_quad(v1, v2, v3, v4, r_axis_x, r_axis_y);
361
362 return true;
363}
364
365static float bm_loop_flip_equotion(float mat[2][2],
366 float b[2],
367 const float target_axis_x[3],
368 const float target_axis_y[3],
369 const float coord[3],
370 int i,
371 int j)
372{
373 mat[0][0] = target_axis_x[i];
374 mat[0][1] = target_axis_y[i];
375 mat[1][0] = target_axis_x[j];
376 mat[1][1] = target_axis_y[j];
377 b[0] = coord[i];
378 b[1] = coord[j];
379
380 return cross_v2v2(mat[0], mat[1]);
381}
382
383static void bm_loop_flip_disp(const float source_axis_x[3],
384 const float source_axis_y[3],
385 const float target_axis_x[3],
386 const float target_axis_y[3],
387 float disp[3])
388{
389 float vx[3], vy[3], coord[3];
390 float n[3], vec[3];
391 float b[2], mat[2][2], d;
392
393 mul_v3_v3fl(vx, source_axis_x, disp[0]);
394 mul_v3_v3fl(vy, source_axis_y, disp[1]);
395 add_v3_v3v3(coord, vx, vy);
396
397 /* project displacement from source grid plane onto target grid plane */
398 cross_v3_v3v3(n, target_axis_x, target_axis_y);
399 project_v3_v3v3(vec, coord, n);
400 sub_v3_v3v3(coord, coord, vec);
401
402 d = bm_loop_flip_equotion(mat, b, target_axis_x, target_axis_y, coord, 0, 1);
403
404 if (fabsf(d) < 1e-4f) {
405 d = bm_loop_flip_equotion(mat, b, target_axis_x, target_axis_y, coord, 0, 2);
406 if (fabsf(d) < 1e-4f) {
407 d = bm_loop_flip_equotion(mat, b, target_axis_x, target_axis_y, coord, 1, 2);
408 }
409 }
410
411 disp[0] = (b[0] * mat[1][1] - mat[0][1] * b[1]) / d;
412 disp[1] = (mat[0][0] * b[1] - b[0] * mat[1][0]) / d;
413}
414
419
421 const float *f_src_center;
422
423 float *axis_x, *axis_y;
424 float *v1, *v4;
425 float *e1, *e2;
426
427 int res;
428 float d;
429};
430
431static void loop_interp_multires_cb(void *__restrict userdata,
432 const int ix,
433 const TaskParallelTLS *__restrict /*tls*/)
434{
435 BMLoopInterpMultiresData *data = static_cast<BMLoopInterpMultiresData *>(userdata);
436
437 BMLoop *l_first = data->l_src_first;
438 BMLoop *l_dst = data->l_dst;
439 const int cd_loop_mdisp_offset = data->cd_loop_mdisp_offset;
440
441 MDisps *md_dst = data->md_dst;
442 const float *f_src_center = data->f_src_center;
443
444 float *axis_x = data->axis_x;
445 float *axis_y = data->axis_y;
446
447 float *v1 = data->v1;
448 float *v4 = data->v4;
449 float *e1 = data->e1;
450 float *e2 = data->e2;
451
452 const int res = data->res;
453 const float d = data->d;
454
455 float x = d * ix, y;
456 int iy;
457 for (y = 0.0f, iy = 0; iy < res; y += d, iy++) {
458 BMLoop *l_iter = l_first;
459 float co1[3], co2[3], co[3];
460
461 madd_v3_v3v3fl(co1, v1, e1, y);
462 madd_v3_v3v3fl(co2, v4, e2, y);
463 interp_v3_v3v3(co, co1, co2, x);
464
465 do {
466 MDisps *md_src;
467 float src_axis_x[3], src_axis_y[3];
468 float uv[2];
469
470 md_src = static_cast<MDisps *>(BM_ELEM_CD_GET_VOID_P(l_iter, cd_loop_mdisp_offset));
471
472 if (mdisp_in_mdispquad(l_dst, l_iter, f_src_center, co, res, src_axis_x, src_axis_y, uv)) {
473 old_mdisps_bilinear(md_dst->disps[iy * res + ix], md_src->disps, res, uv[0], uv[1]);
474 bm_loop_flip_disp(src_axis_x, src_axis_y, axis_x, axis_y, md_dst->disps[iy * res + ix]);
475
476 break;
477 }
478 } while ((l_iter = l_iter->next) != l_first);
479 }
480}
481
483 BMLoop *l_dst,
484 const BMFace *f_src,
485 const float f_dst_center[3],
486 const float f_src_center[3],
487 const int cd_loop_mdisp_offset)
488{
489 MDisps *md_dst;
490 float v1[3], v2[3], v3[3], v4[3] = {0.0f, 0.0f, 0.0f}, e1[3], e2[3];
491 float axis_x[3], axis_y[3];
492
493 /* ignore 2-edged faces */
494 if (l_dst->f->len < 3) [[unlikely]] {
495 return;
496 }
497
498 md_dst = static_cast<MDisps *>(BM_ELEM_CD_GET_VOID_P(l_dst, cd_loop_mdisp_offset));
499 compute_mdisp_quad(l_dst, f_dst_center, v1, v2, v3, v4, e1, e2);
500
501 /* if no disps data allocate a new grid, the size of the first grid in f_src. */
502 if (!md_dst->totdisp) {
503 const MDisps *md_src = static_cast<const MDisps *>(
504 BM_ELEM_CD_GET_VOID_P(BM_FACE_FIRST_LOOP(f_src), cd_loop_mdisp_offset));
505
506 md_dst->totdisp = md_src->totdisp;
507 if (md_dst->totdisp) {
508 md_dst->disps = MEM_new_array_zeroed<float[3]>(md_dst->totdisp, __func__);
509 }
510 else {
511 return;
512 }
513 }
514
515 mdisp_axis_from_quad(v1, v2, v3, v4, axis_x, axis_y);
516
517 const int res = int(sqrt(md_dst->totdisp));
519 data.l_dst = l_dst;
520 data.l_src_first = BM_FACE_FIRST_LOOP(f_src);
521 data.cd_loop_mdisp_offset = cd_loop_mdisp_offset;
522 data.md_dst = md_dst;
523 data.f_src_center = f_src_center;
524 data.axis_x = axis_x;
525 data.axis_y = axis_y;
526 data.v1 = v1;
527 data.v4 = v4;
528 data.e1 = e1;
529 data.e2 = e2;
530 data.res = res;
531 data.d = 1.0f / float(res - 1);
532
533 TaskParallelSettings settings;
535 settings.use_threading = (res > 5);
537}
538
539void BM_loop_interp_multires(BMesh *bm, BMLoop *l_dst, const BMFace *f_src)
540{
541 const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
542
543 if (cd_loop_mdisp_offset != -1) {
544 float f_dst_center[3];
545 float f_src_center[3];
546
547 BM_face_calc_center_median(l_dst->f, f_dst_center);
548 BM_face_calc_center_median(f_src, f_src_center);
549
550 BM_loop_interp_multires_ex(bm, l_dst, f_src, f_dst_center, f_src_center, cd_loop_mdisp_offset);
551 }
552}
553
555 BMFace *f_dst,
556 const BMFace *f_src,
557 const float f_dst_center[3],
558 const float f_src_center[3],
559 const int cd_loop_mdisp_offset)
560{
561 BMLoop *l_iter, *l_first;
562 l_iter = l_first = BM_FACE_FIRST_LOOP(f_dst);
563 do {
565 bm, l_iter, f_src, f_dst_center, f_src_center, cd_loop_mdisp_offset);
566 } while ((l_iter = l_iter->next) != l_first);
567}
568
569void BM_face_interp_multires(BMesh *bm, BMFace *f_dst, const BMFace *f_src)
570{
571 const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
572
573 if (cd_loop_mdisp_offset != -1) {
574 float f_dst_center[3];
575 float f_src_center[3];
576
577 BM_face_calc_center_median(f_dst, f_dst_center);
578 BM_face_calc_center_median(f_src, f_src_center);
579
580 BM_face_interp_multires_ex(bm, f_dst, f_src, f_dst_center, f_src_center, cd_loop_mdisp_offset);
581 }
582}
583
585{
586 const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
587 BMLoop *l;
588 BMIter liter;
589
590 if (cd_loop_mdisp_offset == -1) {
591 return;
592 }
593
594 BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
595 MDisps *mdp = static_cast<MDisps *>(BM_ELEM_CD_GET_VOID_P(l->prev, cd_loop_mdisp_offset));
596 MDisps *mdl = static_cast<MDisps *>(BM_ELEM_CD_GET_VOID_P(l, cd_loop_mdisp_offset));
597 MDisps *mdn = static_cast<MDisps *>(BM_ELEM_CD_GET_VOID_P(l->next, cd_loop_mdisp_offset));
598 float co1[3];
599 int sides;
600 int y;
601
616
617 sides = int(sqrt(mdp->totdisp));
618 for (y = 0; y < sides; y++) {
619 mid_v3_v3v3(co1, mdn->disps[y * sides], mdl->disps[y]);
620
621 copy_v3_v3(mdn->disps[y * sides], co1);
622 copy_v3_v3(mdl->disps[y], co1);
623 }
624 }
625
626 BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
627 MDisps *mdl1 = static_cast<MDisps *>(BM_ELEM_CD_GET_VOID_P(l, cd_loop_mdisp_offset));
628 MDisps *mdl2;
629 float co1[3], co2[3], co[3];
630 int sides;
631 int y;
632
647
648 if (l->radial_next == l) {
649 continue;
650 }
651
652 if (l->radial_next->v == l->v) {
653 mdl2 = static_cast<MDisps *>(BM_ELEM_CD_GET_VOID_P(l->radial_next, cd_loop_mdisp_offset));
654 }
655 else {
656 mdl2 = static_cast<MDisps *>(
657 BM_ELEM_CD_GET_VOID_P(l->radial_next->next, cd_loop_mdisp_offset));
658 }
659
660 sides = int(sqrt(mdl1->totdisp));
661 for (y = 0; y < sides; y++) {
662 int a1, a2, o1, o2;
663
664 if (l->v != l->radial_next->v) {
665 a1 = sides * y + sides - 2;
666 a2 = (sides - 2) * sides + y;
667
668 o1 = sides * y + sides - 1;
669 o2 = (sides - 1) * sides + y;
670 }
671 else {
672 a1 = sides * y + sides - 2;
673 a2 = sides * y + sides - 2;
674 o1 = sides * y + sides - 1;
675 o2 = sides * y + sides - 1;
676 }
677
678 /* magic blending numbers, hardcoded! */
679 add_v3_v3v3(co1, mdl1->disps[a1], mdl2->disps[a2]);
680 mul_v3_fl(co1, 0.18);
681
682 add_v3_v3v3(co2, mdl1->disps[o1], mdl2->disps[o2]);
683 mul_v3_fl(co2, 0.32);
684
685 add_v3_v3v3(co, co1, co2);
686
687 copy_v3_v3(mdl1->disps[o1], co);
688 copy_v3_v3(mdl2->disps[o2], co);
689 }
690 }
691}
692
694 BMesh *bm, BMLoop *l_dst, const BMFace *f_src, const bool do_vertex, const bool do_multires)
695{
696 BMLoop *l_iter;
697 BMLoop *l_first;
698 Array<const void *, BM_DEFAULT_NGON_STACK_SIZE> vblocks_buf(do_vertex ? f_src->len : 0);
702 const void **vblocks = do_vertex ? vblocks_buf.data() : nullptr;
703 const void **blocks = blocks_buf.data();
704 float (*cos_2d)[2] = reinterpret_cast<float (*)[2]>(cos_2d_buf.data());
705 float axis_mat[3][3]; /* use normal to transform into 2d xy coords */
706 float co[2];
707
708 /* Convert the 3d coords into 2d for projection. */
709 float axis_dominant[3];
710 if (!is_zero_v3(f_src->no)) {
711 BLI_assert(BM_face_is_normal_valid(f_src));
712 copy_v3_v3(axis_dominant, f_src->no);
713 }
714 else {
715 /* Rare case in which all the vertices of the face are aligned.
716 * Get a random axis that is orthogonal to the tangent. */
717 float vec[3];
718 BM_face_calc_tangent_auto(f_src, vec);
719 ortho_v3_v3(axis_dominant, vec);
720 normalize_v3(axis_dominant);
721 }
722 axis_dominant_v3_to_m3(axis_mat, axis_dominant);
723
724 int i = 0;
725 l_iter = l_first = BM_FACE_FIRST_LOOP(f_src);
726 do {
727 mul_v2_m3v3(cos_2d[i], axis_mat, l_iter->v->co);
728 blocks[i] = l_iter->head.data;
729
730 if (do_vertex) {
731 vblocks[i] = l_iter->v->head.data;
732 }
733 } while ((void)i++, (l_iter = l_iter->next) != l_first);
734
735 mul_v2_m3v3(co, axis_mat, l_dst->v->co);
736
737 /* interpolate */
738 interp_weights_poly_v2(w.data(), cos_2d, f_src->len, co);
739 CustomData_bmesh_interp(&bm->ldata, blocks, w.data(), f_src->len, l_dst->head.data);
740 if (do_vertex) {
741 CustomData_bmesh_interp(&bm->vdata, vblocks, w.data(), f_src->len, l_dst->v->head.data);
742 }
743
744 if (do_multires) {
745 BM_loop_interp_multires(bm, l_dst, f_src);
746 }
747}
748
749void BM_vert_interp_from_face(BMesh *bm, BMVert *v_dst, const BMFace *f_src)
750{
751 BMLoop *l_iter;
752 BMLoop *l_first;
756 const void **blocks = blocks_buf.data();
757 float (*cos_2d)[2] = reinterpret_cast<float (*)[2]>(cos_2d_buf.data());
758 float axis_mat[3][3]; /* use normal to transform into 2d xy coords */
759 float co[2];
760
761 /* convert the 3d coords into 2d for projection */
763 axis_dominant_v3_to_m3(axis_mat, f_src->no);
764
765 int i = 0;
766 l_iter = l_first = BM_FACE_FIRST_LOOP(f_src);
767 do {
768 mul_v2_m3v3(cos_2d[i], axis_mat, l_iter->v->co);
769 blocks[i] = l_iter->v->head.data;
770 } while ((void)i++, (l_iter = l_iter->next) != l_first);
771
772 mul_v2_m3v3(co, axis_mat, v_dst->co);
773
774 /* interpolate */
775 interp_weights_poly_v2(w.data(), cos_2d, f_src->len, co);
776 CustomData_bmesh_interp(&bm->vdata, blocks, w.data(), f_src->len, v_dst->head.data);
777}
778
780{
782
783 BMIter iter;
784 BLI_mempool *oldpool = olddata->pool;
785 void *block;
786
787 if (data == &bm->vdata) {
788 BMVert *eve;
789
791
792 BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
793 block = nullptr;
794 CustomData_bmesh_copy_block(*data, cd_map, eve->head.data, &block);
795 CustomData_bmesh_free_block(olddata, &eve->head.data);
796 eve->head.data = block;
797 }
798 }
799 else if (data == &bm->edata) {
800 BMEdge *eed;
801
803
804 BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
805 block = nullptr;
806 CustomData_bmesh_copy_block(*data, cd_map, eed->head.data, &block);
807 CustomData_bmesh_free_block(olddata, &eed->head.data);
808 eed->head.data = block;
809 }
810 }
811 else if (data == &bm->ldata) {
812 BMIter liter;
813 BMFace *efa;
814 BMLoop *l;
815
817 BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
818 BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
819 block = nullptr;
820 CustomData_bmesh_copy_block(*data, cd_map, l->head.data, &block);
822 l->head.data = block;
823 }
824 }
825 }
826 else if (data == &bm->pdata) {
827 BMFace *efa;
828
830
831 BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
832 block = nullptr;
833 CustomData_bmesh_copy_block(*data, cd_map, efa->head.data, &block);
834 CustomData_bmesh_free_block(olddata, &efa->head.data);
835 efa->head.data = block;
836 }
837 }
838 else {
839 /* should never reach this! */
840 BLI_assert(0);
841 }
842
843 if (oldpool) {
844 /* this should never happen but can when dissolve fails - #28960. */
845 BLI_assert(data->pool != oldpool);
846
847 BLI_mempool_destroy(oldpool);
848 }
849}
850
852{
853 CustomData olddata = *data;
854 olddata.layers = (olddata.layers) ? MEM_dupalloc(olddata.layers) : nullptr;
855 /* The pool is now owned by `olddata` and must not be shared. */
856 data->pool = nullptr;
857
859
860 update_data_blocks(bm, &olddata, data);
861 if (olddata.layers) {
862 MEM_delete(olddata.layers);
863 }
864}
865
867{
868 CustomData olddata = *data;
869 olddata.layers = (olddata.layers) ? MEM_dupalloc(olddata.layers) : nullptr;
870 /* The pool is now owned by `olddata` and must not be shared. */
871 data->pool = nullptr;
872
874
875 update_data_blocks(bm, &olddata, data);
876 if (olddata.layers) {
877 MEM_delete(olddata.layers);
878 }
879}
880
882{
883 if (CustomData_get_named_layer_index(data, eCustomDataType(type), name) == -1) {
884 BM_data_layer_add_named(bm, data, type, name);
885 }
886}
887
889{
890 const int nr_uv_layers = CustomData_number_of_layers(&bm->ldata, CD_PROP_FLOAT2);
891 for (int l = 0; l < nr_uv_layers; l++) {
892 /* NOTE: you can't re-use the return-value of #CustomData_get_layer_name()
893 * because adding layers can invalidate that. */
894 char name[MAX_CUSTOMDATA_LAYER_NAME];
896 bm,
897 &bm->ldata,
900 }
901}
902
904{
905 char name[MAX_CUSTOMDATA_LAYER_NAME];
907 bm, &bm->ldata, CD_PROP_BOOL, BKE_uv_map_pin_name_get(uv_map_name, name));
908}
909
910bool BM_uv_map_attr_pin_exists(const BMesh *bm, const StringRef uv_map_name)
911{
912 char name[MAX_CUSTOMDATA_LAYER_NAME];
914 &bm->ldata, CD_PROP_BOOL, BKE_uv_map_pin_name_get(uv_map_name, name)) != -1);
915}
916
918{
919 CustomData olddata = *data;
920 olddata.layers = (olddata.layers) ? MEM_dupalloc(olddata.layers) : nullptr;
921 /* The pool is now owned by `olddata` and must not be shared. */
922 data->pool = nullptr;
923
924 const bool had_layer = CustomData_free_layer_active(data, eCustomDataType(type));
925 /* Assert because its expensive to reallocate - better not do if layer isn't present. */
926 BLI_assert(had_layer != false);
927 UNUSED_VARS_NDEBUG(had_layer);
928
929 update_data_blocks(bm, &olddata, data);
930 if (olddata.layers) {
931 MEM_delete(olddata.layers);
932 }
933}
934
936{
937 CustomData olddata = *data;
938 olddata.layers = (olddata.layers) ? MEM_dupalloc(olddata.layers) : nullptr;
939 /* The pool is now owned by `olddata` and must not be shared. */
940 data->pool = nullptr;
941
942 const bool had_layer = CustomData_free_layer_named(data, name);
943
944 if (had_layer) {
945 update_data_blocks(bm, &olddata, data);
946 }
947 else {
948 /* Move pool ownership back to BMesh CustomData, no block reallocation. */
949 data->pool = olddata.pool;
950 }
951
952 if (olddata.layers) {
953 MEM_delete(olddata.layers);
954 }
955
956 return had_layer;
957}
958
959void BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n)
960{
961 CustomData olddata = *data;
962 olddata.layers = (olddata.layers) ? MEM_dupalloc(olddata.layers) : nullptr;
963 /* The pool is now owned by `olddata` and must not be shared. */
964 data->pool = nullptr;
965
966 const bool had_layer = CustomData_free_layer(
968 /* Assert because its expensive to realloc - better not do if layer isn't present. */
969 BLI_assert(had_layer != false);
970 UNUSED_VARS_NDEBUG(had_layer);
971
972 update_data_blocks(bm, &olddata, data);
973 if (olddata.layers) {
974 MEM_delete(olddata.layers);
975 }
976}
977
978void BM_data_layer_copy(BMesh *bm, CustomData *data, int type, int src_n, int dst_n)
979{
980 BMIter iter;
981
982 if (&bm->vdata == data) {
983 BMVert *eve;
984
985 BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
986 void *ptr = CustomData_bmesh_get_n(data, eve->head.data, eCustomDataType(type), src_n);
987 CustomData_bmesh_set_n(data, eve->head.data, eCustomDataType(type), dst_n, ptr);
988 }
989 }
990 else if (&bm->edata == data) {
991 BMEdge *eed;
992
993 BM_ITER_MESH (eed, &iter, bm, BM_EDGES_OF_MESH) {
994 void *ptr = CustomData_bmesh_get_n(data, eed->head.data, eCustomDataType(type), src_n);
995 CustomData_bmesh_set_n(data, eed->head.data, eCustomDataType(type), dst_n, ptr);
996 }
997 }
998 else if (&bm->pdata == data) {
999 BMFace *efa;
1000
1001 BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
1002 void *ptr = CustomData_bmesh_get_n(data, efa->head.data, eCustomDataType(type), src_n);
1003 CustomData_bmesh_set_n(data, efa->head.data, eCustomDataType(type), dst_n, ptr);
1004 }
1005 }
1006 else if (&bm->ldata == data) {
1007 BMIter liter;
1008 BMFace *efa;
1009 BMLoop *l;
1010
1011 BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
1012 BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
1013 void *ptr = CustomData_bmesh_get_n(data, l->head.data, eCustomDataType(type), src_n);
1014 CustomData_bmesh_set_n(data, l->head.data, eCustomDataType(type), dst_n, ptr);
1015 }
1016 }
1017 }
1018 else {
1019 /* should never reach this! */
1020 BLI_assert(0);
1021 }
1022}
1023
1024float BM_elem_float_data_get(CustomData *cd, void *element, int type)
1025{
1026 const float *f = static_cast<const float *>(
1027 CustomData_bmesh_get(cd, (static_cast<BMHeader *>(element))->data, eCustomDataType(type)));
1028 return f ? *f : 0.0f;
1029}
1030
1031void BM_elem_float_data_set(CustomData *cd, void *element, int type, const float val)
1032{
1033 float *f = static_cast<float *>(
1034 CustomData_bmesh_get(cd, (static_cast<BMHeader *>(element))->data, eCustomDataType(type)));
1035 if (f) {
1036 *f = val;
1037 }
1038}
1039
1041{
1043 if (const std::optional<bke::AttrType> type = bke::custom_data_type_to_attr_type(
1044 eCustomDataType(layer.type)))
1045 {
1046 if (layer.name == name) {
1047 return {layer.offset, bke::AttrDomain::Point, *type, &layer};
1048 }
1049 }
1050 }
1052 if (const std::optional<bke::AttrType> type = bke::custom_data_type_to_attr_type(
1053 eCustomDataType(layer.type)))
1054 {
1055 if (layer.name == name) {
1056 return {layer.offset, bke::AttrDomain::Edge, *type, &layer};
1057 }
1058 }
1059 }
1061 if (const std::optional<bke::AttrType> type = bke::custom_data_type_to_attr_type(
1062 eCustomDataType(layer.type)))
1063 {
1064 if (layer.name == name) {
1065 return {layer.offset, bke::AttrDomain::Face, *type, &layer};
1066 }
1067 }
1068 }
1070 if (const std::optional<bke::AttrType> type = bke::custom_data_type_to_attr_type(
1071 eCustomDataType(layer.type)))
1072 {
1073 if (layer.name == name) {
1074 return {layer.offset, bke::AttrDomain::Corner, *type, &layer};
1075 }
1076 }
1077 }
1078 return {};
1079}
1080
1081/* -------------------------------------------------------------------- */
1099
1101 /* same for all groups */
1102 int type;
1104 const float *loop_weights;
1106
1107 /* --- Per loop fan vars --- */
1108
1109 /* reference for this contiguous fan */
1110 const void *data_ref;
1112
1113 /* accumulate 'LoopGroupCD.weight' to make unit length */
1115
1116 /* both arrays the size of the 'BM_vert_face_count(v)'
1117 * each contiguous fan gets a slide of these arrays */
1121};
1122
1123/* Store vars to pass into 'CustomData_bmesh_interp' */
1125 /* direct customdata pointer array */
1126 void **data;
1127 /* weights (aligned with 'data') */
1129 /* index-in-face */
1131 /* number of loops in the fan */
1133};
1134
1136{
1137 const int i = BM_elem_index_get(l);
1138 const float w = lwc->loop_weights[i];
1141 lwc->data_index_array[lwc->data_len] = i;
1142 lwc->weight_array[lwc->data_len] = w;
1143 lwc->weight_accum += w;
1144
1145 lwc->data_len += 1;
1146}
1147
1153static void bm_loop_walk_data(LoopWalkCtx *lwc, BMLoop *l_walk)
1154{
1155 int i;
1156
1157 BLI_assert(
1158 /* Include pointer equality to prevent assert if any of the values include NAN,
1159 * making it seem like there is a bug when there isn't. */
1160 (lwc->data_ref == BM_ELEM_CD_GET_VOID_P(l_walk, lwc->cd_layer_offset)) ||
1162 lwc->data_ref,
1163 BM_ELEM_CD_GET_VOID_P(l_walk, lwc->cd_layer_offset)));
1165
1166 bm_loop_walk_add(lwc, l_walk);
1167
1168 /* recurse around this loop-fan (in both directions) */
1169 for (i = 0; i < 2; i++) {
1170 BMLoop *l_other = ((i == 0) ? l_walk : l_walk->prev)->radial_next;
1171 if (l_other->radial_next != l_other) {
1172 if (l_other->v != l_walk->v) {
1173 l_other = l_other->next;
1174 }
1175 BLI_assert(l_other->v == l_walk->v);
1178 lwc->data_ref,
1179 BM_ELEM_CD_GET_VOID_P(l_other, lwc->cd_layer_offset)))
1180 {
1181 bm_loop_walk_data(lwc, l_other);
1182 }
1183 }
1184 }
1185 }
1186}
1187
1189 BMesh *bm, BMVert *v, const int layer_n, const float *loop_weights, MemArena *arena)
1190{
1191 LoopWalkCtx lwc;
1192 LinkNode *groups = nullptr;
1193 BMLoop *l;
1194 BMIter liter;
1195 int loop_num;
1196
1197 lwc.type = bm->ldata.layers[layer_n].type;
1198 lwc.cd_layer_offset = bm->ldata.layers[layer_n].offset;
1199 lwc.loop_weights = loop_weights;
1200 lwc.arena = arena;
1201
1202 /* Enable 'BM_ELEM_INTERNAL_TAG', leaving the flag clean on completion. */
1203 loop_num = 0;
1204 BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
1206 BM_elem_index_set(l, loop_num); /* set_dirty! */
1207 loop_num++;
1208 }
1210
1211 lwc.data_len = 0;
1212 lwc.data_array = static_cast<void **>(BLI_memarena_alloc(lwc.arena, sizeof(void *) * loop_num));
1213 lwc.data_index_array = static_cast<int *>(BLI_memarena_alloc(lwc.arena, sizeof(int) * loop_num));
1214 lwc.weight_array = static_cast<float *>(BLI_memarena_alloc(lwc.arena, sizeof(float) * loop_num));
1215
1216 BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
1218 LoopGroupCD *lf = static_cast<LoopGroupCD *>(BLI_memarena_alloc(lwc.arena, sizeof(*lf)));
1219 int len_prev = lwc.data_len;
1220
1222
1223 /* assign len-last */
1224 lf->data = &lwc.data_array[lwc.data_len];
1225 lf->data_index = &lwc.data_index_array[lwc.data_len];
1226 lf->data_weights = &lwc.weight_array[lwc.data_len];
1227 lwc.weight_accum = 0.0f;
1228
1229 /* new group */
1230 bm_loop_walk_data(&lwc, l);
1231 lf->data_len = lwc.data_len - len_prev;
1232
1233 if (lwc.weight_accum != 0.0f) [[likely]] {
1234 mul_vn_fl(lf->data_weights, lf->data_len, 1.0f / lwc.weight_accum);
1235 }
1236 else {
1237 std::fill_n(lf->data_weights, lf->data_len, 1.0f / float(lf->data_len));
1238 }
1239
1240 BLI_linklist_prepend_arena(&groups, lf, lwc.arena);
1241 }
1242 }
1243
1244 BLI_assert(lwc.data_len == loop_num);
1245
1246 return groups;
1247}
1248
1250 void *lf_p,
1251 int layer_n,
1252 void *data_tmp)
1253{
1254 LoopGroupCD *lf = static_cast<LoopGroupCD *>(lf_p);
1255 const int type = bm->ldata.layers[layer_n].type;
1256 int i;
1257 const float *data_weights;
1258
1259 data_weights = lf->data_weights;
1260
1262 &bm->ldata, (const void **)lf->data, data_weights, lf->data_len, data_tmp, layer_n);
1263
1264 for (i = 0; i < lf->data_len; i++) {
1265 CustomData_copy_elements(eCustomDataType(type), data_tmp, lf->data[i], 1);
1266 }
1267}
1268
1270 BMesh *bm, void *lf_p, const int layer_n, void *data_tmp, const float *loop_weights)
1271{
1272 LoopGroupCD *lf = static_cast<LoopGroupCD *>(lf_p);
1273 const int type = bm->ldata.layers[layer_n].type;
1274 int i;
1275 const float *data_weights;
1276
1277 /* re-weight */
1279 float *temp_weights = temp_weights_buf.data();
1280 float weight_accum = 0.0f;
1281
1282 for (i = 0; i < lf->data_len; i++) {
1283 float w = loop_weights[lf->data_index[i]] * lf->data_weights[i];
1284 temp_weights[i] = w;
1285 weight_accum += w;
1286 }
1287
1288 if (weight_accum != 0.0f) [[likely]] {
1289 mul_vn_fl(temp_weights, lf->data_len, 1.0f / weight_accum);
1290 data_weights = temp_weights;
1291 }
1292 else {
1293 data_weights = lf->data_weights;
1294 }
1295
1297 &bm->ldata, (const void **)lf->data, data_weights, lf->data_len, data_tmp, layer_n);
1298
1299 for (i = 0; i < lf->data_len; i++) {
1300 CustomData_copy_elements(eCustomDataType(type), data_tmp, lf->data[i], 1);
1301 }
1302}
1303
1304void BM_vert_loop_groups_data_layer_merge(BMesh *bm, LinkNode *groups, const int layer_n)
1305{
1306 const int type = bm->ldata.layers[layer_n].type;
1307 const int size = CustomData_sizeof(eCustomDataType(type));
1308 void *data_tmp = alloca(size);
1309
1310 do {
1311 bm_vert_loop_groups_data_layer_merge__single(bm, groups->link, layer_n, data_tmp);
1312 } while ((groups = groups->next));
1313}
1314
1316 LinkNode *groups,
1317 const int layer_n,
1318 const float *loop_weights)
1319{
1320 const int type = bm->ldata.layers[layer_n].type;
1321 const int size = CustomData_sizeof(eCustomDataType(type));
1322 void *data_tmp = alloca(size);
1323
1324 do {
1326 bm, groups->link, layer_n, data_tmp, loop_weights);
1327 } while ((groups = groups->next));
1328}
1329
1331
1332} // namespace blender
Generic geometry attributes built on CustomData.
CustomData interface, see also DNA_customdata_types.h.
Read Blender memory allocation and freeing.
#define UNUSED_FUNCTION(x)
#define UNUSED_VARS_NDEBUG(...)
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_elem_index_get(ele)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_index_set(ele, index)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define MAX_CUSTOMDATA_LAYER_NAME
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
const T * data() const
Definition BLI_array.hh:323
constexpr Span()=default
#define FLT_EPSILON
#define layer
std::optional< AttrType > custom_data_type_to_attr_type(eCustomDataType data_type)
BMesh Iterators.
void resolve_quad_uv_v2(float r_uv[2], const float st[2], const float st0[2], const float st1[2], const float st2[2], const float st3[2])
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
bool BM_data_layer_free_named(BMesh *bm, CustomData *data, StringRef name)
void BM_face_calc_center_median(const BMFace *f, float r_cent[3])
int CustomData_get_offset(const CustomData *data, eCustomDataType type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void mul_vn_fl(float *array_tar, int size, float f)
void BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n)
bool BM_uv_map_attr_pin_exists(const BMesh *bm, const StringRef uv_map_name)
void BM_elem_float_data_set(CustomData *cd, void *element, int type, const float val)
void BM_data_layer_add(BMesh *bm, CustomData *data, int type)
void BM_vert_loop_groups_data_layer_merge(BMesh *bm, LinkNode *groups, const int layer_n)
void * CustomData_bmesh_get(const CustomData *data, void *block, eCustomDataType type)
static void bm_data_interp_from_elem(CustomData *data_layer, const BMElem *ele_src_1, const BMElem *ele_src_2, BMElem *ele_dst, const float fac)
void CustomData_bmesh_set_n(CustomData *data, void *block, eCustomDataType type, int n, const void *source)
bool CustomData_free_layer_active(CustomData *data, eCustomDataType type)
int CustomData_number_of_layers(const CustomData *data, eCustomDataType type)
void CustomData_copy_elements(eCustomDataType type, const void *src_data, void *dst_data, int count)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
void mid_v3_v3v3v3v3(float v[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
static bool quad_co(const float v1[3], const float v2[3], const float v3[3], const float v4[3], const float p[3], const float n[3], float r_uv[2])
MINLINE void copy_v3_v3(float r[3], const float a[3])
ATTR_WARN_UNUSED_RESULT const BMLoop * l
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
void BM_vert_loop_groups_data_layer_merge_weights(BMesh *bm, LinkNode *groups, const int layer_n, const float *loop_weights)
MINLINE void mul_v2_fl(float r[2], float f)
MINLINE float cross_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
static void bm_loop_flip_disp(const float source_axis_x[3], const float source_axis_y[3], const float target_axis_x[3], const float target_axis_y[3], float disp[3])
BMCustomDataCopyMap CustomData_bmesh_copy_map_calc(const CustomData &src, const CustomData &dst, eCustomDataMask mask_exclude=0)
void CustomData_bmesh_interp(CustomData *data, const void **src_blocks, const float *weights, int count, void *dst_block)
void mul_v2_m3v3(float r[2], const float M[3][3], const float a[3])
void BLI_linklist_prepend_arena(LinkNode **listp, void *ptr, struct MemArena *ma) ATTR_NONNULL(1
static void loop_interp_multires_cb(void *__restrict userdata, const int ix, const TaskParallelTLS *__restrict)
bool CustomData_data_equals(eCustomDataType type, const void *data1, const void *data2)
void BLI_task_parallel_range(int start, int stop, void *userdata, TaskParallelRangeFunc func, const TaskParallelSettings *settings)
int CustomData_sizeof(eCustomDataType type)
bool CustomData_free_layer_named(CustomData *data, StringRef name)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void CustomData_bmesh_copy_block(CustomData &data, void *src_block, void **dst_block)
void BM_data_layer_free(BMesh *bm, CustomData *data, int type)
void BM_data_interp_from_edges(BMesh *bm, const BMEdge *e_src_1, const BMEdge *e_src_2, BMEdge *e_dst, const float fac)
Data, Interpolate From Edges.
MINLINE void mul_v3_fl(float r[3], float f)
float BM_elem_float_data_get(CustomData *cd, void *element, int type)
void project_v3_v3v3(float out[3], const float p[3], const float v_proj[3])
MINLINE void sub_v3_v3(float r[3], const float a[3])
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
void BLI_mempool_destroy(BLI_mempool *pool) ATTR_NONNULL(1)
void CustomData_bmesh_free_block(CustomData *data, void **block)
void old_mdisps_bilinear(float out[3], float(*disps)[3], int st, float u, float v)
Definition multires.cc:569
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
void CustomData_bmesh_interp_n(CustomData *data, const void **src_blocks, const float *weights, int count, void *dst_block_ofs, int n)
static void bm_loop_walk_add(LoopWalkCtx *lwc, BMLoop *l)
BMesh const char void * data
float normal_quad_v3(float n[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
Definition math_geom.cc:62
void * CustomData_add_layer_named(CustomData *data, eCustomDataType type, eCDAllocType alloctype, int totelem, StringRef name)
void BM_vert_normal_update_all(BMVert *v)
static void UNUSED_FUNCTION BM_Data_Vert_Average(BMesh *, BMFace *)
Data Vert Average.
sqrt(x)+1/max(0
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
bool CustomData_free_layer(CustomData *data, eCustomDataType type, int index)
BMDataLayerLookup BM_data_layer_lookup(const BMesh &bm, const StringRef name)
int isect_point_quad_v2(const float p[2], const float v1[2], const float v2[2], const float v3[2], const float v4[2])
static void bm_vert_loop_groups_data_layer_merge_weights__single(BMesh *bm, void *lf_p, const int layer_n, void *data_tmp, const float *loop_weights)
void interp_weights_poly_v2(float w[], float v[][2], int n, const float co[2])
static void update_data_blocks(BMesh *bm, CustomData *olddata, CustomData *data)
void BM_uv_map_attr_pin_ensure_named(BMesh *bm, const StringRef uv_map_name)
int CustomData_get_named_layer_index(const CustomData *data, eCustomDataType type, StringRef name)
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
void BM_face_interp_multires(BMesh *bm, BMFace *f_dst, const BMFace *f_src)
void * BLI_memarena_alloc(MemArena *ma, size_t size) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_ALLOC_SIZE(2)
MINLINE float normalize_v3(float n[3])
MINLINE void add_v3_v3(float r[3], const float a[3])
void BM_face_interp_from_face(BMesh *bm, BMFace *f_dst, const BMFace *f_src, const bool do_vertex)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
int CustomData_get_layer_index_n(const CustomData *data, eCustomDataType type, int n)
void BM_data_layer_ensure_named(BMesh *bm, CustomData *data, int type, const StringRef name)
void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f)
void BM_vert_interp_from_face(BMesh *bm, BMVert *v_dst, const BMFace *f_src)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
static void bm_vert_loop_groups_data_layer_merge__single(BMesh *bm, void *lf_p, int layer_n, void *data_tmp)
const char * CustomData_get_layer_name(const CustomData *data, eCustomDataType type, int n)
void BM_data_layer_copy(BMesh *bm, CustomData *data, int type, int src_n, int dst_n)
void CustomData_bmesh_init_pool(CustomData *data, int totelem, char htype)
void BM_data_layer_add_named(BMesh *bm, CustomData *data, int type, const StringRef name)
void BM_data_interp_from_verts(BMesh *bm, const BMVert *v_src_1, const BMVert *v_src_2, BMVert *v_dst, const float fac)
Data, Interpolate From Verts.
MINLINE void sub_v2_v2(float r[2], const float a[2])
void BM_face_interp_from_face_ex(BMesh *bm, BMFace *f_dst, const BMFace *f_src, const bool do_vertex, const void **blocks_l, const void **blocks_v, float(*cos_2d)[2], float axis_mat[3][3])
Data Interpolate From Face.
static int compute_mdisp_quad(const BMLoop *l, const float l_f_center[3], float v1[3], float v2[3], float v3[3], float v4[3], float e1[3], float e2[3])
Multires Interpolation.
static float bm_loop_flip_equotion(float mat[2][2], float b[2], const float target_axis_x[3], const float target_axis_y[3], const float coord[3], int i, int j)
void BM_loop_interp_multires_ex(BMesh *, BMLoop *l_dst, const BMFace *f_src, const float f_dst_center[3], const float f_src_center[3], const int cd_loop_mdisp_offset)
void BM_uv_map_attr_pin_ensure_for_all_layers(BMesh *bm)
void BM_face_interp_multires_ex(BMesh *bm, BMFace *f_dst, const BMFace *f_src, const float f_dst_center[3], const float f_src_center[3], const int cd_loop_mdisp_offset)
ATTR_WARN_UNUSED_RESULT const void * element
bool BM_face_is_normal_valid(const BMFace *f)
void BM_loop_interp_multires(BMesh *bm, BMLoop *l_dst, const BMFace *f_src)
void poly_rotate_plane(const float normal[3], float(*verts)[3], const uint nverts)
POLY ROTATE PLANE.
StringRef BKE_uv_map_pin_name_get(StringRef uv_map_name, char *buffer)
static bool mdisp_in_mdispquad(BMLoop *l_src, BMLoop *l_dst, const float l_dst_f_center[3], const float p[3], int res, float r_axis_x[3], float r_axis_y[3], float r_uv[2])
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
@ BM_ELEM_INTERNAL_TAG
static void mdisp_axis_from_quad(const float v1[3], const float v2[3], float[3], const float v4[3], float r_axis_x[3], float r_axis_y[3])
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
static void bm_loop_walk_data(LoopWalkCtx *lwc, BMLoop *l_walk)
void BM_data_interp_face_vert_edge(BMesh *bm, const BMVert *v_src_1, const BMVert *, BMVert *v, BMEdge *e, const float fac)
Data Face-Vert Edge Interpolate.
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void BM_loop_interp_from_face(BMesh *bm, BMLoop *l_dst, const BMFace *f_src, const bool do_vertex, const bool do_multires)
void axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3])
Normal to x,y matrix.
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
LinkNode * BM_vert_loop_groups_data_layer_create(BMesh *bm, BMVert *v, const int layer_n, const float *loop_weights, MemArena *arena)
void * CustomData_add_layer(CustomData *data, eCustomDataType type, eCDAllocType alloctype, int totelem)
void * CustomData_bmesh_get_n(const CustomData *data, void *block, eCustomDataType type, int n)
const btScalar eps
Definition poly34.cpp:11
#define fabsf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct BMLoop * next
struct BMLoop * prev
struct BMVert * v
struct BMLoop * radial_next
struct BMFace * f
struct BLI_mempool * pool
struct LinkNode * next
const float * loop_weights
struct BMLoop * radial_next