63 return automasking & mode;
100 brush->mesh_automasking_settings->flags;
106 flags |=
brush->mesh_automasking_settings->flags;
111 flags |=
paint.mesh_automasking_settings->flags;
116 return paint.mesh_automasking_settings->flags;
128 if (
angle > limit_lower &&
angle < limit_upper) {
129 float t = 1.0f - (
angle - limit_lower) / (limit_upper - limit_lower);
132 t = t * t * (3.0 - 2.0 * t);
136 if (
angle > limit_upper) {
168 return brush && (flag_is_set(
brush->mesh_automasking_settings->flags,
170 flag_is_set(
brush->mesh_automasking_settings->flags,
172 brush->mesh_automasking_settings->boundary_edges_propagation_steps :
173 paint.mesh_automasking_settings->boundary_edges_propagation_steps;
242 const float3 &vert_position)
258 factor = factor *
sign * 0.5f + 0.5f;
259 CLAMP(factor, 0.0f, 1.0f);
275 const Cache &automasking,
280 struct CavityBlurVert {
302 const int num_steps = steps + 1;
304 std::queue<CavityBlurVert> queue;
307 const CavityBlurVert initial{vert, 0};
311 const float3 starting_position = positions_eval[vert];
314 while (!queue.empty()) {
315 const CavityBlurVert blurvert = queue.front();
318 const int current_vert = blurvert.vertex;
320 const float3 &blur_vert_position = positions_eval[current_vert];
321 const float3 &blur_vert_normal = normals_eval[current_vert];
323 const float dist_to_start =
math::distance(blur_vert_position, starting_position);
325 all_verts.
position += blur_vert_position;
326 all_verts.
distance += dist_to_start;
329 if (blurvert.depth < num_steps) {
330 verts_in_range.
position += blur_vert_position;
331 verts_in_range.
normal += blur_vert_normal;
332 verts_in_range.
count++;
337 if (blurvert.depth >= num_steps) {
342 faces, corner_verts, vert_to_face_map, hide_poly, current_vert, neighbors))
344 if (visited_verts.
contains(neighbor)) {
348 visited_verts.
add_new(neighbor);
349 queue.push({neighbor, blurvert.depth + 1});
355 if (all_verts.
count == 0) {
356 all_verts.
position = positions_eval[vert];
363 if (verts_in_range.
count == 0) {
364 verts_in_range.
position = positions_eval[vert];
372 verts_in_range.
normal = normals_eval[vert];
381 const Cache &automasking,
386 struct CavityBlurVert {
402 const int num_steps = steps + 1;
404 std::queue<CavityBlurVert> queue;
407 const CavityBlurVert initial{vert.to_index(key), 0};
408 visited_verts.
add_new(initial.vert);
411 const float3 starting_position = positions[vert.to_index(key)];
414 while (!queue.empty()) {
415 const CavityBlurVert blurvert = queue.front();
418 const int current_vert = blurvert.vert;
420 const float3 &blur_vert_position = positions[current_vert];
421 const float3 &blur_vert_normal = normals[current_vert];
423 const float dist_to_start =
math::distance(blur_vert_position, starting_position);
425 all_verts.
position += blur_vert_position;
426 all_verts.
distance += dist_to_start;
429 if (blurvert.depth < num_steps) {
430 verts_in_range.
position += blur_vert_position;
431 verts_in_range.
normal += blur_vert_normal;
432 verts_in_range.
count++;
437 if (blurvert.depth >= num_steps) {
444 const int neighbor_idx = neighbor.
to_index(key);
445 if (visited_verts.
contains(neighbor_idx)) {
449 visited_verts.
add_new(neighbor_idx);
450 queue.push({neighbor_idx, blurvert.depth + 1});
456 if (all_verts.
count == 0) {
457 all_verts.
position = positions[vert.to_index(key)];
464 if (verts_in_range.
count == 0) {
465 verts_in_range.
position = positions[vert.to_index(key)];
473 verts_in_range.
normal = normals[vert.to_index(key)];
486 struct CavityBlurVert {
497 const int num_steps = steps + 1;
499 std::queue<CavityBlurVert> queue;
503 visited_verts.
add_new(initial.index);
506 const float3 starting_position = vert->co;
509 while (!queue.empty()) {
510 const CavityBlurVert blurvert = queue.front();
513 BMVert *current_vert = blurvert.vertex;
515 const float3 blur_vert_position = current_vert->
co;
516 const float3 blur_vert_normal = current_vert->
no;
518 const float dist_to_start =
math::distance(blur_vert_position, starting_position);
520 all_verts.
position += blur_vert_position;
521 all_verts.
distance += dist_to_start;
524 if (blurvert.depth < num_steps) {
525 verts_in_range.
position += blur_vert_position;
526 verts_in_range.
normal += blur_vert_normal;
527 verts_in_range.
count++;
532 if (blurvert.depth >= num_steps) {
538 if (visited_verts.
contains(neighbor_idx)) {
542 visited_verts.
add_new(neighbor_idx);
543 queue.push({neighbor, neighbor_idx, blurvert.depth + 1});
549 if (all_verts.
count == 0) {
557 if (verts_in_range.
count == 0) {
566 verts_in_range.
normal = vert->no;
581 factor =
inverted ? 1.0f - factor : factor;
583 factor =
inverted ? 1.0f - factor : factor;
590 const Cache &automasking,
605 const Cache &automasking,
630 const Cache &automasking,
653 orig_normals = orig_data->normals;
659 const int vert = verts[i];
660 const float3 &normal = orig_normals.is_empty() ? vert_normals[vert] : orig_normals[i];
674 float cached_factor = automasking.
factor[vert];
681 factors[i] *= cached_factor;
690 depsgraph,
const_cast<Cache &
>(automasking),
object, vert, vert_positions[vert]);
756 const Cache &automasking,
772 const Span<int> face_verts = corner_verts.
slice(faces[face_indices[i]]);
774 for (
const int vert : face_verts) {
790 float cached_factor = automasking.
factor[vert];
797 factor *= cached_factor;
806 depsgraph,
const_cast<Cache &
>(automasking),
object, vert, vert_positions[vert]);
872 const Cache &automasking,
879 const Mesh &base_mesh = *id_cast<const Mesh *>(
object.
data);
881 const Span<int> corner_verts = base_mesh.corner_verts();
895 orig_normals = orig_data->normals;
900 const int grid_face_set = face_sets.
is_empty() ?
902 face_sets[subdiv_ccg.grid_to_face_map[grids[i]]];
903 const int node_start = i * key.
grid_area;
904 const int grids_start = grids[i] * key.
grid_area;
906 const int node_vert = node_start + offset;
907 const int vert = grids_start + offset;
908 const float3 &normal = orig_normals.
is_empty() ? subdiv_ccg.normals[vert] :
909 orig_normals[node_vert];
923 float cached_factor = automasking.
factor[vert];
930 factors[node_vert] *= cached_factor;
939 depsgraph,
const_cast<Cache &
>(automasking),
object, vert, subdiv_ccg.positions[vert]);
941 factors[node_vert] = 0.0f;
954 factors[node_vert] = 0.0f;
960 factors[node_vert] = 0.0f;
973 factors[node_vert] = 0.0f;
991 factors[node_vert] = 0.0f;
1012 const Cache &automasking,
1031 for (
BMVert *vert : verts) {
1048 float cached_factor = automasking.
factor[vert_i];
1055 factors[i] *= cached_factor;
1064 depsgraph,
const_cast<Cache &
>(automasking),
object, vert_i, vert->co);
1137 const float radius = ss.
cache ? ss.
cache->
radius : std::numeric_limits<float>::max();
1138 const int active_vert = std::get<int>(ss.
active_vert());
1146 float3 location = vert_positions[active_vert];
1149 flood.
execute(ob, vert_to_face_map, [&](
int from_v,
int to_v) {
1150 factors[from_v] = 1.0f;
1151 factors[to_v] = 1.0f;
1156 flood.
execute(ob, vert_to_face_map, [&](
int from_v,
int to_v) {
1157 factors[from_v] = 1.0f;
1158 factors[to_v] = 1.0f;
1173 const float radius = ss.
cache ? ss.
cache->
radius : std::numeric_limits<float>::max();
1186 float3 location = positions[active_vert];
1191 factors[from_v.
to_index(key)] = 1.0f;
1192 factors[to_v.
to_index(key)] = 1.0f;
1194 positions[to_v.
to_index(key)], location, radius, symm);
1200 factors[from_v.
to_index(key)] = 1.0f;
1201 factors[to_v.
to_index(key)] = 1.0f;
1215 const float radius = ss.
cache ? ss.
cache->
radius : std::numeric_limits<float>::max();
1252 if (std::holds_alternative<std::monostate>(ss.
active_vert())) {
1294 for (const int vert : range) {
1295 if (!face_set::vert_has_face_set(vert_to_face_map, face_sets, vert, active_face_set)) {
1296 factors[vert] = 0.0f;
1303 const Mesh &base_mesh = *id_cast<const Mesh *>(ob.
data);
1313 const int grid_area = subdiv_ccg.
grid_area;
1315 for (const int face : range) {
1316 if (face_sets[face] != active_face_set) {
1317 factors.slice(bke::ccg::face_range(faces, grid_area, face)).fill(0.0f);
1329 if (face_set_offset == -1) {
1333 for (const int i : range) {
1334 const BMVert *vert = BM_vert_at_index(&const_cast<BMesh &>(bm), i);
1335 if (!face_set::vert_has_face_set(face_set_offset, *vert, active_face_set)) {
1353 const Depsgraph &depsgraph,
1355 const int propagation_steps,
1377 edge_distance[i] = 0;
1382 edge_distance[i] = 0;
1389 for (
const int propagation_it :
IndexRange(propagation_steps)) {
1395 for (
const int neighbor :
1398 if (edge_distance[neighbor] == propagation_it) {
1399 edge_distance[i] = propagation_it + 1;
1410 const float p = 1.0f - (
float(edge_distance[i]) /
float(propagation_steps));
1411 const float edge_boundary_automask =
pow2f(p);
1413 factors[i] *= (1.0f - edge_boundary_automask);
1419 const int propagation_steps,
1447 edge_distance[i] = 0;
1452 faces, corner_verts, vert_to_face_map, face_sets, subdiv_ccg, coord))
1454 edge_distance[i] = 0;
1461 for (
const int propagation_it :
IndexRange(propagation_steps)) {
1471 const int neighbor_idx = neighbor.
to_index(key);
1472 if (edge_distance[neighbor_idx] == propagation_it) {
1473 edge_distance[i] = propagation_it + 1;
1484 const float p = 1.0f - (
float(edge_distance[i]) /
float(propagation_steps));
1485 const float edge_boundary_automask =
pow2f(p);
1487 factors[i] *= (1.0f - edge_boundary_automask);
1493 const int propagation_steps,
1509 edge_distance[i] = 0;
1514 edge_distance[i] = 0;
1520 for (
const int propagation_it :
IndexRange(propagation_steps)) {
1530 if (edge_distance[neighbor_idx] == propagation_it) {
1531 edge_distance[i] = propagation_it + 1;
1542 const float p = 1.0f - (
float(edge_distance[i]) /
float(propagation_steps));
1543 const float edge_boundary_automask =
pow2f(p);
1545 factors[i] *= (1.0f - edge_boundary_automask);
1550 const Depsgraph &depsgraph,
1552 const int propagation_steps,
1582 brush->mesh_automasking_settings->view_normal_falloff;
1587 paint.mesh_automasking_settings->view_normal_falloff;
1595 brush->mesh_automasking_settings->start_normal_falloff;
1600 paint.mesh_automasking_settings->start_normal_falloff;
1630 for (
const int vert : range) {
1631 float f = factors[vert];
1636 depsgraph, automasking, ob, vert, vert_positions[vert]);
1651 for (
const int vert : range) {
1652 float f = factors[vert];
1657 depsgraph, automasking, ob, vert, subdiv_ccg.
positions[vert]);
1672 for (const int i : range) {
1673 const BMVert *vert = BM_vert_at_index(&bm, i);
1674 float f = factors[i];
1676 if (flag_is_set(mode, BRUSH_AUTOMASKING_VIEW_NORMAL)) {
1677 if (flag_is_set(mode, BRUSH_AUTOMASKING_VIEW_OCCLUSION)) {
1678 f *= calc_view_occlusion_factor(depsgraph, automasking, ob, i, vert->co);
1681 f *= calc_view_normal_factor(automasking, ob, vert->no);
1703 std::unique_ptr<Cache> automasking = std::make_unique<Cache>();
1723 symm_verts[symm_it]);
1744 automasking->cavity_factor =
Array<float>(verts_num, -1.0f);
1756 automasking->factor =
Array<float>(verts_num, initial_value);
1803 depsgraph,
paint,
nullptr, ob);
1833 switch (
pbvh.type()) {
1839 for (
const int vert : verts) {
1853 for (
const int grid : grids) {
1867 for (
BMVert *vert : verts) {
A BVH for high poly meshes.
#define BLI_SCOPED_DEFER(function_to_defer)
#define PRF_scope(category)
#define BM_elem_index_get(ele)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
constexpr IndexRange()=default
bool contains(const Key &key) const
void add_new(const Key &key)
constexpr Span slice(int64_t start, int64_t size) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
GAttributeReader lookup(const StringRef name) const
constexpr bool is_empty() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexRange index_range() const
ccl_device_inline float3x3 inverted(const float3x3 m)
IndexRange grid_range(const int grid_area, const int grid)
pbvh::Tree * pbvh_get(Object &object)
Span< float3 > vert_normals_eval(const Depsgraph &depsgraph, const Object &object_orig)
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
std::unique_ptr< Cache > cache_init(const Depsgraph &depsgraph, const Paint &paint, const Brush *brush, Object &ob)
static void init_face_sets_masking(const Paint &paint, Object &ob, MutableSpan< float > factors)
static void fill_topology_automasking_factors_mesh(const Depsgraph &depsgraph, const Paint &paint, Object &ob, const Span< float3 > vert_positions, MutableSpan< float > factors)
static void calc_blurred_cavity_mesh(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const int steps, const int vert, MutableSpan< float > cavity_factors)
static float calc_brush_normal_factor(const Cache &automasking, const Object &object, const float3 &normal)
static float normal_calc(const float3 &compare_normal, const float3 &normal, float limit_lower, float limit_upper)
static void calc_cavity_factor_bmesh(const Cache &automasking, BMVert *vert, const int vert_i)
static bool calc_view_occlusion_factor(const Depsgraph &depsgraph, Cache &automasking, const Object &object, const int vert, const float3 &vert_position)
static void calc_cavity_factor_mesh(const Depsgraph &depsgraph, const Cache &automasking, const Object &object, const int vert)
static void fill_topology_automasking_factors(const Depsgraph &depsgraph, const Paint &paint, Object &ob, MutableSpan< float > factors)
static void init_boundary_masking(Object &object, const Depsgraph &depsgraph, const BoundaryAutomaskMode mode, const int propagation_steps, MutableSpan< float > factors)
const Cache * active_cache_get(const SculptSession &ss)
static void fill_topology_automasking_factors_grids(const Paint &paint, Object &ob, const SubdivCCG &subdiv_ccg, MutableSpan< float > factors)
static float calc_view_normal_factor(const Cache &automasking, const Object &object, const float3 &normal)
static void cache_settings_update(Cache &automasking, Object &object, const Paint &paint, const Brush *brush)
static eAutomasking_flag calc_effective_bits(const Paint &paint, const Brush *brush)
static void init_boundary_masking_bmesh(Object &object, const BoundaryAutomaskMode mode, const int propagation_steps, MutableSpan< float > factors)
Cache & stroke_cache_ensure(const Depsgraph &depsgraph, const Paint &paint, const Brush *brush, Object &ob)
static void normal_occlusion_automasking_fill(const Depsgraph &depsgraph, Cache &automasking, Object &ob, eAutomasking_flag mode, MutableSpan< float > factors)
static void calc_blurred_cavity_grids(const Object &object, const Cache &automasking, const int steps, const SubdivCCGCoord vert, MutableSpan< float > cavity_factors)
static void init_boundary_masking_mesh(Object &object, const Depsgraph &depsgraph, const BoundaryAutomaskMode mode, const int propagation_steps, MutableSpan< float > factors)
static int boundary_propagation_steps(const Paint &paint, const Brush *brush)
static constexpr int EDGE_DISTANCE_INF
static void init_boundary_masking_grids(Object &object, const BoundaryAutomaskMode mode, const int propagation_steps, MutableSpan< float > factors)
bool is_enabled(const Paint &paint, const Object &object, const Brush *br)
static void calc_blurred_cavity_bmesh(const Cache &automasking, const int steps, BMVert *vert, MutableSpan< float > cavity_factors)
static void fill_topology_automasking_factors_bmesh(const Paint &paint, Object &ob, BMesh &bm, MutableSpan< float > factors)
void calc_vert_factors(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const bke::pbvh::MeshNode &node, Span< int > verts, MutableSpan< float > factors)
void calc_grids_factors(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const bke::pbvh::GridsNode &node, Span< int > grids, MutableSpan< float > factors)
void calc_interpolated_face_factors(const Depsgraph &depsgraph, const Object &object, OffsetIndices< int > faces, Span< int > corner_verts, const Cache &automasking, const bke::pbvh::MeshNode &node, Span< int > face_indices, MutableSpan< float > factors)
static float calc_cavity_factor(const Cache &automasking, float factor)
static bool is_constrained_by_radius(const Brush *br)
bool mode_enabled(const Sculpt &sd, const Brush *br, eAutomasking_flag mode)
Cache & filter_cache_ensure(const Depsgraph &depsgraph, const Paint &paint, Object &ob)
static float process_cavity_factor(const Cache &automasking, float factor)
static void calc_cavity_factor_grids(const CCGKey &key, const Cache &automasking, const Object &object, const int vert)
static bool needs_factors_cache(const Paint &paint, const Brush *brush)
void ensure_boundary_info(Object &object)
bool vert_is_boundary(const GroupedSpan< int > vert_to_face_map, const Span< bool > hide_poly, const BitSpan boundary_verts, const int vert)
bool stroke_is_dyntopo(const Object &object, const Brush &brush)
bool vert_has_unique_face_set(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, int vert)
bool vert_has_face_set(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const int vert, const int face_set)
int vert_face_set_max_get(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const int vert)
int active_face_set_get(const Object &object)
void ensure_cache(Object &object)
int vert_id_get(const SculptSession &ss, const int vert)
void vert_random_access_ensure(Object &object)
Vector< int > find_symm_verts_grids(const Object &object, const int original_vert, const float max_distance)
Vector< BMVert *, 64 > BMeshNeighborVerts
int vertex_count_get(const Object &object)
std::optional< OrigPositionData > orig_position_data_lookup_grids(const Object &object, const bke::pbvh::GridsNode &node)
void orig_position_data_gather_bmesh(const BMLog &bm_log, const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions, MutableSpan< float3 > normals)
ePaintSymmetryFlags mesh_symmetry_xyz_get(const Object &object)
Vector< int > find_symm_verts_mesh(const Depsgraph &depsgraph, const Object &object, const int original_vert, const float max_distance)
Span< BMVert * > vert_neighbors_get_bmesh(BMVert &vert, BMeshNeighborVerts &r_neighbors)
bool vertex_is_occluded(const Depsgraph &depsgraph, const Object &object, const float3 &position, bool original)
bool is_vertex_inside_brush_radius_symm(const float vertex[3], const float br_co[3], float radius, char symm)
std::optional< OrigPositionData > orig_position_data_lookup_mesh(const Object &object, const bke::pbvh::MeshNode &node)
Span< int > vert_neighbors_get_mesh(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const Span< bool > hide_poly, const int vert, Vector< int > &r_neighbors)
std::array< int, PAINT_SYMM_AREAS > find_all_symm_verts(const Depsgraph &depsgraph, const Object &object, const int original_vert, const float max_distance)
Vector< int > find_symm_verts_bmesh(const Object &object, const int original_vert, const float max_distance)
bool is_symmetry_iteration_valid(const char i, const char symm)
constexpr ParallelGrainSize grain_size(int grain_size)
T safe_divide(const T &a, const T &b)
T distance(const T &a, const T &b)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ PAINT_FALLOFF_SHAPE_TUBE
MINLINE float pow2f(float x)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
@ SCULPT_BRUSH_TYPE_DRAW_FACE_SETS
@ SCULPT_BRUSH_TYPE_ROTATE
@ SCULPT_BRUSH_TYPE_THUMB
void BKE_subdiv_ccg_neighbor_coords_get(const SubdivCCG &subdiv_ccg, const SubdivCCGCoord &coord, bool include_duplicates, SubdivCCGNeighbors &r_neighbors)
void BKE_curvemapping_init(CurveMapping *cumap)
BMesh const char void * data
MINLINE float signf(float f)
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
int BM_mesh_elem_count(BMesh *bm, const char htype)
BLI_INLINE BMVert * BM_vert_at_index(BMesh *bm, const int index)
@ BRUSH_AUTOMASKING_VIEW_OCCLUSION
@ BRUSH_AUTOMASKING_TOPOLOGY
@ BRUSH_AUTOMASKING_BRUSH_NORMAL
@ BRUSH_AUTOMASKING_FACE_SETS
@ BRUSH_AUTOMASKING_CAVITY_USE_CURVE
@ BRUSH_AUTOMASKING_BOUNDARY_FACE_SETS
@ BRUSH_AUTOMASKING_BOUNDARY_EDGES
@ BRUSH_AUTOMASKING_CAVITY_ALL
@ BRUSH_AUTOMASKING_VIEW_NORMAL
@ BRUSH_AUTOMASKING_CAVITY_NORMAL
@ BRUSH_AUTOMASKING_CAVITY_INVERTED
const Brush * BKE_paint_brush_for_read(const Paint *paint)
VecBase< float, 3 > float3
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
eBrushSculptType sculpt_brush_type
struct MeshAutomaskingSettings * mesh_automasking_settings
eBrushFalloffShape falloff_shape
bke::ObjectRuntime * runtime
std::unique_ptr< SculptBoundaryInfoCache > boundary_info_cache
ed::sculpt_paint::StrokeCache * cache
ed::sculpt_paint::filter::Cache * filter_cache
ActiveVert active_vert() const
int active_vert_index() const
static SubdivCCGCoord from_index(const CCGKey &key, int index)
int to_index(const CCGKey &key) const
SubdivCCGNeighborCoords coords
Array< float3 > positions
SculptSession * sculpt_session
float3 initial_normal_symm
std::unique_ptr< auto_mask::Cache > automasking
ePaintSymmetryFlags mirror_symmetry_pass
void calc_cavity_factor(const Depsgraph &depsgraph, const Object &object, const IndexMask &node_mask)
Array< OcclusionValue > occlusion
Array< float > cavity_factor
float start_normal_falloff
CurveMapping * cavity_curve
float view_normal_falloff
bool topology_use_brush_limit
std::array< int, PAINT_SYMM_AREAS > initial_island_nr
std::unique_ptr< auto_mask::Cache > automasking
void add_initial(BMVert *vertex)
void execute(Object &object, FunctionRef< bool(BMVert *from_v, BMVert *to_v)> func)
void execute(Object &object, const SubdivCCG &subdiv_ccg, FunctionRef< bool(SubdivCCGCoord from_v, SubdivCCGCoord to_v, bool is_duplicate)> func)
void add_initial(SubdivCCGCoord vertex)
void execute(Object &object, GroupedSpan< int > vert_to_face_map, FunctionRef< bool(int from_v, int to_v)> func)
void add_initial(int vertex)