Blender V5.3
editmesh_bvh.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2010 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "MEM_guardedalloc.h"
10
11#include "BLI_kdopbvh.hh"
12#include "BLI_math_geom_c.hh"
13#include "BLI_math_vector_c.hh"
14
15#include "BKE_editmesh.hh"
16
17#include "BKE_editmesh_bvh.hh" /* own include */
18
19namespace blender {
20
21struct BMBVHTree {
22 BVHTree *tree = nullptr;
23
25
26 BMesh *bm = nullptr;
27
28 const float3 *cos_cage = nullptr;
29 bool cos_cage_free = false;
30
31 int flag = 0;
32};
33
35 BMEditMesh *em, BMesh *bm, int flag, const float3 *cos_cage, const bool cos_cage_free)
36{
37 return BKE_bmbvh_new(bm, em->looptris, flag, cos_cage, cos_cage_free);
38}
39
41 const Span<std::array<BMLoop *, 3>> looptris,
42 int flag,
43 const float3 *cos_cage,
44 const bool cos_cage_free,
45 bool (*test_fn)(BMFace *, void *user_data),
46 void *user_data)
47{
48 /* could become argument */
49 const float epsilon = FLT_EPSILON * 2.0f;
50
51 BMBVHTree *bmtree = MEM_new<BMBVHTree>("BMBVHTree");
52 float cos[3][3];
53 int tottri;
54
55 /* avoid testing every tri */
56 BMFace *f_test, *f_test_prev;
57 bool test_fn_ret;
58
59 /* BKE_editmesh_looptris_calc() must be called already */
60 BLI_assert(looptris.size() != 0 || bm->totface == 0);
61
62 if (cos_cage) {
64 }
65
66 bmtree->looptris = looptris;
67 bmtree->bm = bm;
68 bmtree->cos_cage = cos_cage;
69 bmtree->cos_cage_free = cos_cage_free;
70 bmtree->flag = flag;
71
72 if (test_fn) {
73 /* callback must do... */
75
76 f_test_prev = nullptr;
77 test_fn_ret = false;
78
79 tottri = 0;
80 for (const int i : looptris.index_range()) {
81 f_test = looptris[i][0]->f;
82 if (f_test != f_test_prev) {
83 test_fn_ret = test_fn(f_test, user_data);
84 f_test_prev = f_test;
85 }
86
87 if (test_fn_ret) {
88 tottri++;
89 }
90 }
91 }
92 else {
93 tottri = looptris.size();
94 }
95
96 bmtree->tree = BLI_bvhtree_new(tottri, epsilon, 8, 8);
97
98 f_test_prev = nullptr;
99 test_fn_ret = false;
100
101 for (const int i : looptris.index_range()) {
102 if (test_fn) {
103 /* NOTE: the arrays won't align now! Take care. */
104 f_test = looptris[i][0]->f;
105 if (f_test != f_test_prev) {
106 test_fn_ret = test_fn(f_test, user_data);
107 f_test_prev = f_test;
108 }
109
110 if (!test_fn_ret) {
111 continue;
112 }
113 }
114
115 if (cos_cage) {
116 copy_v3_v3(cos[0], cos_cage[BM_elem_index_get(looptris[i][0]->v)]);
117 copy_v3_v3(cos[1], cos_cage[BM_elem_index_get(looptris[i][1]->v)]);
118 copy_v3_v3(cos[2], cos_cage[BM_elem_index_get(looptris[i][2]->v)]);
119 }
120 else {
121 copy_v3_v3(cos[0], looptris[i][0]->v->co);
122 copy_v3_v3(cos[1], looptris[i][1]->v->co);
123 copy_v3_v3(cos[2], looptris[i][2]->v->co);
124 }
125
126 BLI_bvhtree_insert(bmtree->tree, i, reinterpret_cast<float *>(cos), 3);
127 }
128
129 BLI_bvhtree_balance(bmtree->tree);
130
131 return bmtree;
132}
133
134static bool bm_face_is_select(BMFace *f, void * /*user_data*/)
135{
136 return (BM_elem_flag_test(f, BM_ELEM_SELECT) != 0);
137}
138
139static bool bm_face_is_not_hidden(BMFace *f, void * /*user_data*/)
140{
141 return (BM_elem_flag_test(f, BM_ELEM_HIDDEN) == 0);
142}
143
145 const Span<std::array<BMLoop *, 3>> looptris,
146 int flag,
147 const float3 *cos_cage,
148 const bool cos_cage_free)
149{
150 bool (*test_fn)(BMFace *, void *user_data);
151
152 if (flag & BMBVH_RESPECT_SELECT) {
153 test_fn = bm_face_is_select;
154 }
155 else if (flag & BMBVH_RESPECT_HIDDEN) {
156 test_fn = bm_face_is_not_hidden;
157 }
158 else {
159 test_fn = nullptr;
160 }
161
163
164 return BKE_bmbvh_new_ex(bm, looptris, flag, cos_cage, cos_cage_free, test_fn, nullptr);
165}
166
168{
169 BLI_bvhtree_free(bmtree->tree);
170
171 if (bmtree->cos_cage && bmtree->cos_cage_free) {
172 MEM_delete(bmtree->cos_cage);
173 }
174
175 MEM_delete(bmtree);
176}
177
179{
180 return bmtree->tree;
181}
182
183/* -------------------------------------------------------------------- */
184/* Utility BMesh cast/intersect functions */
185
189static void bmbvh_tri_from_face(const float *cos[3],
190 const std::array<BMLoop *, 3> &ltri,
191 const float3 *cos_cage)
192{
193 if (cos_cage == nullptr) {
194 cos[0] = ltri[0]->v->co;
195 cos[1] = ltri[1]->v->co;
196 cos[2] = ltri[2]->v->co;
197 }
198 else {
199 cos[0] = cos_cage[BM_elem_index_get(ltri[0]->v)];
200 cos[1] = cos_cage[BM_elem_index_get(ltri[1]->v)];
201 cos[2] = cos_cage[BM_elem_index_get(ltri[2]->v)];
202 }
203}
204
205/* Taken from `bvhutils.cc`. */
206
207/* -------------------------------------------------------------------- */
208/* BKE_bmbvh_ray_cast */
209
211 /* from the bmtree */
214
215 /* from the hit */
216 float uv[2];
217};
218
220 RayCastUserData *bmcb_data,
221 const BVHTreeRayHit *hit,
222 float *r_dist,
223 float r_hitout[3],
224 float r_cagehit[3])
225{
226 if (r_hitout) {
227 if (bmtree->flag & BMBVH_RETURN_ORIG) {
228 const std::array<BMLoop *, 3> &ltri = bmtree->looptris[hit->index];
229 interp_v3_v3v3v3_uv(r_hitout, ltri[0]->v->co, ltri[1]->v->co, ltri[2]->v->co, bmcb_data->uv);
230 }
231 else {
232 copy_v3_v3(r_hitout, hit->co);
233 }
234
235 if (r_cagehit) {
236 copy_v3_v3(r_cagehit, hit->co);
237 }
238 }
239
240 if (r_dist) {
241 *r_dist = hit->dist;
242 }
243
244 return bmtree->looptris[hit->index][0]->f;
245}
246
247static void bmbvh_ray_cast_cb(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
248{
249 RayCastUserData *bmcb_data = static_cast<RayCastUserData *>(userdata);
250 const std::array<BMLoop *, 3> &ltri = bmcb_data->looptris[index];
251 float dist, uv[2];
252 const float *tri_cos[3];
253 bool isect;
254
255 bmbvh_tri_from_face(tri_cos, ltri, bmcb_data->cos_cage);
256
257 isect =
258 (ray->radius > 0.0f ?
260 ray->direction,
261 tri_cos[0],
262 tri_cos[1],
263 tri_cos[2],
264 &dist,
265 uv,
266 ray->radius) :
267#ifdef USE_KDOPBVH_WATERTIGHT
269 ray->origin, ray->isect_precalc, tri_cos[0], tri_cos[1], tri_cos[2], &dist, uv));
270#else
272 ray->origin, ray->direction, tri_cos[0], tri_cos[1], tri_cos[2], &dist, uv));
273#endif
274
275 if (isect && dist < hit->dist) {
276 hit->dist = dist;
277 hit->index = index;
278
279 copy_v3_v3(hit->no, ltri[0]->f->no);
280
281 madd_v3_v3v3fl(hit->co, ray->origin, ray->direction, dist);
282
283 copy_v2_v2(bmcb_data->uv, uv);
284 }
285}
286
288 const float co[3],
289 const float dir[3],
290 const float radius,
291 float *r_dist,
292 float r_hitout[3],
293 float r_cagehit[3])
294{
295 BVHTreeRayHit hit;
296 RayCastUserData bmcb_data;
297 const float dist = r_dist ? *r_dist : FLT_MAX;
298
299 if (bmtree->cos_cage) {
300 BLI_assert(!(bmtree->bm->elem_index_dirty & BM_VERT));
301 }
302
303 hit.dist = dist;
304 hit.index = -1;
305
306 /* ok to leave 'uv' uninitialized */
307 bmcb_data.looptris = bmtree->looptris;
308 bmcb_data.cos_cage = bmtree->cos_cage;
309
310 BLI_bvhtree_ray_cast(bmtree->tree, co, dir, radius, &hit, bmbvh_ray_cast_cb, &bmcb_data);
311
312 if (hit.index != -1 && hit.dist != dist) {
313 return bmbvh_ray_cast_handle_hit(bmtree, &bmcb_data, &hit, r_dist, r_hitout, r_cagehit);
314 }
315
316 return nullptr;
317}
318
319/* -------------------------------------------------------------------- */
320/* bmbvh_ray_cast_cb_filter */
321
322/* Same as BKE_bmbvh_ray_cast but takes a callback to filter out faces.
323 */
324
331
332static void bmbvh_ray_cast_cb_filter(void *userdata,
333 int index,
334 const BVHTreeRay *ray,
335 BVHTreeRayHit *hit)
336{
337 RayCastUserData_Filter *bmcb_data_filter = static_cast<RayCastUserData_Filter *>(userdata);
338 RayCastUserData *bmcb_data = &bmcb_data_filter->bmcb_data;
339 const std::array<BMLoop *, 3> &ltri = bmcb_data->looptris[index];
340 if (bmcb_data_filter->filter_cb(ltri[0]->f, bmcb_data_filter->filter_userdata)) {
341 bmbvh_ray_cast_cb(bmcb_data, index, ray, hit);
342 }
343}
344
346 const float co[3],
347 const float dir[3],
348 const float radius,
349 float *r_dist,
350 float r_hitout[3],
351 float r_cagehit[3],
352 BMBVHTree_FaceFilter filter_cb,
353 void *filter_userdata)
354{
355 BVHTreeRayHit hit;
356 RayCastUserData_Filter bmcb_data_filter;
357 RayCastUserData *bmcb_data = &bmcb_data_filter.bmcb_data;
358
359 const float dist = r_dist ? *r_dist : FLT_MAX;
360
361 bmcb_data_filter.filter_cb = filter_cb;
362 bmcb_data_filter.filter_userdata = filter_userdata;
363
364 if (bmtree->cos_cage) {
365 BLI_assert(!(bmtree->bm->elem_index_dirty & BM_VERT));
366 }
367
368 hit.dist = dist;
369 hit.index = -1;
370
371 /* ok to leave 'uv' uninitialized */
372 bmcb_data->looptris = bmtree->looptris;
373 bmcb_data->cos_cage = bmtree->cos_cage;
374
376 bmtree->tree, co, dir, radius, &hit, bmbvh_ray_cast_cb_filter, &bmcb_data_filter);
377 if (hit.index != -1 && hit.dist != dist) {
378 return bmbvh_ray_cast_handle_hit(bmtree, bmcb_data, &hit, r_dist, r_hitout, r_cagehit);
379 }
380
381 return nullptr;
382}
383
384/* -------------------------------------------------------------------- */
385/* BKE_bmbvh_find_vert_closest */
386
388 /* from the bmtree */
391
392 /* from the hit */
395};
396
397static void bmbvh_find_vert_closest_cb(void *userdata,
398 int index,
399 const float co[3],
400 BVHTreeNearest *hit)
401{
402 VertSearchUserData *bmcb_data = static_cast<VertSearchUserData *>(userdata);
403 const std::array<BMLoop *, 3> &ltri = bmcb_data->looptris[index];
404 const float dist_max_sq = bmcb_data->dist_max_sq;
405
406 const float *tri_cos[3];
407 bmbvh_tri_from_face(tri_cos, ltri, bmcb_data->cos_cage);
408
409 for (int i = 0; i < 3; i++) {
410 const float dist_sq = len_squared_v3v3(co, tri_cos[i]);
411 if (dist_sq < hit->dist_sq && dist_sq < dist_max_sq) {
412 copy_v3_v3(hit->co, tri_cos[i]);
413 /* XXX, normal ignores cage */
414 copy_v3_v3(hit->no, ltri[i]->v->no);
415 hit->dist_sq = dist_sq;
416 hit->index = index;
417 bmcb_data->index_tri = i;
418 }
419 }
420}
421
423 const float co[3],
424 const float dist_max)
425{
426 BVHTreeNearest hit;
427 VertSearchUserData bmcb_data;
428 const float dist_max_sq = dist_max * dist_max;
429
430 if (bmtree->cos_cage) {
431 BLI_assert(!(bmtree->bm->elem_index_dirty & BM_VERT));
432 }
433
434 hit.dist_sq = dist_max_sq;
435 hit.index = -1;
436
437 bmcb_data.looptris = bmtree->looptris;
438 bmcb_data.cos_cage = bmtree->cos_cage;
439 bmcb_data.dist_max_sq = dist_max_sq;
440
441 BLI_bvhtree_find_nearest(bmtree->tree, co, &hit, bmbvh_find_vert_closest_cb, &bmcb_data);
442 if (hit.index != -1) {
443 const std::array<BMLoop *, 3> &ltri = bmtree->looptris[hit.index];
444 return ltri[bmcb_data.index_tri]->v;
445 }
446
447 return nullptr;
448}
449
451 /* from the bmtree */
454
455 /* from the hit */
457};
458
459static void bmbvh_find_face_closest_cb(void *userdata,
460 int index,
461 const float co[3],
462 BVHTreeNearest *hit)
463{
464 FaceSearchUserData *bmcb_data = static_cast<FaceSearchUserData *>(userdata);
465 const std::array<BMLoop *, 3> &ltri = bmcb_data->looptris[index];
466 const float dist_max_sq = bmcb_data->dist_max_sq;
467
468 const float *tri_cos[3];
469
470 bmbvh_tri_from_face(tri_cos, ltri, bmcb_data->cos_cage);
471
472 float co_close[3];
473 closest_on_tri_to_point_v3(co_close, co, UNPACK3(tri_cos));
474 const float dist_sq = len_squared_v3v3(co, co_close);
475 if (dist_sq < hit->dist_sq && dist_sq < dist_max_sq) {
476 /* XXX, normal ignores cage */
477 copy_v3_v3(hit->no, ltri[0]->f->no);
478 hit->dist_sq = dist_sq;
479 hit->index = index;
480 }
481}
482
484 const float co[3],
485 const float dist_max)
486{
487 BVHTreeNearest hit;
488 FaceSearchUserData bmcb_data;
489 const float dist_max_sq = dist_max * dist_max;
490
491 if (bmtree->cos_cage) {
492 BLI_assert(!(bmtree->bm->elem_index_dirty & BM_VERT));
493 }
494
495 hit.dist_sq = dist_max_sq;
496 hit.index = -1;
497
498 bmcb_data.looptris = bmtree->looptris;
499 bmcb_data.cos_cage = bmtree->cos_cage;
500 bmcb_data.dist_max_sq = dist_max_sq;
501
502 BLI_bvhtree_find_nearest(bmtree->tree, co, &hit, bmbvh_find_face_closest_cb, &bmcb_data);
503 if (hit.index != -1) {
504 const std::array<BMLoop *, 3> &ltri = bmtree->looptris[hit.index];
505 return ltri[0]->f;
506 }
507
508 return nullptr;
509}
510
511/* -------------------------------------------------------------------- */
512/* BKE_bmbvh_overlap */
513
518
519static bool bmbvh_overlap_cb(void *userdata, int index_a, int index_b, int /*thread*/)
520{
521 BMBVHTree_OverlapData *data = static_cast<BMBVHTree_OverlapData *>(userdata);
522 const BMBVHTree *bmtree_a = data->tree_pair[0];
523 const BMBVHTree *bmtree_b = data->tree_pair[1];
524
525 const std::array<BMLoop *, 3> &ltri_a = bmtree_a->looptris[index_a];
526 const std::array<BMLoop *, 3> &ltri_b = bmtree_b->looptris[index_b];
527 const float *tri_a_co[3] = {ltri_a[0]->v->co, ltri_a[1]->v->co, ltri_a[2]->v->co};
528 const float *tri_b_co[3] = {ltri_b[0]->v->co, ltri_b[1]->v->co, ltri_b[2]->v->co};
529 float ix_pair[2][3];
530 int verts_shared = 0;
531
532 if (bmtree_a->looptris == bmtree_b->looptris) {
533 if (ltri_a[0]->f == ltri_b[0]->f) [[unlikely]] {
534 return false;
535 }
536
537 verts_shared = (ELEM(tri_a_co[0], UNPACK3(tri_b_co)) + ELEM(tri_a_co[1], UNPACK3(tri_b_co)) +
538 ELEM(tri_a_co[2], UNPACK3(tri_b_co)));
539
540 /* if 2 points are shared, bail out */
541 if (verts_shared >= 2) {
542 return false;
543 }
544 }
545
546 return (isect_tri_tri_v3(UNPACK3(tri_a_co), UNPACK3(tri_b_co), ix_pair[0], ix_pair[1]) &&
547 /* if we share a vertex, check the intersection isn't a 'point' */
548 ((verts_shared == 0) || (len_squared_v3v3(ix_pair[0], ix_pair[1]) > data->epsilon)));
549}
550
552 const BMBVHTree *bmtree_b,
553 uint *r_overlap_tot)
554{
556
557 data.tree_pair[0] = bmtree_a;
558 data.tree_pair[1] = bmtree_b;
559 data.epsilon = max_ff(BLI_bvhtree_get_epsilon(bmtree_a->tree),
560 BLI_bvhtree_get_epsilon(bmtree_b->tree));
561
562 return BLI_bvhtree_overlap(
563 bmtree_a->tree, bmtree_b->tree, r_overlap_tot, bmbvh_overlap_cb, &data);
564}
565
566static bool bmbvh_overlap_self_cb(void *userdata, int index_a, int index_b, int thread)
567{
568 if (index_a < index_b) {
569 return bmbvh_overlap_cb(userdata, index_a, index_b, thread);
570 }
571 return false;
572}
573
575{
577
578 data.tree_pair[0] = bmtree;
579 data.tree_pair[1] = bmtree;
580 data.epsilon = BLI_bvhtree_get_epsilon(bmtree->tree);
581
582 return BLI_bvhtree_overlap(
583 bmtree->tree, bmtree->tree, r_overlap_tot, bmbvh_overlap_self_cb, &data);
584}
585
586} // namespace blender
Read Blender memory allocation and freeing.
#define UNPACK3(a)
#define ELEM(...)
#define BM_elem_index_get(ele)
#define BM_elem_flag_test(ele, hflag)
#define FLT_MAX
#define FLT_EPSILON
#define cos
BMesh Iterators.
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
static void bmbvh_ray_cast_cb(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void BKE_bmbvh_free(BMBVHTree *tree)
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
BMBVHTree * BKE_bmbvh_new_ex(struct BMesh *bm, Span< std::array< BMLoop *, 3 > > looptris, int flag, const float3 *cos_cage, bool cos_cage_free, bool(*test_fn)(struct BMFace *, void *user_data), void *user_data)
bool isect_tri_tri_v3(const float t_a0[3], const float t_a1[3], const float t_a2[3], const float t_b0[3], const float t_b1[3], const float t_b2[3], float r_i1[3], float r_i2[3])
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
int BLI_bvhtree_find_nearest(const BVHTree *tree, const float co[3], BVHTreeNearest *nearest, BVHTree_NearestPointCallback callback, void *userdata)
struct BMFace * BKE_bmbvh_find_face_closest(const BMBVHTree *tree, const float co[3], float dist_max)
BVHTreeOverlap * BLI_bvhtree_overlap(const BVHTree *tree1, const BVHTree *tree2, unsigned int *r_overlap_num, BVHTree_OverlapCallback callback, void *userdata)
static bool bmbvh_overlap_self_cb(void *userdata, int index_a, int index_b, int thread)
float BLI_bvhtree_get_epsilon(const BVHTree *tree)
bool isect_ray_tri_watertight_v3(const float ray_origin[3], const struct IsectRayPrecalc *isect_precalc, const float v0[3], const float v1[3], const float v2[3], float *r_lambda, float r_uv[2])
struct BMFace * BKE_bmbvh_ray_cast(const BMBVHTree *tree, const float co[3], const float dir[3], float radius, float *r_dist, float r_hitout[3], float r_cagehit[3])
MINLINE void copy_v2_v2(float r[2], const float a[2])
void BLI_bvhtree_free(BVHTree *tree)
void BLI_bvhtree_balance(BVHTree *tree)
ATTR_WARN_UNUSED_RESULT const BMVert * v
struct BVHTree * BKE_bmbvh_tree_get(BMBVHTree *tree)
int BLI_bvhtree_ray_cast(const BVHTree *tree, const float co[3], const float dir[3], float radius, BVHTreeRayHit *hit, BVHTree_RayCastCallback callback, void *userdata)
static void bmbvh_find_vert_closest_cb(void *userdata, int index, const float co[3], BVHTreeNearest *hit)
BMBVHTree * BKE_bmbvh_new(struct BMesh *bm, Span< std::array< BMLoop *, 3 > > looptris, int flag, const float3 *cos_cage, bool cos_cage_free)
struct BMVert * BKE_bmbvh_find_vert_closest(const BMBVHTree *tree, const float co[3], float dist_max)
static bool bm_face_is_not_hidden(BMFace *f, void *)
struct BVHTreeOverlap * BKE_bmbvh_overlap(const BMBVHTree *bmtree_a, const BMBVHTree *bmtree_b, unsigned int *r_overlap_tot)
void interp_v3_v3v3v3_uv(float p[3], const float v1[3], const float v2[3], const float v3[3], const float uv[2])
BMesh const char void * data
BMBVHTree * BKE_bmbvh_new_from_editmesh(struct BMEditMesh *em, struct BMesh *bm, int flag, const float3 *cos_cage, bool cos_cage_free)
static bool bmbvh_overlap_cb(void *userdata, int index_a, int index_b, int)
BVHTree * BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis)
static BMFace * bmbvh_ray_cast_handle_hit(const BMBVHTree *bmtree, RayCastUserData *bmcb_data, const BVHTreeRayHit *hit, float *r_dist, float r_hitout[3], float r_cagehit[3])
bool isect_ray_tri_v3(const float ray_origin[3], const float ray_direction[3], const float v0[3], const float v1[3], const float v2[3], float *r_lambda, float r_uv[2])
static void bmbvh_tri_from_face(const float *cos[3], const std::array< BMLoop *, 3 > &ltri, const float3 *cos_cage)
static void bmbvh_find_face_closest_cb(void *userdata, int index, const float co[3], BVHTreeNearest *hit)
MINLINE float max_ff(float a, float b)
void closest_on_tri_to_point_v3(float r[3], const float p[3], const float v1[3], const float v2[3], const float v3[3])
void BLI_bvhtree_insert(BVHTree *tree, int index, const float co[3], int numpoints)
bool isect_ray_tri_epsilon_v3(const float ray_origin[3], const float ray_direction[3], const float v0[3], const float v1[3], const float v2[3], float *r_lambda, float r_uv[2], float epsilon)
struct BMFace * BKE_bmbvh_ray_cast_filter(const BMBVHTree *tree, const float co[3], const float dir[3], float radius, float *r_dist, float r_hitout[3], float r_cagehit[3], BMBVHTree_FaceFilter filter_cb, void *filter_userdata)
VecBase< float, 3 > float3
bool(*) BMBVHTree_FaceFilter(struct BMFace *f, void *userdata)
static void bmbvh_ray_cast_cb_filter(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit)
struct BVHTreeOverlap * BKE_bmbvh_overlap_self(const BMBVHTree *bmtree, unsigned int *r_overlap_tot)
static bool bm_face_is_select(BMFace *f, void *)
const BMBVHTree * tree_pair[2]
Span< std::array< BMLoop *, 3 > > looptris
const float3 * cos_cage
Array< std::array< BMLoop *, 3 > > looptris
struct IsectRayPrecalc * isect_precalc
Span< std::array< BMLoop *, 3 > > looptris
BMBVHTree_FaceFilter filter_cb
Span< std::array< BMLoop *, 3 > > looptris
Span< std::array< BMLoop *, 3 > > looptris