38 BMVert *v_tar =
static_cast<BMVert *
>(BMO_slot_map_elem_get(slot_targetmap,
l->
v));
98#define LOOP_MAP_VERT_INIT(l_init, v_map, is_del) \
100 is_del = BMO_vert_flag_test_bool(bm, v_map, ELE_DEL); \
102 v_map = static_cast<BMVert *>(BMO_slot_map_elem_get(slot_targetmap, v_map)); \
106 BMLoop *l_first, *l_curr, *l_next;
117 l_next = l_curr->
next;
121 if ((is_del_v_curr || is_del_v_next) == 0) {
124 else if (v_curr == v_next) {
146 is_del_v_curr = is_del_v_next;
147 }
while ((l_curr = l_next) != l_first);
149#undef LOOP_MAP_VERT_INIT
173 }
while ((
void)i++, (l_iter = l_iter->
next) != l_first);
201 const bool has_selected = !
bm->
selected.is_empty();
202 const bool use_targetmap_all = has_selected;
210 BMVert *v_dst =
static_cast<BMVert *
>(BMO_slot_map_elem_get(slot_targetmap,
v));
211 if (v_dst ==
nullptr) {
220 if (use_targetmap_all) {
222 targetmap_all.
add(
v, v_dst);
226 if (average_vert_data &&
LIKELY(v_dst !=
v)) {
227 clusters.
add(v_dst,
v);
233 for (
const auto &item : clusters.
items()) {
241 for (
BMVert *v_duplicate : cluster) {
246 mul_v3_fl(centroid, 1.0f /
float(count));
251 if (average_vert_data) {
252 for (
const auto &item : clusters.
items()) {
259 src_blocks[i + 1] = merged_verts[i]->head.
data;
277 if (is_del_v1 || is_del_v2) {
279 v1 =
static_cast<BMVert *
>(BMO_slot_map_elem_get(slot_targetmap, v1));
282 v2 =
static_cast<BMVert *
>(BMO_slot_map_elem_get(slot_targetmap,
v2));
291 if (e_new ==
nullptr) {
295 if (use_targetmap_all) {
297 targetmap_all.
add(
e, e_new);
308 bool vert_delete =
false;
309 int edge_collapse = 0;
321 bool use_in_place =
false;
325 if (f->
len - edge_collapse >= 3) {
348 if ((use_in_place ==
false) && (f_new !=
nullptr)) {
350 if (use_targetmap_all) {
351 targetmap_all.
add(f, f_new);
362 bm, &targetmap_all, &targetmap_all, &targetmap_all,
true);
381 vert_target =
static_cast<BMVert *
>(
391 if (l_first ==
nullptr) {
467 BMVert *
v, *vert_target =
nullptr;
478 vert_target =
static_cast<BMVert *
>(
481 const bool is_explicit_snap = vert_target !=
nullptr;
488 else if (
v != vert_target) {
493 if (!is_explicit_snap) {
570 for (j = 0; j < 2; j++) {
571 BMVert *v_src = *((&
e->v1) + j);
693 const bool has_keep_vert)
696 bool found_duplicates =
false;
697 bool has_self_index =
false;
700 for (
int i = 0; i < verts_len; i++) {
704 has_self_index =
true;
714 auto deduplicate_target_calc_fn = [&verts](
const int *cluster,
const int cluster_num) ->
int {
715 if (cluster_num == 2) {
718 return (cluster[0] < cluster[1]) ? 0 : 1;
723 for (
int i = 0; i < cluster_num; i++) {
724 centroid +=
float3(verts[cluster[i]]->co);
726 centroid /=
float(cluster_num);
729 const int cluster_end = cluster_num - 1;
732 int i_best = cluster_end;
733 float dist_sq_best =
len_squared_v3v3(centroid, verts[cluster[i_best]]->co);
734 for (
int i = 0; i < cluster_end; i++) {
735 const float dist_sq_test =
len_squared_v3v3(centroid, verts[cluster[i]]->co);
737 if (dist_sq_test > dist_sq_best) {
740 if (dist_sq_test == dist_sq_best) {
741 if (cluster[i] > cluster[i_best]) {
746 dist_sq_best = dist_sq_test;
752 tree, dist, duplicates, has_self_index, deduplicate_target_calc_fn) != 0;
756 if (!found_duplicates) {
757 MEM_delete(duplicates);
758 duplicates =
nullptr;
768 const bool has_keep_vert)
771 bool found_duplicates =
false;
776 for (
int i = 0; i < verts_len; i++) {
783 vert_to_index_map.
add(verts[i], i);
788 for (
int i = 0; i < verts_len; i++) {
789 if (!
ELEM(duplicates[i], -1, i)) {
792 const float *co_check = verts[i]->
co;
796 BMVert *v_check = verts[i_check];
799 e_first = e_iter = v_check->
e;
804 const int i_other = vert_to_index_map.
lookup_default(v_other, -1);
805 if ((i_other != -1) && (duplicates[i_other] == -1)) {
806 duplicates[i_other] = i;
807 vert_stack.
push(i_other);
808 found_duplicates =
true;
815 l_radial_iter = e_iter->
l;
817 if (l_radial_iter->
v != v_check) {
821 if (l_radial_iter->
f->
len <= 3) {
833 const int i_other = vert_to_index_map.
lookup_default(v_other, -1);
834 if ((i_other != -1) && (duplicates[i_other] == -1)) {
835 duplicates[i_other] = i;
836 vert_stack.
push(i_other);
837 found_duplicates =
true;
840 }
while ((l_iter = l_iter->
next) != l_end);
841 }
while ((l_radial_iter = l_radial_iter->
radial_next) != e_iter->
l);
846 }
while ((i_check = vert_stack.
is_empty() ? -1 : vert_stack.
pop()) != -1);
849 if (!found_duplicates) {
850 MEM_delete(duplicates);
851 duplicates =
nullptr;
865 const int verts_len = slot_verts->
len;
867 bool has_keep_vert =
false;
882 int *duplicates =
nullptr;
885 bm, verts, verts_len, dist, has_keep_vert);
893 for (
int i = 0; i < verts_len; i++) {
894 BMVert *v_check = verts[i];
895 if (duplicates[i] == -1) {
898 else if (duplicates[i] == i) {
902 BMVert *v_other = verts[duplicates[i]];
907 MEM_delete(duplicates);
CustomData interface, see also DNA_customdata_types.h.
A KD-tree for nearest neighbor search.
#define STACK_CLEAR(stack)
#define STACK_PUSH(stack, val)
#define STACK_DECLARE(stack)
#define STACK_SIZE(stack)
#define STACK_INIT(stack, stack_num)
Read Blender memory allocation and freeing.
#define BM_DISK_EDGE_NEXT(e, v)
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_elem_flag_merge_ex(ele_a, ele_b, hflag_and)
#define BM_elem_flag_disable(ele, hflag)
#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 BMO_vert_flag_disable(bm, e, oflag)
#define BMO_edge_flag_test(bm, e, oflag)
#define BMO_edge_flag_enable(bm, e, oflag)
#define BMO_vert_flag_enable(bm, e, oflag)
#define BMO_face_flag_enable(bm, e, oflag)
#define BMO_ITER(ele, iter, slot_args, slot_name, restrict_flag)
#define BMO_vert_flag_test(bm, e, oflag)
#define BMO_vert_flag_test_bool(bm, e, oflag)
#define BMO_face_flag_disable(bm, e, oflag)
#define LOOP_MAP_VERT_INIT(l_init, v_map, is_del)
bool add(const Key &key, const Value &value)
Value lookup_default(const Key &key, const Value &default_value) const
MapType::ItemIterator items() const
void add(const Key &key, const Value &value)
constexpr const T * data() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
void push(const T &value)
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
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 kdtree_balance(KDTree< CoordT > *tree)
BLI_INLINE bool BM_loop_is_adjacent(const BMLoop *l_a, const BMLoop *l_b) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
bool BLI_stack_is_empty(const BLI_Stack *stack) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
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 BLI_stack_free(BLI_Stack *stack) ATTR_NONNULL()
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void * BMW_begin(BMWalker *walker, void *start)
float BMO_slot_float_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
void BMO_slot_buffer_flag_enable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
BMO_FLAG_BUFFER.
void BMW_init(BMWalker *walker, BMesh *bm, int type, short mask_vert, short mask_edge, short mask_face, BMWFlag flag, int layer, BMWDelimitFlag delimit)
Initialize Walker.
void BMO_mesh_delete_oflag_context(BMesh *bm, const short oflag, const int type, FunctionRef< void()> prepare_fn)
void BLI_stack_pop(BLI_Stack *stack, void *dst) ATTR_NONNULL()
void CustomData_bmesh_interp(CustomData *data, const void **src_blocks, const float *weights, int count, void *dst_block)
int kdtree_calc_duplicates_cb(const KDTree< CoordT > *tree, const typename KDTree< CoordT >::ValueType range, int *duplicates, const bool has_self_index, Func &&duplicates_cb)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void CustomData_bmesh_copy_block(CustomData &data, void *src_block, void **dst_block)
BMFace * BM_face_create(BMesh *bm, BMVert *const *verts, BMEdge *const *edges, const int len, const BMFace *f_example, const eBMCreateFlag create_flag)
void bmo_collapse_uvs_exec(BMesh *bm, BMOperator *op)
void BMO_op_exec(BMesh *bm, BMOperator *op)
BMESH OPSTACK EXEC OP.
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
MINLINE void mul_v3_fl(float r[3], float f)
void * BMO_slot_buffer_get_single(BMOpSlot *slot)
static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op, BMOpSlot *slot_targetmap)
KDTree< CoordT > * kdtree_new(uint nodes_len_capacity)
int BM_vert_face_count(const BMVert *v)
ATTR_WARN_UNUSED_RESULT const BMFlagLayer * oflags
void BMW_end(BMWalker *walker)
End Walker.
void BMO_slot_vec_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, float r_vec[3])
void CustomData_data_copy_value(eCustomDataType type, const void *source, void *dest)
static void bmo_collapsecon_do_layer(BMesh *bm, const int layer, const short oflag)
void kdtree_insert(KDTree< CoordT > *tree, int index, const CoordT &co)
void CustomData_data_multiply(eCustomDataType type, void *data, float fac)
void BMO_slot_bool_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, bool i)
void bmo_pointmerge_exec(BMesh *bm, BMOperator *op)
bool BMO_op_callf(BMesh *bm, int flag, const char *fmt,...)
void * BLI_stack_peek(BLI_Stack *stack) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static int * bmesh_find_doubles_by_distance_impl(BMesh *bm, BMVert *const *verts, const int verts_len, const float dist, const bool has_keep_vert)
MINLINE void zero_v3(float r[3])
BMFace * BM_face_exists(BMVert *const *varr, int len)
BMOpSlot * BMO_slot_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
BMESH OPSTACK GET SLOT.
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
void bmo_pointmerge_facedata_exec(BMesh *bm, BMOperator *op)
MINLINE void add_v3_v3(float r[3], const float a[3])
bool BMO_slot_bool_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
void kdtree_free(KDTree< CoordT > *tree)
void bmo_remove_doubles_exec(BMesh *bm, BMOperator *op)
void bmo_weld_verts_exec(BMesh *bm, BMOperator *op)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
void BM_face_kill(BMesh *bm, BMFace *f)
BMFace * BM_face_split(BMesh *bm, BMFace *f, BMLoop *l_a, BMLoop *l_b, BMLoop **r_l, BMEdge *example, const bool no_double)
Face Split.
static BMFace * remdoubles_createface(BMesh *bm, BMFace *f, BMOpSlot *slot_targetmap, bool *r_created)
static int * bmesh_find_doubles_by_distance_connected_impl(BMesh *bm, BMVert *const *verts, const int verts_len, const float dist, const bool has_keep_vert)
void BM_select_history_merge_from_targetmap(BMesh *bm, Map< void *, void * > *vert_map, Map< void *, void * > *edge_map, Map< void *, void * > *face_map, const bool use_chain)
void * BMW_step(BMWalker *walker)
Step Walker.
void BLI_stack_push(BLI_Stack *stack, const void *src) ATTR_NONNULL()
BMLoop * BM_face_vert_share_loop(BMFace *f, BMVert *v)
Return the Loop Shared by Face and Vertex.
void BMO_op_init(BMesh *bm, BMOperator *op, int flag, const char *opname)
BMESH OPSTACK INIT OP.
void bmo_average_vert_facedata_exec(BMesh *bm, BMOperator *op)
int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const bool value)
Mesh Iter Flag Count.
void BM_elem_attrs_copy(BMesh *bm, const BMCustomDataCopyMap &map, const BMVert *src, BMVert *dst)
bool CustomData_has_math(const CustomData *data)
VecBase< float, 3 > float3
void BMO_op_finish(BMesh *bm, BMOperator *op)
BMESH OPSTACK FINISH OP.
ATTR_WARN_UNUSED_RESULT const BMFlagLayer const short oflag
BLI_INLINE void BMO_slot_map_elem_insert(BMOperator *op, BMOpSlot *slot, const void *element, void *val)
BLI_Stack * BLI_stack_new(size_t elem_size, const char *description) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void bmesh_find_doubles_common(BMesh *bm, BMOperator *op, BMOperator *optarget, BMOpSlot *optarget_slot)
void CustomData_data_initminmax(eCustomDataType type, void *min, void *max)
void bmo_find_doubles_exec(BMesh *bm, BMOperator *op)
void CustomData_data_add(eCustomDataType type, void *data1, const void *data2)
BMEdge * BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *e_example, const eBMCreateFlag create_flag)
Main function for creating a new edge.
bool CustomData_layer_has_math(const CustomData *data, int layer_n)
void bmesh_face_swap_data(BMFace *f_a, BMFace *f_b)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void CustomData_data_dominmax(eCustomDataType type, const void *data, void *min, void *max)
bool BMO_slot_exists(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
BMESH OPSTACK HAS SLOT.
void * BMO_iter_new(BMOIter *iter, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char restrictmask)
New Iterator.
void bmo_collapse_exec(BMesh *bm, BMOperator *op)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct BMLoop * radial_next
union blender::BMOpSlot::@376352321363166111241172004263244043165250166277 data
struct BMOpSlot slots_in[BMO_OP_MAX_SLOTS]
struct BMOpSlot slots_out[BMO_OP_MAX_SLOTS]
ListBaseT< BMEditSelection > selected