57 defgroup = MEM_new<bDeformGroup>(__func__);
76 const ListBaseT<bDeformGroup> *inbase)
78 outbase->clear_no_delete();
92 bDeformGroup *outgroup = MEM_new<bDeformGroup>(__func__);
97 outgroup->
next = outgroup->
prev =
nullptr;
104 const bool *vgroup_subset,
105 const int vgroup_num)
108 for (defgroup = 0; defgroup < vgroup_num; defgroup++) {
109 if (vgroup_subset[defgroup]) {
117 const bool *vgroup_subset,
118 const int vgroup_num,
120 const int flip_map_num)
123 for (defgroup = 0; defgroup < vgroup_num && defgroup < flip_map_num; defgroup++) {
124 if (vgroup_subset[defgroup] && (dvert_dst != dvert_src || flip_map[defgroup] != defgroup)) {
139 MEM_delete(dvert_dst->
dw);
143 dvert_dst->
dw = MEM_dupalloc(dvert_src->
dw);
146 dvert_dst->
dw =
nullptr;
154 const int defgroup_dst,
156 const int defgroup_src)
181 for (
int i = 0; i < dvert_src->
totweight; i++, dw_src++) {
200 const int flip_map_num,
201 const bool use_ensure)
205 for (
int i = 0; i < dvert_src->
totweight; i++, dw_src++) {
206 if (dw_src->
def_nr < flip_map_num) {
226 for (
int i = dvert->
totweight; i != 0; i--, dw++) {
227 if (dw->
def_nr < map_len) {
257 const bool use_subset = !subset_flags.
is_empty();
258 const bool use_locks = !lock_flags.
is_empty();
259 const bool use_soft_locks = !soft_lock_flags.
is_empty();
287 if (use_subset && !subset_flags[dw->
def_nr]) {
291 const bool is_unlocked = lock_flags.
is_empty() || !lock_flags[dw->
def_nr];
301 float total_locked_weight = 0.0f;
302 float total_soft_locked_weight = 0.0f;
303 float total_regular_weight = 0.0f;
304 int soft_locked_group_count = 0;
306 if (use_subset && !subset_flags[dw.def_nr]) {
311 if (use_locks && lock_flags[dw.def_nr]) {
313 total_locked_weight += dw.weight;
315 else if (use_soft_locks && soft_lock_flags[dw.def_nr]) {
316 total_soft_locked_weight += dw.weight;
317 soft_locked_group_count++;
320 total_regular_weight += dw.weight;
324 const float available_weight =
max_ff(0.0f, 1.0f - total_locked_weight);
331 if (total_regular_weight <= 0.0f && total_soft_locked_weight <= 0.0f) {
356 if (soft_locked_group_count == 0) {
360 const float weight = available_weight / soft_locked_group_count;
362 if (!subset_flags.
is_empty() && !subset_flags[dw.def_nr]) {
367 if (!lock_flags.
is_empty() && lock_flags[dw.def_nr]) {
372 if (use_soft_locks && soft_lock_flags[dw.def_nr]) {
381 float soft_locked_scale;
383 const bool must_adjust_soft_locked = total_soft_locked_weight >= available_weight ||
384 total_regular_weight <= 0.0f;
385 if (must_adjust_soft_locked) {
386 soft_locked_scale = available_weight / total_soft_locked_weight;
387 regular_scale = 0.0f;
390 soft_locked_scale = 1.0f;
391 regular_scale = (available_weight - total_soft_locked_weight) / total_regular_weight;
396 if (use_subset && !subset_flags[dw.def_nr]) {
401 if (use_locks && lock_flags[dw.def_nr]) {
406 if (use_soft_locks && soft_lock_flags[dw.def_nr]) {
407 dw.weight *= soft_locked_scale;
410 dw.weight *= regular_scale;
414 CLAMP(dw.weight, 0.0f, 1.0f);
423 for (dw = dvert->
dw, i = 0; i < dvert->totweight; dw++, i++) {
424 if (dw->
def_nr < flip_map_num) {
425 if (flip_map[dw->
def_nr] >= 0) {
439 for (dw = dvert->
dw, i = 0; i < totweight; dw++, i++) {
440 if (dw->
def_nr < flip_map_num) {
441 if (flip_map[dw->
def_nr] >= 0) {
467 const ID *
id =
static_cast<const ID *
>(ob->
data);
474 switch (
GS(
id->name)) {
476 const Mesh *
mesh = id_cast<const Mesh *>(
id);
477 return &
mesh->vertex_group_names;
480 const Lattice *lt = id_cast<const Lattice *>(
id);
484 const bGPdata *gpd = id_cast<const bGPdata *>(
id);
504 return &
mesh->vertex_group_active_index;
507 const Lattice *lattice = id_cast<const Lattice *>(ob->
data);
511 const bGPdata *gpd = id_cast<const bGPdata *>(ob->
data);
537 if (name == group.name) {
549 for (
const auto [
index, group] : defbase->enumerate()) {
550 if (name == group.name) {
571 for (
const auto [
index, group] : defbase->enumerate()) {
572 if (name == group.name) {
573 if (r_index !=
nullptr) {
576 if (r_group !=
nullptr) {
626 const bool use_default,
627 const bool use_only_unlocked,
631 const int defbase_num = defbase->count();
632 *r_flip_map_num = defbase_num;
634 if (defbase_num == 0) {
639 char name_flip[
sizeof(dg->
name)];
643 for (i = 0; i < defbase_num; i++) {
647 for (dg = defbase->first(), i = 0; dg; dg = dg->
next, i++) {
663 if (flip_num != -1) {
679 const bool use_default,
686 const bool use_default,
691 const int defbase_num = defbase->count();
692 *r_flip_map_num = defbase_num;
694 if (defbase_num == 0) {
701 for (i = 0; i < defbase_num; i++) {
702 map[i] = use_default ? i : -1;
711 if (flip_num != -1) {
712 map[defgroup] = flip_num;
713 map[flip_num] = defgroup;
727 char name_flip[
sizeof(dg->
name)];
735 return (flip_index == -1 && use_default) ?
index : flip_index;
749 if (curdef.name == name) {
769 std::string old_name = dg->
name;
782 return dw ? dw->
weight : 0.0f;
795 if (defgroup == -1) {
798 if (dvert ==
nullptr) {
799 return invert ? 1.0 : 0.0f;
805 weight = 1.0f - weight;
813 if (dvert && defgroup >= 0) {
817 for (i = dvert->
totweight; i != 0; i--, dw++) {
818 if (dw->
def_nr == defgroup) {
835 if (!dvert || defgroup < 0) {
848 MEM_delete(dvert->
dw);
853 dw_new->
def_nr = defgroup;
868 if (!dvert || defgroup < 0) {
876 MEM_delete(dvert->
dw);
881 dw_new->
def_nr = defgroup;
887 if (!dvert || !dw) [[unlikely]] {
897 const int i = dw - dvert->
dw;
913 MEM_delete(dvert->
dw);
920 MEM_SAFE_DELETE(dvert->
dw);
931 for (i = dvert_a->
totweight; i != 0; i--, dw++) {
944 for (
int i = dvert->
totweight; i != 0; i--, dw++) {
947 if (dw->
def_nr < defgroup_tot) [[likely]] {
957 const bool *defbase_sel)
962 if (defbase_sel ==
nullptr) {
966 for (
int i = dv->
totweight; i != 0; i--, dw++) {
967 if (dw->
def_nr < defbase_num) {
968 if (defbase_sel[dw->
def_nr]) {
978 const int defbase_num,
979 const bool *defbase_sel,
980 const int defbase_sel_num,
981 const bool is_normalized)
987 if (!is_normalized) {
988 total /= defbase_sel_num;
996 float unlocked_weight)
999 if (unlocked_weight > 0.0f) {
1000 return weight / unlocked_weight;
1004 if (locked_weight <= 0.0f) {
1010 if (weight != 0.0f) {
1019 return weight / (1.0f - locked_weight);
1024 const int defbase_num,
1025 const bool *defbase_locked,
1026 const bool *defbase_unlocked)
1030 if (unlocked > 0.0f) {
1031 return weight / unlocked;
1053 for (
int i = 0; i < totvert; i++) {
1056 memcpy(dst[i].dw, src[i].dw,
sizeof(
MDeformWeight) * src[i].totweight);
1072 for (
int i = 0; i < totvert; i++) {
1074 MEM_delete(dvert[i].dw);
1096 const int verts_num,
1097 const bool invert_vgroup,
1100 if (dvert && defgroup != -1) {
1105 r_weights[i] = invert_vgroup ? (1.0f -
w) :
w;
1109 std::fill_n(r_weights, verts_num, invert_vgroup ? 1.0f : 0.0f);
1115 const int verts_num,
1117 const bool invert_vgroup,
1120 if (!dvert || defgroup == -1) [[unlikely]] {
1121 std::fill_n(r_weights, edges.
size(), 0.0f);
1125 int i = edges.
size();
1129 dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
1132 const int2 &edge = edges[i];
1134 r_weights[i] = (tmp_weights[edge[0]] + tmp_weights[edge[1]]) * 0.5f;
1137 MEM_delete(tmp_weights);
1142 const int verts_num,
1144 const bool invert_vgroup,
1147 if (!dvert || defgroup == -1) [[unlikely]] {
1148 std::fill_n(r_weights, corner_verts.
size(), 0.0f);
1152 int i = corner_verts.
size();
1156 dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
1159 r_weights[i] = tmp_weights[corner_verts[i]];
1162 MEM_delete(tmp_weights);
1167 const int verts_num,
1170 const bool invert_vgroup,
1173 if (!dvert || defgroup == -1) [[unlikely]] {
1174 std::fill_n(r_weights, faces.
size(), 0.0f);
1178 int i = faces.
size();
1182 dvert, defgroup, verts_num, invert_vgroup, tmp_weights);
1186 const int *corner_vert = &corner_verts[face.
start()];
1187 int j = face.
size();
1190 for (; j--; corner_vert++) {
1191 w += tmp_weights[*corner_vert];
1196 MEM_delete(tmp_weights);
1207 const void **sources,
1208 const float *weights,
1210 const float mix_factor)
1217 const int mix_mode = laymap->
mix_mode;
1222 float weight_src = 0.0f, weight_dst = 0.0f;
1224 bool has_dw_sources =
false;
1226 for (i = count; i--;) {
1227 for (j = data_src[i]->totweight; j--;) {
1229 if (dw_src->
def_nr == idx_src) {
1230 weight_src += dw_src->
weight * weights[i];
1231 has_dw_sources =
true;
1239 weight_dst = dw_dst->
weight;
1247 CLAMP(weight_src, 0.0f, 1.0f);
1250 if (!has_dw_sources) {
1253 dw_dst->
weight = weight_src;
1260 dw_dst->
weight = weight_src;
1267 const float mix_factor,
1268 const float *mix_weights,
1269 const bool use_create,
1270 const bool use_delete,
1272 const Mesh &mesh_src,
1276 const bool *use_layers_src,
1277 const int num_layers_src)
1284 const int tot_dst = dst_defbase->count();
1293 idx_src = num_layers_src;
1294 while (idx_src-- && !use_layers_src[idx_src]) {
1299 if (idx_dst < idx_src) {
1302 for (; idx_dst < idx_src; idx_dst++) {
1311 else if (use_delete && idx_dst > idx_src) {
1312 while (idx_dst-- > idx_src) {
1318 if (!use_layers_src[idx_src]) {
1326 mesh_src.deform_verts().data(),
1327 mesh_dst.deform_verts_for_write().data(),
1343 for (dg_dst = dst_defbase->first(); dg_dst;) {
1349 dg_dst = dg_dst_next;
1353 for (idx_src = 0, dg_src = src_list->first(); idx_src < num_layers_src;
1354 idx_src++, dg_src = dg_src->
next)
1356 if (!use_layers_src[idx_src]) {
1361 if (idx_dst == -1) {
1377 mesh_src.deform_verts().data(),
1378 mesh_dst.deform_verts_for_write().data(),
1399 const float mix_factor,
1400 const float *mix_weights,
1401 const bool use_create,
1402 const bool use_delete,
1405 const Mesh &mesh_src,
1407 const bool use_dupref_dst,
1408 const int fromlayers,
1411 int idx_src, idx_dst;
1422 if (src_defbase->is_empty()) {
1432 if (fromlayers >= 0) {
1433 idx_src = fromlayers;
1434 if (idx_src >= src_defbase->count()) {
1445 if (tolayers >= 0) {
1454 if (idx_dst == -1) {
1465 int num = src_defbase->count();
1467 if (
num <= idx_dst) {
1472 for (;
num <= idx_dst;
num++) {
1480 if (idx_dst == -1) {
1498 mesh_src.deform_verts().data(),
1499 mesh_dst.deform_verts_for_write().data(),
1510 int num_src, num_sel_unused;
1511 bool *use_layers_src =
nullptr;
1514 switch (fromlayers) {
1529 if (use_layers_src) {
1545 MEM_SAFE_DELETE(use_layers_src);
1560 const float blend = ((weight / 2.0f) + 0.5f);
1562 if (weight <= 0.25f) {
1564 r_rgb[1] = blend * weight * 4.0f;
1567 else if (weight <= 0.50f) {
1570 r_rgb[2] = blend * (1.0f - ((weight - 0.25f) * 4.0f));
1572 else if (weight <= 0.75f) {
1573 r_rgb[0] = blend * ((weight - 0.50f) * 4.0f);
1577 else if (weight <= 1.0f) {
1579 r_rgb[1] = blend * (1.0f - ((weight - 0.75f) * 4.0f));
1606 if (dvlist ==
nullptr) {
1614 for (
int i = 0; i < count; i++) {
1623 if (mdverts ==
nullptr) {
1627 for (
int i = count; i > 0; i--, mdverts++) {
1635 memcpy(dw_tmp, dw, dw_len);
1640 mdverts->
dw =
nullptr;
1657 const int dvert_index_;
1668 dvert_index_(dvert_index)
1674 if (dverts_ ==
nullptr) {
1678 return weight->weight;
1686 if (value == 0.0f) {
1688 weight->weight = 0.0f;
1701 for (const int64_t i : range) {
1702 this->set(i, src[i]);
1709 const bool )
const override
1712 if (dverts_ ==
nullptr) {
1716 mask.slice(range).foreach_index_optimized<int64_t>([&](const int64_t index) {
1717 if (const MDeformWeight *weight = this->find_weight_at_index(index)) {
1718 dst[index] = weight->weight;
1731 if (weight.def_nr == dvert_index_) {
1740 if (weight.def_nr == dvert_index_) {
1753 const int defgroup_index)
1762 for (MDeformVert &dvert : dverts.slice(range)) {
1763 MDeformWeight *weight = BKE_defvert_find_index(&dvert, defgroup_index);
1764 BKE_defvert_remove_group(&dvert, weight);
1765 for (MDeformWeight &weight : MutableSpan(dvert.dw, dvert.totweight)) {
1766 if (weight.def_nr > defgroup_index) {
1788 const int src_i = indices[dst_i];
1789 dst[dst_i].dw = MEM_dupalloc(src[src_i].dw);
1790 dst[dst_i].totweight = src[src_i].totweight;
1791 dst[dst_i].flag = src[src_i].flag;
1802 dst[dst_i].dw = MEM_dupalloc(src[src_i].dw);
1803 dst[dst_i].totweight = src[src_i].totweight;
1804 dst[dst_i].flag = src[src_i].flag;
1817 if (indices.
size() == 1) {
1820 std::copy_n(src_dvert.
dw, src_dvert.
totweight, dst_dvert.
dw);
1832 const float factor = weights.
is_empty() ? src_num_inv : weights[i];
1839 [](
const auto &a,
const auto &
b) { return a.def_nr < b.def_nr; });
1843 std::copy(dw_buffer.
begin(), dw_buffer.
end(), dst_dvert.
dw);
CustomData interface, see also DNA_customdata_types.h.
Low-level operations for grease pencil.
Utility functions for vertex groups in grease pencil objects.
General operations, lookup, etc. for blender objects.
#define STRNCPY_UTF8(dst, src)
Object is a sort of wrapper for general info.
#define OB_TYPE_SUPPORT_VGROUP(_type)
Read Blender memory allocation and freeing.
#define PRF_scope_with_name(ui_name, category)
#define PRF_scope(category)
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define MEM_realloc_uninitialized(vmemh, len)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
constexpr int64_t size() const
constexpr int64_t start() const
constexpr MutableSpan()=default
constexpr IndexRange index_range() const
constexpr const T & first() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
static VArray from(Args &&...args)
static VMutableArray from(Args &&...args)
int64_t index_of_or_add(const Key &key)
void clear_and_keep_capacity()
const Key * begin() const
void set_all(Span< float > src) override
float get(const int64_t index) const override
void set(const int64_t index, const float value) override
VArrayImpl_For_VertexWeights(MutableSpan< MDeformVert > dverts, const int dvert_index)
VArrayImpl_For_VertexWeights(Span< MDeformVert > dverts, const int dvert_index)
void materialize(const IndexMask &mask, float *dst, const bool) const override
constexpr bool is_empty() const
void copy_utf8_truncated(char *dst, int64_t dst_size) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
float2x2 invert(float2x2 mat)
void validate_drawing_vertex_groups(GreasePencil &grease_pencil)
void remove_defgroup_index(MutableSpan< MDeformVert > dverts, int defgroup_index)
void gather_deform_verts(Span< MDeformVert > src, Span< int > indices, MutableSpan< MDeformVert > dst)
MDeformVert mix_deform_verts(const Span< MDeformVert > src, const Span< int > indices, const Span< float > weights, MDeformWeightSet &dw_buffer)
VMutableArray< float > varray_for_mutable_deform_verts(MutableSpan< MDeformVert > dverts, int defgroup_index)
CustomIDVectorSet< MDeformWeight, WeightIndexGetter, 64 > MDeformWeightSet
VArray< float > varray_for_deform_verts(Span< MDeformVert > dverts, int defgroup_index)
constexpr ParallelGrainSize grain_size(int grain_size)
void masked_fill(MutableSpan< T > data, const T &value, const IndexMask &mask)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
@ CDT_MIX_REPLACE_ABOVE_THRESHOLD
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_object_defgroup_unique_name(bDeformGroup *dg, Object *ob)
void BKE_defvert_array_free(MDeformVert *dvert, int totvert)
bool BKE_defvert_is_weight_zero(const MDeformVert *dvert, int defgroup_tot)
ListBaseT< bDeformGroup > * BKE_object_defgroup_list_mutable(Object *ob)
static const int * object_defgroup_active_index_get_p(const Object *ob)
void BKE_defbase_blend_write(BlendWriter *writer, const ListBaseT< bDeformGroup > *defbase)
bool BKE_defgroup_listbase_name_find(ListBaseT< bDeformGroup > *defbase, StringRef name, int *r_index, bDeformGroup **r_group)
const ListBaseT< bDeformGroup > * BKE_object_defgroup_list(const Object *ob)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void BKE_defvert_array_copy(MDeformVert *dst, const MDeformVert *src, int totvert)
int BKE_object_defgroup_count(const Object *ob)
void BKE_defvert_remap(MDeformVert *dvert, const int *map, int map_len)
bDeformGroup * BKE_object_defgroup_find_name(const Object *ob, StringRef name)
void BKE_defvert_flip_merged(MDeformVert *dvert, const int *flip_map, int flip_map_num)
void BKE_defvert_blend_read(BlendDataReader *reader, int count, MDeformVert *mdverts)
void BKE_defvert_blend_write(BlendWriter *writer, int count, const MDeformVert *dvlist)
const ListBaseT< bDeformGroup > * BKE_id_defgroup_list_get(const ID *id)
void BKE_defvert_array_free_elems(MDeformVert *dvert, int totvert)
static bool defgroup_find_name_dupe(const StringRef name, bDeformGroup *dg, Object *ob)
void BKE_defvert_extract_vgroup_to_faceweights(const MDeformVert *dvert, int defgroup, int verts_num, const Span< int > corner_verts, OffsetIndices< int > faces, bool invert_vgroup, float *r_weights)
void BKE_object_defgroup_active_index_set(Object *ob, int new_index)
void BKE_defvert_extract_vgroup_to_vertweights(const MDeformVert *dvert, int defgroup, int verts_num, bool invert_vgroup, float *r_weights)
void BKE_defvert_clear(MDeformVert *dvert)
int * BKE_object_defgroup_flip_map(const Object *ob, bool use_default, int *r_flip_map_num)
int BKE_defgroup_name_index(const ListBaseT< bDeformGroup > *defbase, StringRef name)
void BKE_object_batch_cache_dirty_tag(Object *ob)
int BKE_id_defgroup_name_index(const ID *id, StringRef name)
void BKE_object_defgroup_remove_all(struct Object *ob)
size_t void BLI_uniquename_cb(FunctionRef< bool(StringRefNull)> unique_check, const char *defname, char delim, char *name, size_t name_maxncpy) ATTR_NONNULL(2
float BKE_defvert_find_weight(const MDeformVert *dvert, int defgroup)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
bool BKE_object_supports_vertex_groups(const Object *ob)
void BKE_defvert_copy_subset(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const bool *vgroup_subset, int vgroup_num)
VecBase< int32_t, 2 > int2
int * BKE_object_defgroup_flip_map_single(const Object *ob, bool use_default, int defgroup, int *r_flip_map_num)
float BKE_defvert_lock_relative_weight(float weight, const MDeformVert *dv, int defbase_num, const bool *defbase_locked, const bool *defbase_unlocked)
float BKE_defvert_calc_lock_relative_weight(float weight, float locked_weight, float unlocked_weight)
void BKE_defvert_normalize_ex(MDeformVert &dvert, Span< bool > subset_flags, Span< bool > lock_flags, Span< bool > soft_lock_flags)
void BKE_defvert_extract_vgroup_to_edgeweights(const MDeformVert *dvert, int defgroup, int verts_num, Span< int2 > edges, bool invert_vgroup, float *r_weights)
BMesh const char void * data
static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(Vector< CustomDataTransferLayerMap > *r_map, const int mix_mode, const float mix_factor, const float *mix_weights, const bool use_create, const bool use_delete, Object *ob_dst, const Mesh &mesh_src, Mesh &mesh_dst, const bool, const int tolayers, const bool *use_layers_src, const int num_layers_src)
void BKE_defvert_copy_index(MDeformVert *dvert_dst, int defgroup_dst, const MDeformVert *dvert_src, int defgroup_src)
bDeformGroup * BKE_defgroup_duplicate(const bDeformGroup *ingroup)
void BKE_defvert_extract_vgroup_to_loopweights(const MDeformVert *dvert, int defgroup, int verts_num, Span< int > corner_verts, bool invert_vgroup, float *r_weights)
void BKE_defvert_sync_mapped(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const int *flip_map, int flip_map_num, bool use_ensure)
void BKE_defvert_mirror_subset(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const bool *vgroup_subset, int vgroup_num, const int *flip_map, int flip_map_num)
@ DT_LAYERS_VGROUP_SRC_BONE_SELECT
@ DT_LAYERS_VGROUP_SRC_BONE_DEFORM
MDeformWeight * BKE_defvert_ensure_index(MDeformVert *dv, int defgroup)
int BKE_object_defgroup_name_index(const Object *ob, StringRef name)
bool BKE_id_supports_vertex_groups(const ID *id)
void BKE_grease_pencil_vgroup_name_update(Object *ob, const char *old_name, const char *new_name)
float BKE_defvert_array_find_weight_safe(const MDeformVert *dvert, int index, int defgroup, bool invert)
struct bDeformGroup * BKE_object_defgroup_add_name(struct Object *ob, const char *name)
void BKE_defvert_normalize(MDeformVert &dvert)
int BKE_object_defgroup_flip_index(const Object *ob, int index, bool use_default)
bool data_transfer_layersmapping_vgroups(Vector< CustomDataTransferLayerMap > *r_map, int mix_mode, float mix_factor, const float *mix_weights, bool use_create, bool use_delete, Object *ob_src, Object *ob_dst, const Mesh &mesh_src, Mesh &mesh_dst, bool use_dupref_dst, int fromlayers, int tolayers)
void BKE_object_defgroup_set_name(bDeformGroup *dg, Object *ob, const char *new_name)
ATTR_WARN_UNUSED_RESULT const size_t num
int BLI_listbase_count(const ListBase *listbase) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
_W64 unsigned int uintptr_t
static void data_transfer_layersmapping_add_item(Vector< CustomDataTransferLayerMap > *r_map, const int cddata_type, const int mix_mode, const float mix_factor, const float *mix_weights, std::variant< const void *, GVArray > data_src, std::variant< void *, bke::GSpanAttributeWriter > data_dst, const int data_src_n, const int data_dst_n, const size_t elem_size, const size_t data_size, const size_t data_offset, cd_datatransfer_interp interp, void *interp_data)
void BKE_defvert_normalize_subset(MDeformVert &dvert, Span< bool > subset_flags)
void BKE_defvert_flip(MDeformVert *dvert, const int *flip_map, int flip_map_num)
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
void BKE_defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, bool use_ensure)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
bDeformGroup * BKE_object_defgroup_new(Object *ob, StringRef name)
struct bDeformGroup * BKE_object_defgroup_add(struct Object *ob)
float data_transfer_interp_float_do(const int mix_mode, const float val_dst, const float val_src, const float mix_factor)
MINLINE float max_ff(float a, float b)
float BKE_defvert_total_selected_weight(const MDeformVert *dv, int defbase_num, const bool *defbase_sel)
void BKE_defvert_add_index_notest(MDeformVert *dv, int defgroup, float weight)
void BKE_defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
ID_Type GS(const char *name)
void BKE_defgroup_copy_list(ListBaseT< bDeformGroup > *outbase, const ListBaseT< bDeformGroup > *inbase)
static void vgroups_datatransfer_interp(const CustomDataTransferLayerMap *laymap, void *dest, const void **sources, const float *weights, const int count, const float mix_factor)
static int * object_defgroup_unlocked_flip_map_ex(const Object *ob, const bool use_default, const bool use_only_unlocked, int *r_flip_map_num)
bool * BKE_object_defgroup_subset_from_select_type(struct Object *ob, enum eVGroupSelect subset_type, int *r_defgroup_tot, int *r_subset_count)
void BKE_object_defgroup_remove(struct Object *ob, struct bDeformGroup *defgroup)
int BKE_defvert_find_shared(const MDeformVert *dvert_a, const MDeformVert *dvert_b)
ListBaseT< bDeformGroup > * BKE_id_defgroup_list_get_mutable(ID *id)
void BKE_defvert_weight_to_rgb(float r_rgb[3], float weight)
void BKE_defvert_remove_group(MDeformVert *dvert, MDeformWeight *dw)
bool BKE_id_defgroup_name_find(ID *id, StringRef name, int *r_index, bDeformGroup **r_group)
MDeformWeight * BKE_defvert_find_index(const MDeformVert *dv, int defgroup)
int * BKE_object_defgroup_flip_map_unlocked(const Object *ob, bool use_default, int *r_flip_map_num)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
float BKE_defvert_multipaint_collective_weight(const MDeformVert *dv, int defbase_num, const bool *defbase_sel, int defbase_sel_num, bool is_normalized)
size_t BLI_string_flip_side_name(char *name_dst, const char *name_src, bool strip_number, size_t name_dst_maxncpy) ATTR_NONNULL(1
void BKE_defvert_normalize_lock_map(MDeformVert &dvert, Span< bool > subset_flags, Span< bool > lock_flags)
int BKE_object_defgroup_active_index_get(const Object *ob)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_array(const int64_t array_size, const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
int vertex_group_active_index
ListBaseT< struct bDeformGroup > vertex_group_names
ListBaseT< bDeformGroup > vertex_group_names
ListBaseT< bDeformGroup > vertex_group_names
int vertex_group_active_index