Cleanup: use 'BKE_' prefix for BKE_deform API calls

- Use 'BKE_object_defgroup' prefix for object functions.

- Rename 'defvert_verify_index' to 'defvert_ensure_index'
  since this adds the group if it isn't found.
master
Campbell Barton 4 years ago
parent 1af83aa2dd
commit bba4a09b2f

@ -37,35 +37,35 @@ struct MPoly;
struct Object;
struct bDeformGroup;
struct bDeformGroup *BKE_defgroup_new(struct Object *ob, const char *name);
void defgroup_copy_list(struct ListBase *lb1, const struct ListBase *lb2);
struct bDeformGroup *defgroup_duplicate(const struct bDeformGroup *ingroup);
struct bDeformGroup *defgroup_find_name(struct Object *ob, const char *name);
int *defgroup_flip_map(struct Object *ob, int *flip_map_len, const bool use_default);
int *defgroup_flip_map_single(struct Object *ob,
int *flip_map_len,
const bool use_default,
int defgroup);
int defgroup_flip_index(struct Object *ob, int index, const bool use_default);
int defgroup_name_index(struct Object *ob, const char *name);
void defgroup_unique_name(struct bDeformGroup *dg, struct Object *ob);
struct bDeformGroup *BKE_object_defgroup_new(struct Object *ob, const char *name);
void BKE_defgroup_copy_list(struct ListBase *lb1, const struct ListBase *lb2);
struct bDeformGroup *BKE_defgroup_duplicate(const struct bDeformGroup *ingroup);
struct bDeformGroup *BKE_object_defgroup_find_name(struct Object *ob, const char *name);
int *BKE_object_defgroup_flip_map(struct Object *ob, int *flip_map_len, const bool use_default);
int *BKE_object_defgroup_flip_map_single(struct Object *ob,
int *flip_map_len,
const bool use_default,
int defgroup);
int BKE_object_defgroup_flip_index(struct Object *ob, int index, const bool use_default);
int BKE_object_defgroup_name_index(struct Object *ob, const char *name);
void BKE_object_defgroup_unique_name(struct bDeformGroup *dg, struct Object *ob);
struct MDeformWeight *defvert_find_index(const struct MDeformVert *dv, const int defgroup);
struct MDeformWeight *defvert_verify_index(struct MDeformVert *dv, const int defgroup);
void defvert_add_index_notest(struct MDeformVert *dv, int defgroup, const float weight);
void defvert_remove_group(struct MDeformVert *dvert, struct MDeformWeight *dw);
void defvert_clear(struct MDeformVert *dvert);
int defvert_find_shared(const struct MDeformVert *dvert_a, const struct MDeformVert *dvert_b);
bool defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgroup_tot);
struct MDeformWeight *BKE_defvert_find_index(const struct MDeformVert *dv, const int defgroup);
struct MDeformWeight *BKE_defvert_ensure_index(struct MDeformVert *dv, const int defgroup);
void BKE_defvert_add_index_notest(struct MDeformVert *dv, int defgroup, const float weight);
void BKE_defvert_remove_group(struct MDeformVert *dvert, struct MDeformWeight *dw);
void BKE_defvert_clear(struct MDeformVert *dvert);
int BKE_defvert_find_shared(const struct MDeformVert *dvert_a, const struct MDeformVert *dvert_b);
bool BKE_defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgroup_tot);
void BKE_defvert_array_free_elems(struct MDeformVert *dvert, int totvert);
void BKE_defvert_array_free(struct MDeformVert *dvert, int totvert);
void BKE_defvert_array_copy(struct MDeformVert *dst, const struct MDeformVert *src, int totvert);
float defvert_find_weight(const struct MDeformVert *dvert, const int defgroup);
float defvert_array_find_weight_safe(const struct MDeformVert *dvert,
const int index,
const int defgroup);
float BKE_defvert_find_weight(const struct MDeformVert *dvert, const int defgroup);
float BKE_defvert_array_find_weight_safe(const struct MDeformVert *dvert,
const int index,
const int defgroup);
float BKE_defvert_multipaint_collective_weight(const struct MDeformVert *dv,
int defbase_tot,
@ -73,45 +73,47 @@ float BKE_defvert_multipaint_collective_weight(const struct MDeformVert *dv,
int defbase_tot_sel,
bool do_autonormalize);
void defvert_copy(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src);
void defvert_copy_subset(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot);
void defvert_mirror_subset(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot,
const int *flip_map,
const int flip_map_len);
void defvert_copy_index(struct MDeformVert *dvert_dst,
const int defgroup_dst,
const struct MDeformVert *dvert_src,
const int defgroup_src);
void defvert_sync(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const bool use_verify);
void defvert_sync_mapped(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const int *flip_map,
const int flip_map_len,
const bool use_verify);
void defvert_remap(struct MDeformVert *dvert, int *map, const int map_len);
void defvert_flip(struct MDeformVert *dvert, const int *flip_map, const int flip_map_len);
void defvert_flip_merged(struct MDeformVert *dvert, const int *flip_map, const int flip_map_len);
void defvert_normalize(struct MDeformVert *dvert);
void defvert_normalize_subset(struct MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot);
void defvert_normalize_lock_single(struct MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const uint def_nr_lock);
void defvert_normalize_lock_map(struct MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const bool *lock_flags,
const int defbase_tot);
void BKE_defvert_copy(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src);
void BKE_defvert_copy_subset(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot);
void BKE_defvert_mirror_subset(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot,
const int *flip_map,
const int flip_map_len);
void BKE_defvert_copy_index(struct MDeformVert *dvert_dst,
const int defgroup_dst,
const struct MDeformVert *dvert_src,
const int defgroup_src);
void BKE_defvert_sync(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const bool use_verify);
void BKE_defvert_sync_mapped(struct MDeformVert *dvert_dst,
const struct MDeformVert *dvert_src,
const int *flip_map,
const int flip_map_len,
const bool use_verify);
void BKE_defvert_remap(struct MDeformVert *dvert, int *map, const int map_len);
void BKE_defvert_flip(struct MDeformVert *dvert, const int *flip_map, const int flip_map_len);
void BKE_defvert_flip_merged(struct MDeformVert *dvert,
const int *flip_map,
const int flip_map_len);
void BKE_defvert_normalize(struct MDeformVert *dvert);
void BKE_defvert_normalize_subset(struct MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot);
void BKE_defvert_normalize_lock_single(struct MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const uint def_nr_lock);
void BKE_defvert_normalize_lock_map(struct MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const bool *lock_flags,
const int defbase_tot);
/* Utilities to 'extract' a given vgroup into a simple float array,
* for verts, but also edges/polys/loops. */

@ -1533,7 +1533,7 @@ static void armature_vert_task(void *__restrict userdata,
}
if (armature_def_nr != -1 && dvert) {
armature_weight = defvert_find_weight(dvert, armature_def_nr);
armature_weight = BKE_defvert_find_weight(dvert, armature_def_nr);
if (data->invert_vgroup) {
armature_weight = 1.0f - armature_weight;
@ -1681,7 +1681,7 @@ void armature_deform_verts(Object *armOb,
}
/* get the def_nr for the overall armature vertex group if present */
armature_def_nr = defgroup_name_index(target, defgrp_name);
armature_def_nr = BKE_object_defgroup_name_index(target, defgrp_name);
if (ELEM(target->type, OB_MESH, OB_LATTICE, OB_GPENCIL)) {
defbase_tot = BLI_listbase_count(&target->defbase);

@ -372,7 +372,7 @@ static void contarget_get_mesh_mat(Object *ob, const char *substring, float mat[
BMEditMesh *em = BKE_editmesh_from_object(ob);
float plane[3];
float imat[3][3], tmat[3][3];
const int defgroup = defgroup_name_index(ob, substring);
const int defgroup = BKE_object_defgroup_name_index(ob, substring);
/* initialize target matrix using target matrix */
copy_m4_m4(mat, ob->obmat);
@ -396,7 +396,7 @@ static void contarget_get_mesh_mat(Object *ob, const char *substring, float mat[
/* get the average of all verts with that are in the vertex-group */
for (int i = 0; i < numVerts; i++, dv++, mv++) {
MDeformWeight *dw = defvert_find_index(dv, defgroup);
MDeformWeight *dw = BKE_defvert_find_index(dv, defgroup);
if (dw && dw->weight > 0.0f) {
float nor[3];
@ -415,7 +415,7 @@ static void contarget_get_mesh_mat(Object *ob, const char *substring, float mat[
BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
MDeformVert *dv = CustomData_bmesh_get(&em->bm->vdata, v->head.data, CD_MDEFORMVERT);
MDeformWeight *dw = defvert_find_index(dv, defgroup);
MDeformWeight *dw = BKE_defvert_find_index(dv, defgroup);
if (dw && dw->weight > 0.0f) {
madd_v3_v3fl(vec, v->co, dw->weight);
@ -481,7 +481,7 @@ static void contarget_get_lattice_mat(Object *ob, const char *substring, float m
float vec[3] = {0.0f, 0.0f, 0.0f}, tvec[3];
int grouped = 0;
int i, n;
const int defgroup = defgroup_name_index(ob, substring);
const int defgroup = BKE_object_defgroup_name_index(ob, substring);
/* initialize target matrix using target matrix */
copy_m4_m4(mat, ob->obmat);
@ -499,7 +499,7 @@ static void contarget_get_lattice_mat(Object *ob, const char *substring, float m
*/
for (i = 0; i < tot_verts; i++, dv++) {
for (n = 0; n < dv->totweight; n++) {
MDeformWeight *dw = defvert_find_index(dv, defgroup);
MDeformWeight *dw = BKE_defvert_find_index(dv, defgroup);
if (dw && dw->weight > 0.0f) {
/* copy coordinates of point to temporary vector, then add to find average */
memcpy(tvec, co ? co : bp->vec, 3 * sizeof(float));

@ -1444,7 +1444,7 @@ bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph,
if (vgroup_name) {
mdef = CustomData_get_layer(&me_dst->vdata, CD_MDEFORMVERT);
if (mdef) {
vg_idx = defgroup_name_index(ob_dst, vgroup_name);
vg_idx = BKE_object_defgroup_name_index(ob_dst, vgroup_name);
}
}

@ -52,7 +52,7 @@
#include "data_transfer_intern.h"
bDeformGroup *BKE_defgroup_new(Object *ob, const char *name)
bDeformGroup *BKE_object_defgroup_new(Object *ob, const char *name)
{
bDeformGroup *defgroup;
@ -63,26 +63,26 @@ bDeformGroup *BKE_defgroup_new(Object *ob, const char *name)
BLI_strncpy(defgroup->name, name, sizeof(defgroup->name));
BLI_addtail(&ob->defbase, defgroup);
defgroup_unique_name(defgroup, ob);
BKE_object_defgroup_unique_name(defgroup, ob);
BKE_object_batch_cache_dirty_tag(ob);
return defgroup;
}
void defgroup_copy_list(ListBase *outbase, const ListBase *inbase)
void BKE_defgroup_copy_list(ListBase *outbase, const ListBase *inbase)
{
bDeformGroup *defgroup, *defgroupn;
BLI_listbase_clear(outbase);
for (defgroup = inbase->first; defgroup; defgroup = defgroup->next) {
defgroupn = defgroup_duplicate(defgroup);
defgroupn = BKE_defgroup_duplicate(defgroup);
BLI_addtail(outbase, defgroupn);
}
}
bDeformGroup *defgroup_duplicate(const bDeformGroup *ingroup)
bDeformGroup *BKE_defgroup_duplicate(const bDeformGroup *ingroup)
{
bDeformGroup *outgroup;
@ -106,15 +106,15 @@ bDeformGroup *defgroup_duplicate(const bDeformGroup *ingroup)
* - do nothing if neither are set.
* - add destination weight if needed
*/
void defvert_copy_subset(MDeformVert *dvert_dst,
const MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot)
void BKE_defvert_copy_subset(MDeformVert *dvert_dst,
const MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot)
{
int defgroup;
for (defgroup = 0; defgroup < vgroup_tot; defgroup++) {
if (vgroup_subset[defgroup]) {
defvert_copy_index(dvert_dst, defgroup, dvert_src, defgroup);
BKE_defvert_copy_index(dvert_dst, defgroup, dvert_src, defgroup);
}
}
}
@ -124,22 +124,22 @@ void defvert_copy_subset(MDeformVert *dvert_dst,
* - do nothing if neither are set.
* - add destination weight if needed
*/
void defvert_mirror_subset(MDeformVert *dvert_dst,
const MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot,
const int *flip_map,
const int flip_map_len)
void BKE_defvert_mirror_subset(MDeformVert *dvert_dst,
const MDeformVert *dvert_src,
const bool *vgroup_subset,
const int vgroup_tot,
const int *flip_map,
const int flip_map_len)
{
int defgroup;
for (defgroup = 0; defgroup < vgroup_tot && defgroup < flip_map_len; defgroup++) {
if (vgroup_subset[defgroup] && (dvert_dst != dvert_src || flip_map[defgroup] != defgroup)) {
defvert_copy_index(dvert_dst, flip_map[defgroup], dvert_src, defgroup);
BKE_defvert_copy_index(dvert_dst, flip_map[defgroup], dvert_src, defgroup);
}
}
}
void defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
void BKE_defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
{
if (dvert_dst->totweight == dvert_src->totweight) {
if (dvert_src->totweight) {
@ -167,23 +167,23 @@ void defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
* - do nothing if neither are set.
* - add destination weight if needed.
*/
void defvert_copy_index(MDeformVert *dvert_dst,
const int defgroup_dst,
const MDeformVert *dvert_src,
const int defgroup_src)
void BKE_defvert_copy_index(MDeformVert *dvert_dst,
const int defgroup_dst,
const MDeformVert *dvert_src,
const int defgroup_src)
{
MDeformWeight *dw_src, *dw_dst;
dw_src = defvert_find_index(dvert_src, defgroup_src);
dw_src = BKE_defvert_find_index(dvert_src, defgroup_src);
if (dw_src) {
/* source is valid, verify destination */
dw_dst = defvert_verify_index(dvert_dst, defgroup_dst);
dw_dst = BKE_defvert_ensure_index(dvert_dst, defgroup_dst);
dw_dst->weight = dw_src->weight;
}
else {
/* source was NULL, assign zero, could also remove */
dw_dst = defvert_find_index(dvert_dst, defgroup_dst);
dw_dst = BKE_defvert_find_index(dvert_dst, defgroup_dst);
if (dw_dst) {
dw_dst->weight = 0.0f;
@ -195,7 +195,7 @@ void defvert_copy_index(MDeformVert *dvert_dst,
* Only sync over matching weights, don't add or remove groups
* warning, loop within loop.
*/
void defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const bool use_verify)
void BKE_defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const bool use_verify)
{
if (dvert_src->totweight && dvert_dst->totweight) {
int i;
@ -203,10 +203,10 @@ void defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const bo
for (i = 0, dw_src = dvert_src->dw; i < dvert_src->totweight; i++, dw_src++) {
MDeformWeight *dw_dst;
if (use_verify) {
dw_dst = defvert_verify_index(dvert_dst, dw_src->def_nr);
dw_dst = BKE_defvert_ensure_index(dvert_dst, dw_src->def_nr);
}
else {
dw_dst = defvert_find_index(dvert_dst, dw_src->def_nr);
dw_dst = BKE_defvert_find_index(dvert_dst, dw_src->def_nr);
}
if (dw_dst) {
@ -219,11 +219,11 @@ void defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const bo
/**
* be sure all flip_map values are valid
*/
void defvert_sync_mapped(MDeformVert *dvert_dst,
const MDeformVert *dvert_src,
const int *flip_map,
const int flip_map_len,
const bool use_verify)
void BKE_defvert_sync_mapped(MDeformVert *dvert_dst,
const MDeformVert *dvert_src,
const int *flip_map,
const int flip_map_len,
const bool use_verify)
{
if (dvert_src->totweight && dvert_dst->totweight) {
int i;
@ -232,10 +232,10 @@ void defvert_sync_mapped(MDeformVert *dvert_dst,
if (dw_src->def_nr < flip_map_len) {
MDeformWeight *dw_dst;
if (use_verify) {
dw_dst = defvert_verify_index(dvert_dst, flip_map[dw_src->def_nr]);
dw_dst = BKE_defvert_ensure_index(dvert_dst, flip_map[dw_src->def_nr]);
}
else {
dw_dst = defvert_find_index(dvert_dst, flip_map[dw_src->def_nr]);
dw_dst = BKE_defvert_find_index(dvert_dst, flip_map[dw_src->def_nr]);
}
if (dw_dst) {
@ -249,7 +249,7 @@ void defvert_sync_mapped(MDeformVert *dvert_dst,
/**
* be sure all flip_map values are valid
*/
void defvert_remap(MDeformVert *dvert, int *map, const int map_len)
void BKE_defvert_remap(MDeformVert *dvert, int *map, const int map_len)
{
MDeformWeight *dw = dvert->dw;
unsigned int i;
@ -263,9 +263,11 @@ void defvert_remap(MDeformVert *dvert, int *map, const int map_len)
}
/**
* Same as #defvert_normalize but takes a bool array.
* Same as #BKE_defvert_normalize but takes a bool array.
*/
void defvert_normalize_subset(MDeformVert *dvert, const bool *vgroup_subset, const int vgroup_tot)
void BKE_defvert_normalize_subset(MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot)
{
if (dvert->totweight == 0) {
/* nothing */
@ -301,7 +303,7 @@ void defvert_normalize_subset(MDeformVert *dvert, const bool *vgroup_subset, con
}
}
void defvert_normalize(MDeformVert *dvert)
void BKE_defvert_normalize(MDeformVert *dvert)
{
if (dvert->totweight == 0) {
/* nothing */
@ -331,12 +333,12 @@ void defvert_normalize(MDeformVert *dvert)
}
/**
* Same as defvert_normalize() if the locked vgroup is not a member of the subset
* Same as BKE_defvert_normalize() if the locked vgroup is not a member of the subset
*/
void defvert_normalize_lock_single(MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const uint def_nr_lock)
void BKE_defvert_normalize_lock_single(MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const uint def_nr_lock)
{
if (dvert->totweight == 0) {
/* nothing */
@ -388,13 +390,13 @@ void defvert_normalize_lock_single(MDeformVert *dvert,
}
/**
* Same as defvert_normalize() if no locked vgroup is a member of the subset
* Same as BKE_defvert_normalize() if no locked vgroup is a member of the subset
*/
void defvert_normalize_lock_map(MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const bool *lock_flags,
const int defbase_tot)
void BKE_defvert_normalize_lock_map(MDeformVert *dvert,
const bool *vgroup_subset,
const int vgroup_tot,
const bool *lock_flags,
const int defbase_tot)
{
if (dvert->totweight == 0) {
/* nothing */
@ -445,7 +447,7 @@ void defvert_normalize_lock_map(MDeformVert *dvert,
}
}
void defvert_flip(MDeformVert *dvert, const int *flip_map, const int flip_map_len)
void BKE_defvert_flip(MDeformVert *dvert, const int *flip_map, const int flip_map_len)
{
MDeformWeight *dw;
int i;
@ -459,7 +461,7 @@ void defvert_flip(MDeformVert *dvert, const int *flip_map, const int flip_map_le
}
}
void defvert_flip_merged(MDeformVert *dvert, const int *flip_map, const int flip_map_len)
void BKE_defvert_flip_merged(MDeformVert *dvert, const int *flip_map, const int flip_map_len)
{
MDeformWeight *dw, *dw_cpy;
float weight;
@ -470,7 +472,7 @@ void defvert_flip_merged(MDeformVert *dvert, const int *flip_map, const int flip
if (dw->def_nr < flip_map_len) {
if (flip_map[dw->def_nr] >= 0) {
/* error checkers complain of this but we'll never get NULL return */
dw_cpy = defvert_verify_index(dvert, flip_map[dw->def_nr]);
dw_cpy = BKE_defvert_ensure_index(dvert, flip_map[dw->def_nr]);
dw = &dvert->dw[i]; /* in case array got realloced */
/* distribute weights: if only one of the vertex groups was
@ -484,14 +486,14 @@ void defvert_flip_merged(MDeformVert *dvert, const int *flip_map, const int flip
}
}
bDeformGroup *defgroup_find_name(Object *ob, const char *name)
bDeformGroup *BKE_object_defgroup_find_name(Object *ob, const char *name)
{
return (name && name[0] != '\0') ?
BLI_findstring(&ob->defbase, name, offsetof(bDeformGroup, name)) :
NULL;
}
int defgroup_name_index(Object *ob, const char *name)
int BKE_object_defgroup_name_index(Object *ob, const char *name)
{
return (name && name[0] != '\0') ?
BLI_findstringindex(&ob->defbase, name, offsetof(bDeformGroup, name)) :
@ -501,7 +503,7 @@ int defgroup_name_index(Object *ob, const char *name)
/**
* \note caller must free.
*/
int *defgroup_flip_map(Object *ob, int *flip_map_len, const bool use_default)
int *BKE_object_defgroup_flip_map(Object *ob, int *flip_map_len, const bool use_default)
{
int defbase_tot = *flip_map_len = BLI_listbase_count(&ob->defbase);
@ -528,7 +530,7 @@ int *defgroup_flip_map(Object *ob, int *flip_map_len, const bool use_default)
BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
if (!STREQ(name_flip, dg->name)) {
flip_num = defgroup_name_index(ob, name_flip);
flip_num = BKE_object_defgroup_name_index(ob, name_flip);
if (flip_num >= 0) {
map[i] = flip_num;
map[flip_num] = i; /* save an extra lookup */
@ -543,7 +545,10 @@ int *defgroup_flip_map(Object *ob, int *flip_map_len, const bool use_default)
/**
* \note caller must free.
*/
int *defgroup_flip_map_single(Object *ob, int *flip_map_len, const bool use_default, int defgroup)
int *BKE_object_defgroup_flip_map_single(Object *ob,
int *flip_map_len,
const bool use_default,
int defgroup)
{
int defbase_tot = *flip_map_len = BLI_listbase_count(&ob->defbase);
@ -563,7 +568,7 @@ int *defgroup_flip_map_single(Object *ob, int *flip_map_len, const bool use_defa
BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
if (!STREQ(name_flip, dg->name)) {
flip_num = defgroup_name_index(ob, name_flip);
flip_num = BKE_object_defgroup_name_index(ob, name_flip);
if (flip_num != -1) {
map[defgroup] = flip_num;
@ -575,7 +580,7 @@ int *defgroup_flip_map_single(Object *ob, int *flip_map_len, const bool use_defa
}
}
int defgroup_flip_index(Object *ob, int index, const bool use_default)
int BKE_object_defgroup_flip_index(Object *ob, int index, const bool use_default)
{
bDeformGroup *dg = BLI_findlink(&ob->defbase, index);
int flip_index = -1;
@ -585,7 +590,7 @@ int defgroup_flip_index(Object *ob, int index, const bool use_default)
BLI_string_flip_side_name(name_flip, dg->name, false, sizeof(name_flip));
if (!STREQ(name_flip, dg->name)) {
flip_index = defgroup_name_index(ob, name_flip);
flip_index = BKE_object_defgroup_name_index(ob, name_flip);
}
}
@ -616,7 +621,7 @@ static bool defgroup_unique_check(void *arg, const char *name)
return defgroup_find_name_dupe(name, data->dg, data->ob);
}
void defgroup_unique_name(bDeformGroup *dg, Object *ob)
void BKE_object_defgroup_unique_name(bDeformGroup *dg, Object *ob)
{
struct {
Object *ob;
@ -628,9 +633,9 @@ void defgroup_unique_name(bDeformGroup *dg, Object *ob)
BLI_uniquename_cb(defgroup_unique_check, &data, DATA_("Group"), '.', dg->name, sizeof(dg->name));
}
float defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
float BKE_defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
{
MDeformWeight *dw = defvert_find_index(dvert, defgroup);
MDeformWeight *dw = BKE_defvert_find_index(dvert, defgroup);
return dw ? dw->weight : 0.0f;
}
@ -641,9 +646,9 @@ float defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
*
* This is a bit confusing, just saves some checks from the caller.
*/
float defvert_array_find_weight_safe(const struct MDeformVert *dvert,
const int index,
const int defgroup)
float BKE_defvert_array_find_weight_safe(const struct MDeformVert *dvert,
const int index,
const int defgroup)
{
/* Invalid defgroup index means the vgroup selected is invalid,
* does not exist, in that case it is OK to return 1.0
@ -657,10 +662,10 @@ float defvert_array_find_weight_safe(const struct MDeformVert *dvert,
return 0.0f;
}
return defvert_find_weight(dvert + index, defgroup);
return BKE_defvert_find_weight(dvert + index, defgroup);
}
MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
MDeformWeight *BKE_defvert_find_index(const MDeformVert *dvert, const int defgroup)
{
if (dvert && defgroup >= 0) {
MDeformWeight *dw = dvert->dw;
@ -684,7 +689,7 @@ MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
*
* \note this function is mirrored in editmesh_tools.c, for use for editvertices.
*/
MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
MDeformWeight *BKE_defvert_ensure_index(MDeformVert *dvert, const int defgroup)
{
MDeformWeight *dw_new;
@ -694,7 +699,7 @@ MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
return NULL;
}
dw_new = defvert_find_index(dvert, defgroup);
dw_new = BKE_defvert_find_index(dvert, defgroup);
if (dw_new) {
return dw_new;
}
@ -722,7 +727,7 @@ MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
*
* \warning this does NOT check for existing, assume caller already knows its not there.
*/
void defvert_add_index_notest(MDeformVert *dvert, int defgroup, const float weight)
void BKE_defvert_add_index_notest(MDeformVert *dvert, int defgroup, const float weight)
{
MDeformWeight *dw_new;
@ -750,7 +755,7 @@ void defvert_add_index_notest(MDeformVert *dvert, int defgroup, const float weig
*
* \warning This function frees the given MDeformWeight, do not use it afterward!
*/
void defvert_remove_group(MDeformVert *dvert, MDeformWeight *dw)
void BKE_defvert_remove_group(MDeformVert *dvert, MDeformWeight *dw)
{
if (dvert && dw) {
int i = dw - dvert->dw;
@ -781,7 +786,7 @@ void defvert_remove_group(MDeformVert *dvert, MDeformWeight *dw)
}
}
void defvert_clear(MDeformVert *dvert)
void BKE_defvert_clear(MDeformVert *dvert)
{
if (dvert->dw) {
MEM_freeN(dvert->dw);
@ -795,14 +800,14 @@ void defvert_clear(MDeformVert *dvert)
* \return The first group index shared by both deform verts
* or -1 if none are found.
*/
int defvert_find_shared(const MDeformVert *dvert_a, const MDeformVert *dvert_b)
int BKE_defvert_find_shared(const MDeformVert *dvert_a, const MDeformVert *dvert_b)
{
if (dvert_a->totweight && dvert_b->totweight) {
MDeformWeight *dw = dvert_a->dw;
unsigned int i;
for (i = dvert_a->totweight; i != 0; i--, dw++) {
if (dw->weight > 0.0f && defvert_find_weight(dvert_b, dw->def_nr) > 0.0f) {
if (dw->weight > 0.0f && BKE_defvert_find_weight(dvert_b, dw->def_nr) > 0.0f) {
return dw->def_nr;
}
}
@ -814,7 +819,7 @@ int defvert_find_shared(const MDeformVert *dvert_a, const MDeformVert *dvert_b)
/**
* return true if has no weights
*/
bool defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgroup_tot)
bool BKE_defvert_is_weight_zero(const struct MDeformVert *dvert, const int defgroup_tot)
{
MDeformWeight *dw = dvert->dw;
unsigned int i;
@ -931,7 +936,7 @@ void BKE_defvert_extract_vgroup_to_vertweights(MDeformVert *dvert,
int i = num_verts;
while (i--) {
const float w = defvert_find_weight(&dvert[i], defgroup);
const float w = BKE_defvert_find_weight(&dvert[i], defgroup);
r_weights[i] = invert_vgroup ? (1.0f - w) : w;
}
}
@ -1059,7 +1064,7 @@ static void vgroups_datatransfer_interp(const CustomDataTransferLayerMap *laymap
int i, j;
MDeformWeight *dw_src;
MDeformWeight *dw_dst = defvert_find_index(data_dst, idx_dst);
MDeformWeight *dw_dst = BKE_defvert_find_index(data_dst, idx_dst);
float weight_src = 0.0f, weight_dst = 0.0f;
if (sources) {
@ -1085,7 +1090,7 @@ static void vgroups_datatransfer_interp(const CustomDataTransferLayerMap *laymap
CLAMP(weight_src, 0.0f, 1.0f);
if (!dw_dst) {
defvert_add_index_notest(data_dst, idx_dst, weight_src);
BKE_defvert_add_index_notest(data_dst, idx_dst, weight_src);
}
else {
dw_dst->weight = weight_src;
@ -1181,7 +1186,7 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
for (dg_dst = ob_dst->defbase.first; dg_dst;) {
bDeformGroup *dg_dst_next = dg_dst->next;
if (defgroup_name_index(ob_src, dg_dst->name) == -1) {
if (BKE_object_defgroup_name_index(ob_src, dg_dst->name) == -1) {
BKE_object_defgroup_remove(ob_dst, dg_dst);
}
dg_dst = dg_dst_next;
@ -1194,7 +1199,7 @@ static bool data_transfer_layersmapping_vgroups_multisrc_to_dst(ListBase *r_map,
continue;
}
if ((idx_dst = defgroup_name_index(ob_dst, dg_src->name)) == -1) {
if ((idx_dst = BKE_object_defgroup_name_index(ob_dst, dg_src->name)) == -1) {
if (use_create) {
BKE_object_defgroup_add_name(ob_dst, dg_src->name);
idx_dst = ob_dst->actdef - 1;
@ -1326,7 +1331,7 @@ bool data_transfer_layersmapping_vgroups(ListBase *r_map,
}
else if (tolayers == DT_LAYERS_NAME_DST) {
bDeformGroup *dg_src = BLI_findlink(&ob_src->defbase, idx_src);
if ((idx_dst = defgroup_name_index(ob_dst, dg_src->name)) == -1) {
if ((idx_dst = BKE_object_defgroup_name_index(ob_dst, dg_src->name)) == -1) {
if (!use_create) {
return true;
}

@ -355,7 +355,7 @@ bool dynamicPaint_outputLayerExists(struct DynamicPaintSurface *surface, Object
return (CustomData_get_named_layer_index(&me->ldata, CD_MLOOPCOL, name) != -1);
}
else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
return (defgroup_name_index(ob, name) != -1);
return (BKE_object_defgroup_name_index(ob, name) != -1);
}
}
@ -2015,7 +2015,7 @@ static Mesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Object *
}
/* vertex group paint */
else if (surface->type == MOD_DPAINT_SURFACE_T_WEIGHT) {
int defgrp_index = defgroup_name_index(ob, surface->output_name);
int defgrp_index = BKE_object_defgroup_name_index(ob, surface->output_name);
MDeformVert *dvert = CustomData_get_layer(&result->vdata, CD_MDEFORMVERT);
float *weight = (float *)sData->type_data;
@ -2030,13 +2030,13 @@ static Mesh *dynamicPaint_Modifier_apply(DynamicPaintModifierData *pmd, Object *
int i;
for (i = 0; i < sData->total_points; i++) {
MDeformVert *dv = &dvert[i];
MDeformWeight *def_weight = defvert_find_index(dv, defgrp_index);
MDeformWeight *def_weight = BKE_defvert_find_index(dv, defgrp_index);
/* skip if weight value is 0 and no existing weight is found */
if ((def_weight != NULL) || (weight[i] != 0.0f)) {
/* if not found, add a weight for it */
if (def_weight == NULL) {
def_weight = defvert_verify_index(dv, defgrp_index);
def_weight = BKE_defvert_ensure_index(dv, defgrp_index);
}
/* set weight value */

@ -1938,9 +1938,9 @@ static void sample_mesh(FluidFlowSettings *mfs,
/* Apply vertex group influence if it is being used. */
if (defgrp_index != -1 && dvert) {
float weight_mask = defvert_find_weight(&dvert[v1], defgrp_index) * weights[0] +
defvert_find_weight(&dvert[v2], defgrp_index) * weights[1] +
defvert_find_weight(&dvert[v3], defgrp_index) * weights[2];
float weight_mask = BKE_defvert_find_weight(&dvert[v1], defgrp_index) * weights[0] +
BKE_defvert_find_weight(&dvert[v2], defgrp_index) * weights[1] +
BKE_defvert_find_weight(&dvert[v3], defgrp_index) * weights[2];
emission_strength *= weight_mask;
}

@ -1427,14 +1427,14 @@ void BKE_gpencil_vgroup_remove(Object *ob, bDeformGroup *defgroup)
if (gps->dvert != NULL) {
for (int i = 0; i < gps->totpoints; i++) {
dvert = &gps->dvert[i];
MDeformWeight *dw = defvert_find_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dvert, def_nr);
if (dw != NULL) {
defvert_remove_group(dvert, dw);
BKE_defvert_remove_group(dvert, dw);
}
else {
/* Reorganize weights for other groups after deleted one. */
for (int g = 0; g < totgrp; g++) {
dw = defvert_find_index(dvert, g);
dw = BKE_defvert_find_index(dvert, g);
if ((dw != NULL) && (dw->def_nr > def_nr)) {
dw->def_nr--;
}
@ -1524,8 +1524,8 @@ static void stroke_interpolate_deform_weights(
int i;
for (i = 0; i < vert->totweight; i++) {
float wl = defvert_find_weight(vl, vert->dw[i].def_nr);
float wr = defvert_find_weight(vr, vert->dw[i].def_nr);
float wl = BKE_defvert_find_weight(vl, vert->dw[i].def_nr);
float wr = BKE_defvert_find_weight(vr, vert->dw[i].def_nr);
vert->dw[i].weight = interpf(wr, wl, ratio);
}
}
@ -2835,16 +2835,16 @@ bool BKE_gpencil_close_stroke(bGPDstroke *gps)
/* Set weights. */
if (gps->dvert != NULL) {
MDeformVert *dvert1 = &gps->dvert[old_tot - 1];
MDeformWeight *dw1 = defvert_verify_index(dvert1, 0);
MDeformWeight *dw1 = BKE_defvert_ensure_index(dvert1, 0);
float weight_1 = dw1 ? dw1->weight : 0.0f;
MDeformVert *dvert2 = &gps->dvert[0];
MDeformWeight *dw2 = defvert_verify_index(dvert2, 0);
MDeformWeight *dw2 = BKE_defvert_ensure_index(dvert2, 0);
float weight_2 = dw2 ? dw2->weight : 0.0f;
MDeformVert *dvert_final = &gps->dvert[old_tot + i - 1];
dvert_final->totweight = 0;
MDeformWeight *dw = defvert_verify_index(dvert_final, 0);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert_final, 0);
if (dvert_final->dw) {
dw->weight = interpf(weight_2, weight_1, step);
}

@ -1206,7 +1206,7 @@ static float *get_weights_array(Object *ob, char *vgroup, WeightsArrayCache *cac
}
/* find the group (weak loop-in-loop) */
defgrp_index = defgroup_name_index(ob, vgroup);
defgrp_index = BKE_object_defgroup_name_index(ob, vgroup);
if (defgrp_index != -1) {
float *weights;
int i;
@ -1230,12 +1230,12 @@ static float *get_weights_array(Object *ob, char *vgroup, WeightsArrayCache *cac
const int cd_dvert_offset = CustomData_get_offset(&em->bm->vdata, CD_MDEFORMVERT);
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
dvert = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
weights[i] = defvert_find_weight(dvert, defgrp_index);
weights[i] = BKE_defvert_find_weight(dvert, defgrp_index);
}
}
else {
for (i = 0; i < totvert; i++, dvert++) {
weights[i] = defvert_find_weight(dvert, defgrp_index);
weights[i] = BKE_defvert_find_weight(dvert, defgrp_index);
}
}

@ -431,7 +431,7 @@ void calc_latt_deform(LatticeDeformData *lattice_deform_data, float co[3], float
}
if (lt->vgroup[0] && dvert) {
defgrp_index = defgroup_name_index(ob, lt->vgroup);
defgrp_index = BKE_object_defgroup_name_index(ob, lt->vgroup);
copy_v3_v3(co_prev, co);
}
@ -527,7 +527,7 @@ void calc_latt_deform(LatticeDeformData *lattice_deform_data, float co[3], float
madd_v3_v3fl(co, &latticedata[idx_u * 3], u);
if (defgrp_index != -1) {
weight_blend += (u * defvert_find_weight(dvert + idx_u, defgrp_index));
weight_blend += (u * BKE_defvert_find_weight(dvert + idx_u, defgrp_index));
}
}
}
@ -784,8 +784,9 @@ void curve_deform_verts(Object *cuOb,
if (cu->flag & CU_DEFORM_BOUNDS_OFF) {
for (a = 0, dvert_iter = dvert; a < numVerts; a++, dvert_iter++) {
const float weight = invert_vgroup ? 1.0f - defvert_find_weight(dvert_iter, defgrp_index) :
defvert_find_weight(dvert_iter, defgrp_index);
const float weight = invert_vgroup ?
1.0f - BKE_defvert_find_weight(dvert_iter, defgrp_index) :
BKE_defvert_find_weight(dvert_iter, defgrp_index);
if (weight > 0.0f) {
mul_m4_v3(cd.curvespace, vert_coords[a]);
@ -801,8 +802,9 @@ void curve_deform_verts(Object *cuOb,
INIT_MINMAX(cd.dmin, cd.dmax);
for (a = 0, dvert_iter = dvert; a < numVerts; a++, dvert_iter++) {
const float weight = invert_vgroup ? 1.0f - defvert_find_weight(dvert_iter, defgrp_index) :
defvert_find_weight(dvert_iter, defgrp_index);
const float weight = invert_vgroup ?
1.0f - BKE_defvert_find_weight(dvert_iter, defgrp_index) :
BKE_defvert_find_weight(dvert_iter, defgrp_index);
if (weight > 0.0f) {
mul_m4_v3(cd.curvespace, vert_coords[a]);
minmax_v3v3_v3(cd.dmin, cd.dmax, vert_coords[a]);
@ -810,8 +812,9 @@ void curve_deform_verts(Object *cuOb,
}
for (a = 0, dvert_iter = dvert; a < numVerts; a++, dvert_iter++) {
const float weight = invert_vgroup ? 1.0f - defvert_find_weight(dvert_iter, defgrp_index) :
defvert_find_weight(dvert_iter, defgrp_index);
const float weight = invert_vgroup ?
1.0f - BKE_defvert_find_weight(dvert_iter, defgrp_index) :
BKE_defvert_find_weight(dvert_iter, defgrp_index);
if (weight > 0.0f) {
/* already in 'cd.curvespace', prev for loop */
@ -901,8 +904,9 @@ static void lattice_deform_vert_task(void *__restrict userdata,
if (data->dvert != NULL) {
const float weight = data->invert_vgroup ?
1.0f - defvert_find_weight(data->dvert + index, data->defgrp_index) :
defvert_find_weight(data->dvert + index, data->defgrp_index);
1.0f -
BKE_defvert_find_weight(data->dvert + index, data->defgrp_index) :
BKE_defvert_find_weight(data->dvert + index, data->defgrp_index);
if (weight > 0.0f) {
calc_latt_deform(data->lattice_deform_data, data->vert_coords[index], weight * data->fac);
}
@ -935,7 +939,7 @@ void lattice_deform_verts(Object *laOb,
* We want either a Mesh/Lattice with no derived data, or derived data with deformverts.
*/
if (vgroup && vgroup[0] && target && ELEM(target->type, OB_MESH, OB_LATTICE)) {
defgrp_index = defgroup_name_index(target, vgroup);
defgrp_index = BKE_object_defgroup_name_index(target, vgroup);
if (defgrp_index != -1) {
/* if there's derived data without deformverts, don't use vgroups */

@ -384,16 +384,16 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis(MirrorModifierData *mmd,
maxVerts;
int *flip_map = NULL, flip_map_len = 0;
flip_map = defgroup_flip_map(ob, &flip_map_len, false);
flip_map = BKE_object_defgroup_flip_map(ob, &flip_map_len, false);
if (flip_map) {
for (i = 0; i < maxVerts; dvert++, i++) {
/* merged vertices get both groups, others get flipped */
if (do_vtargetmap && (vtargetmap[i] != -1)) {
defvert_flip_merged(dvert, flip_map, flip_map_len);
BKE_defvert_flip_merged(dvert, flip_map, flip_map_len);
}
else {
defvert_flip(dvert, flip_map, flip_map_len);
BKE_defvert_flip(dvert, flip_map, flip_map_len);
}
}

@ -803,7 +803,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
if (dw->def_nr >= INT_MAX) {
PRINT_ERR("\tVertex deform %u, has invalid group %u", i, dw->def_nr);
if (do_fixes) {
defvert_remove_group(dv, dw);
BKE_defvert_remove_group(dv, dw);
fix_flag.verts_weight = true;
if (dv->dw) {

@ -233,7 +233,7 @@ static void object_copy_data(Main *bmain, ID *id_dst, const ID *id_src, const in
BKE_pose_rebuild(bmain, ob_dst, ob_dst->data, do_pose_id_user);
}
}
defgroup_copy_list(&ob_dst->defbase, &ob_src->defbase);
BKE_defgroup_copy_list(&ob_dst->defbase, &ob_src->defbase);
BKE_object_facemap_copy_list(&ob_dst->fmaps, &ob_src->fmaps);
BKE_constraints_copy_ex(&ob_dst->constraints, &ob_src->constraints, flag_subdata, true);
@ -1960,7 +1960,7 @@ void BKE_object_make_proxy(Main *bmain, Object *ob, Object *target, Object *cob)
id_us_plus((ID *)ob->data); /* ensures lib data becomes LIB_TAG_EXTERN */
/* copy vertex groups */
defgroup_copy_list(&ob->defbase, &target->defbase);
BKE_defgroup_copy_list(&ob->defbase, &target->defbase);
/* copy material and index information */
ob->actcol = ob->totcol = 0;

@ -120,7 +120,7 @@ bDeformGroup *BKE_object_defgroup_add_name(Object *ob, const char *name)
return NULL;
}
defgroup = BKE_defgroup_new(ob, name);
defgroup = BKE_object_defgroup_new(ob, name);
ob->actdef = BLI_listbase_count(&ob->defbase);
@ -186,8 +186,8 @@ bool BKE_object_defgroup_clear(Object *ob, bDeformGroup *dg, const bool use_sele
dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
if (dv && dv->dw && (!use_selection || BM_elem_flag_test(eve, BM_ELEM_SELECT))) {
MDeformWeight *dw = defvert_find_index(dv, def_nr);
defvert_remove_group(dv, dw); /* dw can be NULL */
MDeformWeight *dw = BKE_defvert_find_index(dv, def_nr);
BKE_defvert_remove_group(dv, dw); /* dw can be NULL */
changed = true;
}
}
@ -203,8 +203,8 @@ bool BKE_object_defgroup_clear(Object *ob, bDeformGroup *dg, const bool use_sele
for (i = 0; i < me->totvert; i++, mv++, dv++) {
if (dv->dw && (!use_selection || (mv->flag & SELECT))) {
MDeformWeight *dw = defvert_find_index(dv, def_nr);
defvert_remove_group(dv, dw); /* dw can be NULL */
MDeformWeight *dw = BKE_defvert_find_index(dv, def_nr);
BKE_defvert_remove_group(dv, dw); /* dw can be NULL */
changed = true;
}
}
@ -224,8 +224,8 @@ bool BKE_object_defgroup_clear(Object *ob, bDeformGroup *dg, const bool use_sele
dv = &lt->dvert[i];
dw = defvert_find_index(dv, def_nr);
defvert_remove_group(dv, dw); /* dw can be NULL */
dw = BKE_defvert_find_index(dv, def_nr);
BKE_defvert_remove_group(dv, dw); /* dw can be NULL */
changed = true;
}
}
@ -324,8 +324,8 @@ static void object_defgroup_remove_object_mode(Object *ob, bDeformGroup *dg)
for (i = 0, dv = dvert_array; i < dvert_tot; i++, dv++) {
MDeformWeight *dw;
dw = defvert_find_index(dv, def_nr);
defvert_remove_group(dv, dw); /* dw can be NULL */
dw = BKE_defvert_find_index(dv, def_nr);
BKE_defvert_remove_group(dv, dw); /* dw can be NULL */
/* inline, make into a function if anything else needs to do this */
for (j = 0; j < dv->totweight; j++) {
@ -488,7 +488,7 @@ int *BKE_object_defgroup_index_map_create(Object *ob_src, Object *ob_dst, int *r
int i;
for (dg_src = ob_src->defbase.first, i = 0; dg_src; dg_src = dg_src->next, i++) {
vgroup_index_map[i] = defgroup_name_index(ob_dst, dg_src->name);
vgroup_index_map[i] = BKE_object_defgroup_name_index(ob_dst, dg_src->name);
is_vgroup_remap_needed = is_vgroup_remap_needed || (vgroup_index_map[i] != i);
}
@ -714,7 +714,8 @@ void BKE_object_defgroup_mirror_selection(struct Object *ob,
char name_flip[MAXBONENAME];
BLI_string_flip_side_name(name_flip, defgroup->name, false, sizeof(name_flip));
i_mirr = STREQ(name_flip, defgroup->name) ? i : defgroup_name_index(ob, name_flip);
i_mirr = STREQ(name_flip, defgroup->name) ? i :
BKE_object_defgroup_name_index(ob, name_flip);
if ((i_mirr >= 0 && i_mirr < defbase_tot) && (dg_flags_sel[i_mirr] == false)) {
dg_flags_sel[i_mirr] = true;

@ -2223,12 +2223,12 @@ float *psys_cache_vgroup(Mesh *mesh, ParticleSystem *psys, int vgroup)
vg = MEM_callocN(sizeof(float) * totvert, "vg_cache");
if (psys->vg_neg & (1 << vgroup)) {
for (i = 0; i < totvert; i++) {
vg[i] = 1.0f - defvert_find_weight(&dvert[i], psys->vgroup[vgroup] - 1);
vg[i] = 1.0f - BKE_defvert_find_weight(&dvert[i], psys->vgroup[vgroup] - 1);
}
}
else {
for (i = 0; i < totvert; i++) {
vg[i] = defvert_find_weight(&dvert[i], psys->vgroup[vgroup] - 1);
vg[i] = BKE_defvert_find_weight(&dvert[i], psys->vgroup[vgroup] - 1);
}
}
}

@ -355,7 +355,7 @@ static void shrinkwrap_calc_nearest_vertex_cb_ex(void *__restrict userdata,
float *co = calc->vertexCos[i];
float tmp_co[3];
float weight = defvert_array_find_weight_safe(calc->dvert, i, calc->vgroup);
float weight = BKE_defvert_array_find_weight_safe(calc->dvert, i, calc->vgroup);
if (calc->invert_vgroup) {
weight = 1.0f - weight;
@ -527,7 +527,7 @@ static void shrinkwrap_calc_normal_projection_cb_ex(void *__restrict userdata,
const float proj_limit_squared = calc->smd->projLimit * calc->smd->projLimit;
float *co = calc->vertexCos[i];
float tmp_co[3], tmp_no[3];
float weight = defvert_array_find_weight_safe(calc->dvert, i, calc->vgroup);
float weight = BKE_defvert_array_find_weight_safe(calc->dvert, i, calc->vgroup);
if (calc->invert_vgroup) {
weight = 1.0f - weight;
@ -1130,7 +1130,7 @@ static void shrinkwrap_calc_nearest_surface_point_cb_ex(void *__restrict userdat
float *co = calc->vertexCos[i];
float tmp_co[3];
float weight = defvert_array_find_weight_safe(calc->dvert, i, calc->vgroup);
float weight = BKE_defvert_array_find_weight_safe(calc->dvert, i, calc->vgroup);
if (calc->invert_vgroup) {
weight = 1.0f - weight;

@ -2700,8 +2700,9 @@ static void mesh_to_softbody(Scene *scene, Object *ob)
bp = sb->bpoint;
defgroup_index = me->dvert ? (sb->vertgroup - 1) : -1;
defgroup_index_mass = me->dvert ? defgroup_name_index(ob, sb->namedVG_Mass) : -1;
defgroup_index_spring = me->dvert ? defgroup_name_index(ob, sb->namedVG_Spring_K) : -1;
defgroup_index_mass = me->dvert ? BKE_object_defgroup_name_index(ob, sb->namedVG_Mass) : -1;
defgroup_index_spring = me->dvert ? BKE_object_defgroup_name_index(ob, sb->namedVG_Spring_K) :
-1;
for (a = 0; a < me->totvert; a++, bp++) {
/* get scalar values needed *per vertex* from vertex group functions,
@ -2714,7 +2715,7 @@ static void mesh_to_softbody(Scene *scene, Object *ob)
BLI_assert(bp->goal == sb->defgoal);
}
if ((ob->softflag & OB_SB_GOAL) && (defgroup_index != -1)) {
bp->goal *= defvert_find_weight(&me->dvert[a], defgroup_index);
bp->goal *= BKE_defvert_find_weight(&me->dvert[a], defgroup_index);
}
/* to proof the concept
@ -2722,11 +2723,11 @@ static void mesh_to_softbody(Scene *scene, Object *ob)
*/
if (defgroup_index_mass != -1) {
bp->mass *= defvert_find_weight(&me->dvert[a], defgroup_index_mass);
bp->mass *= BKE_defvert_find_weight(&me->dvert[a], defgroup_index_mass);
}
if (defgroup_index_spring != -1) {
bp->springweight *= defvert_find_weight(&me->dvert[a], defgroup_index_spring);
bp->springweight *= BKE_defvert_find_weight(&me->dvert[a], defgroup_index_spring);
}
}
@ -2929,8 +2930,9 @@ static void lattice_to_softbody(Scene *scene, Object *ob)
bp = sb->bpoint;
defgroup_index = lt->dvert ? (sb->vertgroup - 1) : -1;
defgroup_index_mass = lt->dvert ? defgroup_name_index(ob, sb->namedVG_Mass) : -1;
defgroup_index_spring = lt->dvert ? defgroup_name_index(ob, sb->namedVG_Spring_K) : -1;
defgroup_index_mass = lt->dvert ? BKE_object_defgroup_name_index(ob, sb->namedVG_Mass) : -1;
defgroup_index_spring = lt->dvert ? BKE_object_defgroup_name_index(ob, sb->namedVG_Spring_K) :
-1;
/* same code used as for mesh vertices */
for (a = 0; a < totvert; a++, bp++, bpnt++) {
@ -2940,18 +2942,18 @@ static void lattice_to_softbody(Scene *scene, Object *ob)
}
if ((ob->softflag & OB_SB_GOAL) && (defgroup_index != -1)) {
bp->goal *= defvert_find_weight(&lt->dvert[a], defgroup_index);
bp->goal *= BKE_defvert_find_weight(&lt->dvert[a], defgroup_index);
}
else {
bp->goal *= bpnt->weight;
}
if (defgroup_index_mass != -1) {
bp->mass *= defvert_find_weight(&lt->dvert[a], defgroup_index_mass);
bp->mass *= BKE_defvert_find_weight(&lt->dvert[a], defgroup_index_mass);
}
if (defgroup_index_spring != -1) {
bp->springweight *= defvert_find_weight(&lt->dvert[a], defgroup_index_spring);
bp->springweight *= BKE_defvert_find_weight(&lt->dvert[a], defgroup_index_spring);
}
}

@ -1295,7 +1295,7 @@ void blo_do_versions_pre250(FileData *fd, Library *lib, Main *bmain)
}
}
if (ob->soft && ob->soft->vertgroup == 0) {
bDeformGroup *locGroup = defgroup_find_name(ob, "SOFTGOAL");
bDeformGroup *locGroup = BKE_object_defgroup_find_name(ob, "SOFTGOAL");
if (locGroup) {
/* retrieve index for that group */
ob->soft->vertgroup = 1 + BLI_findindex(&ob->defbase, locGroup);
@ -1882,7 +1882,7 @@ void blo_do_versions_pre250(FileData *fd, Library *lib, Main *bmain)
for (curdef = ob->defbase.first; curdef; curdef = curdef->next) {
/* replace an empty-string name with unique name */
if (curdef->name[0] == '\0') {
defgroup_unique_name(curdef, ob);
BKE_object_defgroup_unique_name(curdef, ob);
}
}

@ -5876,7 +5876,7 @@ static BevVert *bevel_vert_construct(BMesh *bm, BevelParams *bp, BMVert *v)
if (bp->vertex_only) {
/* If weighted, modify offset by weight. */
if (bp->dvert != NULL && bp->vertex_group != -1) {
weight = defvert_find_weight(bp->dvert + BM_elem_index_get(v), bp->vertex_group);
weight = BKE_defvert_find_weight(bp->dvert + BM_elem_index_get(v), bp->vertex_group);
bv->offset *= weight;
}
else if (bp->use_weights) {

@ -270,7 +270,7 @@ void BM_mesh_wireframe(BMesh *bm,
if (cd_dvert_offset != -1) {
MDeformVert *dvert = BM_ELEM_CD_GET_VOID_P(v_src, cd_dvert_offset);
float defgrp_fac = defvert_find_weight(dvert, defgrp_index);
float defgrp_fac = BKE_defvert_find_weight(dvert, defgrp_index);
if (defgrp_invert) {
defgrp_fac = 1.0f - defgrp_fac;

@ -893,7 +893,7 @@ bool ArmatureImporter::write_skin_controller_data(const COLLADAFW::SkinControlle
* there's no info to which object this should be long so we associate it with
* skin controller data UID. */
/* don't forget to call defgroup_unique_name before we copy */
/* don't forget to call BKE_object_defgroup_unique_name before we copy */
/* controller data uid -> [armature] -> joint data,
* [mesh object] */

@ -772,8 +772,9 @@ void gpencil_get_edit_geom(struct GpencilBatchCacheElem *be,
for (int i = 0; i < gps->totpoints; i++, pt++) {
/* weight paint */
if (is_weight_paint) {
float weight = (dvert && dvert->dw && (vgindex > -1)) ? defvert_find_weight(dvert, vgindex) :
0.0f;
float weight = (dvert && dvert->dw && (vgindex > -1)) ?
BKE_defvert_find_weight(dvert, vgindex) :
0.0f;
float hue = 2.0f * (1.0f - weight) / 3.0f;
hsv_to_rgb(hue, 1.0f, 1.0f, &selectColor[0], &selectColor[1], &selectColor[2]);
selectColor[3] = 1.0f;
@ -858,8 +859,9 @@ void gpencil_get_edlin_geom(struct GpencilBatchCacheElem *be,
for (int i = 0; i < gps->totpoints; i++, pt++) {
/* weight paint */
if (is_weight_paint) {
float weight = (dvert && dvert->dw && (vgindex > -1)) ? defvert_find_weight(dvert, vgindex) :
0.0f;
float weight = (dvert && dvert->dw && (vgindex > -1)) ?
BKE_defvert_find_weight(dvert, vgindex) :
0.0f;
float hue = 2.0f * (1.0f - weight) / 3.0f;
hsv_to_rgb(hue, 1.0f, 1.0f, &selectColor[0], &selectColor[1], &selectColor[2]);
selectColor[3] = 1.0f;

@ -2420,7 +2420,7 @@ static float evaluate_vertex_weight(const MDeformVert *dvert, const DRW_MeshWeig
}
else {
/* default, non tricky behavior */
input = defvert_find_weight(dvert, wstate->defgroup_active);
input = BKE_defvert_find_weight(dvert, wstate->defgroup_active);
if (input == 0.0f) {
switch (wstate->alert_mode) {
@ -2428,7 +2428,7 @@ static float evaluate_vertex_weight(const MDeformVert *dvert, const DRW_MeshWeig
return -1.0f;
break;
case OB_DRAW_GROUPUSER_ALL:
if (defvert_is_weight_zero(dvert, wstate->defgroup_len)) {
if (BKE_defvert_is_weight_zero(dvert, wstate->defgroup_len)) {
return -1.0f;
}
break;

@ -366,7 +366,7 @@ static GPUVertBuf *lattice_batch_cache_get_pos(LatticeRenderData *rdata,
if (use_weight) {
const float no_active_weight = 666.0f;
float weight = (actdef > -1) ? defvert_find_weight(rdata->dvert + i, actdef) :
float weight = (actdef > -1) ? BKE_defvert_find_weight(rdata->dvert + i, actdef) :
no_active_weight;
GPU_vertbuf_attr_set(cache->pos, attr_id.col, i, &weight);
}

@ -256,7 +256,7 @@ void ED_armature_bone_rename(Main *bmain,
}
if (modifiers_usesArmature(ob, arm)) {
bDeformGroup *dg = defgroup_find_name(ob, oldname);
bDeformGroup *dg = BKE_object_defgroup_find_name(ob, oldname);
if (dg) {
BLI_strncpy(dg->name, newname, MAXBONENAME);
}
@ -313,7 +313,7 @@ void ED_armature_bone_rename(Main *bmain,
case eGpencilModifierType_Armature: {
ArmatureGpencilModifierData *mmd = (ArmatureGpencilModifierData *)gp_md;
if (mmd->object && mmd->object->data == arm) {
bDeformGroup *dg = defgroup_find_name(ob, oldname);
bDeformGroup *dg = BKE_object_defgroup_find_name(ob, oldname);
if (dg) {
BLI_strncpy(dg->name, newname, MAXBONENAME);
}

@ -121,7 +121,7 @@ static int vgroup_add_unique_bone_cb(Object *ob, Bone *bone, void *UNUSED(ptr))
* If such a vertex group already exist the routine exits.
*/
if (!(bone->flag & BONE_NO_DEFORM)) {
if (!defgroup_find_name(ob, bone->name)) {
if (!BKE_object_defgroup_find_name(ob, bone->name)) {
BKE_object_defgroup_add_name(ob, bone->name);
return 1;
}
@ -175,7 +175,7 @@ static int dgroup_skinnable_cb(Object *ob, Bone *bone, void *datap)
}
if (!data->is_weight_paint || ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED))) {
if (!(defgroup = defgroup_find_name(ob, bone->name))) {
if (!(defgroup = BKE_object_defgroup_find_name(ob, bone->name))) {
defgroup = BKE_object_defgroup_add_name(ob, bone->name);
}
else if (defgroup->flag & DG_LOCK_WEIGHT) {
@ -401,7 +401,7 @@ static void add_verts_to_dgroups(ReportList *reports,
char name_flip[MAXBONENAME];
BLI_string_flip_side_name(name_flip, dgroup->name, false, sizeof(name_flip));
dgroupflip[j] = defgroup_find_name(ob, name_flip);
dgroupflip[j] = BKE_object_defgroup_find_name(ob, name_flip);
}
}

@ -168,7 +168,7 @@ static int vgroup_add_unique_bone_cb(Object *ob, Bone *bone, void *UNUSED(ptr))
* If such a vertex group already exist the routine exits.
*/
if (!(bone->flag & BONE_NO_DEFORM)) {
if (!defgroup_find_name(ob, bone->name)) {
if (!BKE_object_defgroup_find_name(ob, bone->name)) {
BKE_object_defgroup_add_name(ob, bone->name);
return 1;
}
@ -221,7 +221,7 @@ static int dgroup_skinnable_cb(Object *ob, Bone *bone, void *datap)
}
if (arm->layer & bone->layer) {
if (!(defgroup = defgroup_find_name(ob, bone->name))) {
if (!(defgroup = BKE_object_defgroup_find_name(ob, bone->name))) {
defgroup = BKE_object_defgroup_add_name(ob, bone->name);
}
else if (defgroup->flag & DG_LOCK_WEIGHT) {
@ -418,7 +418,7 @@ static void gpencil_add_verts_to_dgroups(
}
/* assign weight */
MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, def_nr);
if (dw) {
dw->weight = weight;
}

@ -988,7 +988,7 @@ static bool gp_brush_weight_apply(tGP_BrushEditData *gso,
}
}
/* get current weight */
MDeformWeight *dw = defvert_verify_index(dvert, gso->vrgroup);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, gso->vrgroup);
float curweight = dw ? dw->weight : 0.0f;
if (gp_brush_invert_check(gso)) {

@ -1846,12 +1846,12 @@ static int gpencil_vertex_group_invert_exec(bContext *C, wmOperator *op)
for (int i = 0; i < gps->totpoints; i++) {
dvert = &gps->dvert[i];
MDeformWeight *dw = defvert_find_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dvert, def_nr);
if (dw == NULL) {
defvert_add_index_notest(dvert, def_nr, 1.0f);
BKE_defvert_add_index_notest(dvert, def_nr, 1.0f);
}
else if (dw->weight == 1.0f) {
defvert_remove_group(dvert, dw);
BKE_defvert_remove_group(dvert, dw);
}
else {
dw->weight = 1.0f - dw->weight;
@ -1938,8 +1938,8 @@ static int gpencil_vertex_group_smooth_exec(bContext *C, wmOperator *op)
ptc = &gps->points[i];
}
float wa = defvert_find_weight(dverta, def_nr);
float wb = defvert_find_weight(dvertb, def_nr);
float wa = BKE_defvert_find_weight(dverta, def_nr);
float wb = BKE_defvert_find_weight(dvertb, def_nr);
/* the optimal value is the corresponding to the interpolation of the weight
* at the distance of point b
@ -1947,7 +1947,7 @@ static int gpencil_vertex_group_smooth_exec(bContext *C, wmOperator *op)
const float opfac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
const float optimal = interpf(wa, wb, opfac);
/* Based on influence factor, blend between original and optimal */
MDeformWeight *dw = defvert_verify_index(dvertb, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvertb, def_nr);
if (dw) {
dw->weight = interpf(wb, optimal, fac);
CLAMP(dw->weight, 0.0, 1.0f);
@ -2016,7 +2016,7 @@ static int gpencil_vertex_group_normalize_exec(bContext *C, wmOperator *op)
float maxvalue = 0.0f;
for (int i = 0; i < gps->totpoints; i++) {
dvert = &gps->dvert[i];
dw = defvert_find_index(dvert, def_nr);
dw = BKE_defvert_find_index(dvert, def_nr);
if ((dw != NULL) && (dw->weight > maxvalue)) {
maxvalue = dw->weight;
}
@ -2026,7 +2026,7 @@ static int gpencil_vertex_group_normalize_exec(bContext *C, wmOperator *op)
if (maxvalue > 0.0f) {
for (int i = 0; i < gps->totpoints; i++) {
dvert = &gps->dvert[i];
dw = defvert_find_index(dvert, def_nr);
dw = BKE_defvert_find_index(dvert, def_nr);
if (dw != NULL) {
dw->weight = dw->weight / maxvalue;
}
@ -2102,7 +2102,7 @@ static int gpencil_vertex_group_normalize_all_exec(bContext *C, wmOperator *op)
continue;
}
dw = defvert_find_index(dvert, v);
dw = BKE_defvert_find_index(dvert, v);
if (dw != NULL) {
tot_values[i] += dw->weight;
}
@ -2128,7 +2128,7 @@ static int gpencil_vertex_group_normalize_all_exec(bContext *C, wmOperator *op)
continue;
}
dw = defvert_find_index(dvert, v);
dw = BKE_defvert_find_index(dvert, v);
if (dw != NULL) {
dw->weight = dw->weight / tot_values[i];
}
@ -2320,7 +2320,7 @@ int ED_gpencil_join_objects_exec(bContext *C, wmOperator *op)
for (bDeformGroup *dg = ob_iter->defbase.first; dg; dg = dg->next) {
bDeformGroup *vgroup = MEM_dupallocN(dg);
int idx = BLI_listbase_count(&ob_active->defbase);
defgroup_unique_name(vgroup, ob_active);
BKE_object_defgroup_unique_name(vgroup, ob_active);
BLI_addtail(&ob_active->defbase, vgroup);
/* update vertex groups in strokes in original data */
for (bGPDlayer *gpl_src = gpd->layers.first; gpl_src; gpl_src = gpl_src->next) {

@ -1092,7 +1092,7 @@ static void gpencil_stroke_from_buffer(tGPDfill *tgpf)
pt->time = 0.0f;
if ((ts->gpencil_flags & GP_TOOL_FLAG_CREATE_WEIGHTS) && (have_weight)) {
MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, def_nr);
if (dw) {
dw->weight = ts->vgroup_weight;
}

@ -1049,7 +1049,7 @@ static short gp_stroke_addpoint(
if ((ts->gpencil_flags & GP_TOOL_FLAG_CREATE_WEIGHTS) && (have_weight)) {
BKE_gpencil_dvert_ensure(gps);
MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, def_nr);
if (dw) {
dw->weight = ts->vgroup_weight;
}
@ -1202,7 +1202,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
if ((ts->gpencil_flags & GP_TOOL_FLAG_CREATE_WEIGHTS) && (have_weight)) {
BKE_gpencil_dvert_ensure(gps);
MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, def_nr);
if (dw) {
dw->weight = ts->vgroup_weight;
}
@ -1231,7 +1231,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
if ((ts->gpencil_flags & GP_TOOL_FLAG_CREATE_WEIGHTS) && (have_weight)) {
BKE_gpencil_dvert_ensure(gps);
MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, def_nr);
if (dw) {
dw->weight = ts->vgroup_weight;
}
@ -1279,7 +1279,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
if ((ts->gpencil_flags & GP_TOOL_FLAG_CREATE_WEIGHTS) && (have_weight)) {
BKE_gpencil_dvert_ensure(gps);
MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, def_nr);
if (dw) {
dw->weight = ts->vgroup_weight;
}
@ -1479,7 +1479,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
BKE_gpencil_dvert_ensure(gps);
for (i = 0; i < gps->totpoints; i++) {
MDeformVert *ve = &gps->dvert[i];
MDeformWeight *dw = defvert_verify_index(ve, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(ve, def_nr);
if (dw) {
dw->weight = ts->vgroup_weight;
}

@ -1334,7 +1334,7 @@ static void gpencil_primitive_interaction_end(bContext *C,
BKE_gpencil_dvert_ensure(gps);
for (int i = 0; i < gps->totpoints; i++) {
MDeformVert *ve = &gps->dvert[i];
MDeformWeight *dw = defvert_verify_index(ve, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(ve, def_nr);
if (dw) {
dw->weight = ts->vgroup_weight;
}

@ -1489,7 +1489,7 @@ void ED_gpencil_vgroup_assign(bContext *C, Object *ob, float weight)
bGPDspoint *pt = &gps->points[i];
MDeformVert *dvert = &gps->dvert[i];
if (pt->flag & GP_SPOINT_SELECT) {
MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dvert, def_nr);
if (dw) {
dw->weight = weight;
}
@ -1543,9 +1543,9 @@ void ED_gpencil_vgroup_remove(bContext *C, Object *ob)
MDeformVert *dvert = &gps->dvert[i];
if ((pt->flag & GP_SPOINT_SELECT) && (dvert->totweight > 0)) {
MDeformWeight *dw = defvert_find_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dvert, def_nr);
if (dw != NULL) {
defvert_remove_group(dvert, dw);
BKE_defvert_remove_group(dvert, dw);
}
}
}
@ -1595,7 +1595,7 @@ void ED_gpencil_vgroup_select(bContext *C, Object *ob)
}
MDeformVert *dvert = &gps->dvert[i];
if (defvert_find_index(dvert, def_nr) != NULL) {
if (BKE_defvert_find_index(dvert, def_nr) != NULL) {
pt->flag |= GP_SPOINT_SELECT;
gps->flag |= GP_STROKE_SELECT;
}
@ -1646,7 +1646,7 @@ void ED_gpencil_vgroup_deselect(bContext *C, Object *ob)
}
MDeformVert *dvert = &gps->dvert[i];
if (defvert_find_index(dvert, def_nr) != NULL) {
if (BKE_defvert_find_index(dvert, def_nr) != NULL) {
pt->flag &= ~GP_SPOINT_SELECT;
}
}

@ -5250,7 +5250,7 @@ static int edbm_decimate_exec(bContext *C, wmOperator *op)
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) {
if (use_vertex_group) {
const MDeformVert *dv = BM_ELEM_CD_GET_VOID_P(v, cd_dvert_offset);
weight = defvert_find_weight(dv, defbase_act);
weight = BKE_defvert_find_weight(dv, defbase_act);
if (invert_vertex_group) {
weight = 1.0f - weight;
}

@ -429,7 +429,7 @@ int join_mesh_exec(bContext *C, wmOperator *op)
/* Join this object's vertex groups to the base one's */
for (dg = ob_iter->defbase.first; dg; dg = dg->next) {
/* See if this group exists in the object (if it doesn't, add it to the end) */
if (!defgroup_find_name(ob, dg->name)) {
if (!BKE_object_defgroup_find_name(ob, dg->name)) {
odg = MEM_mallocN(sizeof(bDeformGroup), "join deformGroup");
memcpy(odg, dg, sizeof(bDeformGroup));
BLI_addtail(&ob->defbase, odg);

@ -123,7 +123,7 @@ static bool return_editmesh_vgroup(Object *obedit, BMEditMesh *em, char *r_name,
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
dvert = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
if (defvert_find_weight(dvert, defgrp_index) > 0.0f) {
if (BKE_defvert_find_weight(dvert, defgrp_index) > 0.0f) {
add_v3_v3(r_cent, eve->co);
totvert++;
}

@ -105,7 +105,7 @@ bool ED_vgroup_sync_from_pose(Object *ob)
if (armobj && (armobj->mode & OB_MODE_POSE)) {
struct bArmature *arm = armobj->data;
if (arm->act_bone) {
int def_num = defgroup_name_index(ob, arm->act_bone->name);
int def_num = BKE_object_defgroup_name_index(ob, arm->act_bone->name);
if (def_num != -1) {
ob->actdef = def_num + 1;
return true;
@ -130,7 +130,7 @@ void ED_vgroup_data_clamp_range(ID *id, const int total)
int j;
for (j = 0; j < dv->totweight; j++) {
if (dv->dw[j].def_nr >= total) {
defvert_remove_group(dv, &dv->dw[j]);
BKE_defvert_remove_group(dv, &dv->dw[j]);
j--;
}
}
@ -271,7 +271,7 @@ void ED_vgroup_parray_mirror_sync(Object *ob,
}
int flip_map_len;
const int *flip_map = defgroup_flip_map(ob, &flip_map_len, true);
const int *flip_map = BKE_object_defgroup_flip_map(ob, &flip_map_len, true);
for (int i_src = 0; i_src < dvert_tot; i_src++) {
if (dvert_array[i_src] != NULL) {
@ -282,7 +282,8 @@ void ED_vgroup_parray_mirror_sync(Object *ob,
const MDeformVert *dv_src = dvert_array[i_src];
MDeformVert *dv_dst = dvert_array_all[i_dst];
defvert_mirror_subset(dv_dst, dv_src, vgroup_validmap, vgroup_tot, flip_map, flip_map_len);
BKE_defvert_mirror_subset(
dv_dst, dv_src, vgroup_validmap, vgroup_tot, flip_map, flip_map_len);
dvert_array[i_dst] = dvert_array_all[i_dst];
}
@ -359,7 +360,7 @@ void ED_vgroup_parray_remove_zero(MDeformVert **dvert_array,
dw = dv->dw + j;
if ((dw->def_nr < vgroup_tot) && vgroup_validmap[dw->def_nr]) {
if (dw->weight <= epsilon) {
defvert_remove_group(dv, dw);
BKE_defvert_remove_group(dv, dw);
}
}
}
@ -461,7 +462,7 @@ void ED_vgroup_parray_to_weight_array(const MDeformVert **dvert_array,
for (i = 0; i < dvert_tot; i++) {
const MDeformVert *dv = dvert_array[i];
dvert_weights[i] = dv ? defvert_find_weight(dv, def_nr) : 0.0f;
dvert_weights[i] = dv ? BKE_defvert_find_weight(dv, def_nr) : 0.0f;
}
}
@ -477,15 +478,15 @@ void ED_vgroup_parray_from_weight_array(MDeformVert **dvert_array,
MDeformVert *dv = dvert_array[i];
if (dv) {
if (dvert_weights[i] > 0.0f) {
MDeformWeight *dw = defvert_verify_index(dv, def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dv, def_nr);
BLI_assert(IN_RANGE_INCL(dvert_weights[i], 0.0f, 1.0f));
dw->weight = dvert_weights[i];
}
else {
MDeformWeight *dw = defvert_find_index(dv, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dv, def_nr);
if (dw) {
if (remove_zero) {
defvert_remove_group(dv, dw);
BKE_defvert_remove_group(dv, dw);
}
else {
dw->weight = 0.0f;
@ -505,15 +506,16 @@ static void mesh_defvert_mirror_update_internal(Object *ob,
if (def_nr == -1) {
/* all vgroups, add groups where needed */
int flip_map_len;
int *flip_map = defgroup_flip_map(ob, &flip_map_len, true);
defvert_sync_mapped(dvert_dst, dvert_src, flip_map, flip_map_len, true);
int *flip_map = BKE_object_defgroup_flip_map(ob, &flip_map_len, true);
BKE_defvert_sync_mapped(dvert_dst, dvert_src, flip_map, flip_map_len, true);
MEM_freeN(flip_map);
}
else {
/* single vgroup */
MDeformWeight *dw = defvert_verify_index(dvert_dst, defgroup_flip_index(ob, def_nr, 1));
MDeformWeight *dw = BKE_defvert_ensure_index(dvert_dst,
BKE_object_defgroup_flip_index(ob, def_nr, 1));
if (dw) {
dw->weight = defvert_find_weight(dvert_src, def_nr);
dw->weight = BKE_defvert_find_weight(dvert_src, def_nr);
}
}
}
@ -589,8 +591,8 @@ static void vgroup_remove_weight(Object *ob, const int def_nr)
dvert_act = ED_mesh_active_dvert_get_only(ob);
dw = defvert_find_index(dvert_act, def_nr);
defvert_remove_group(dvert_act, dw);
dw = BKE_defvert_find_index(dvert_act, def_nr);
BKE_defvert_remove_group(dvert_act, dw);
}
static bool vgroup_normalize_active_vertex(Object *ob, eVGroupSelect subset_type)
@ -616,7 +618,7 @@ static bool vgroup_normalize_active_vertex(Object *ob, eVGroupSelect subset_type
vgroup_validmap = BKE_object_defgroup_subset_from_select_type(
ob, subset_type, &vgroup_tot, &subset_count);
defvert_normalize_subset(dvert_act, vgroup_validmap, vgroup_tot);
BKE_defvert_normalize_subset(dvert_act, vgroup_validmap, vgroup_tot);
MEM_freeN((void *)vgroup_validmap);
if (me->editflag & ME_EDIT_MIRROR_X) {
@ -651,7 +653,7 @@ static void vgroup_copy_active_to_sel(Object *ob, eVGroupSelect subset_type)
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && eve != eve_act) {
MDeformVert *dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
defvert_copy_subset(dv, dvert_act, vgroup_validmap, vgroup_tot);
BKE_defvert_copy_subset(dv, dvert_act, vgroup_validmap, vgroup_tot);
if (me->editflag & ME_EDIT_MIRROR_X) {
ED_mesh_defvert_mirror_update_em(ob, eve, -1, i, cd_dvert_offset);
}
@ -668,7 +670,7 @@ static void vgroup_copy_active_to_sel(Object *ob, eVGroupSelect subset_type)
dv = me->dvert;
for (i = 0; i < me->totvert; i++, dv++) {
if ((me->mvert[i].flag & SELECT) && dv != dvert_act) {
defvert_copy_subset(dv, dvert_act, vgroup_validmap, vgroup_tot);
BKE_defvert_copy_subset(dv, dvert_act, vgroup_validmap, vgroup_tot);
if (me->editflag & ME_EDIT_MIRROR_X) {
ED_mesh_defvert_mirror_update_ob(ob, -1, i);
}
@ -804,7 +806,7 @@ static void ED_vgroup_nr_vert_add(
MDeformWeight *dw;
/* Lets first check to see if this vert is already in the weight group - if so lets update it. */
dw = defvert_find_index(dv, def_nr);
dw = BKE_defvert_find_index(dv, def_nr);
if (dw) {
switch (assignmode) {
@ -821,7 +823,7 @@ static void ED_vgroup_nr_vert_add(
dw->weight -= weight;
/* If the weight is zero or less than remove the vert from the deform group. */
if (dw->weight <= 0.0f) {
defvert_remove_group(dv, dw);
BKE_defvert_remove_group(dv, dw);
}
break;
}
@ -839,7 +841,7 @@ static void ED_vgroup_nr_vert_add(
/* If we are doing an additive assignment, then we need to create the deform weight. */
/* We checked if the vertex was added before so no need to test again, simply add. */
defvert_add_index_notest(dv, def_nr, weight);
BKE_defvert_add_index_notest(dv, def_nr, weight);
break;
}
}
@ -897,8 +899,8 @@ void ED_vgroup_vert_remove(Object *ob, bDeformGroup *dg, int vertnum)
MDeformVert *dv = &dvert[vertnum];
MDeformWeight *dw;
dw = defvert_find_index(dv, def_nr);
defvert_remove_group(dv, dw); /* dw can be NULL */
dw = BKE_defvert_find_index(dv, def_nr);
BKE_defvert_remove_group(dv, dw); /* dw can be NULL */
}
}
}
@ -947,7 +949,7 @@ static float get_vert_def_nr(Object *ob, const int def_nr, const int vertnum)
}
if (dv) {
MDeformWeight *dw = defvert_find_index(dv, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dv, def_nr);
if (dw) {
return dw->weight;
}
@ -971,7 +973,7 @@ void ED_vgroup_select_by_name(Object *ob, const char *name)
{
/* note: ob->actdef==0 signals on painting to create a new one,
* if a bone in posemode is selected */
ob->actdef = defgroup_name_index(ob, name) + 1;
ob->actdef = BKE_object_defgroup_name_index(ob, name) + 1;
}
/********************** Operator Implementations *********************/
@ -999,7 +1001,7 @@ static void vgroup_select_verts(Object *ob, int select)
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
MDeformVert *dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
if (defvert_find_index(dv, def_nr)) {
if (BKE_defvert_find_index(dv, def_nr)) {
BM_vert_select_set(em->bm, eve, select);
}
}
@ -1025,7 +1027,7 @@ static void vgroup_select_verts(Object *ob, int select)
for (i = 0; i < me->totvert; i++, mv++, dv++) {
if (!(mv->flag & ME_HIDE)) {
if (defvert_find_index(dv, def_nr)) {
if (BKE_defvert_find_index(dv, def_nr)) {
if (select) {
mv->flag |= SELECT;
}
@ -1052,7 +1054,7 @@ static void vgroup_select_verts(Object *ob, int select)
tot = lt->pntsu * lt->pntsv * lt->pntsw;
for (a = 0, bp = lt->def; a < tot; a++, bp++, dv++) {
if (defvert_find_index(dv, def_nr)) {
if (BKE_defvert_find_index(dv, def_nr)) {
if (select) {
bp->f1 |= SELECT;
}
@ -1088,9 +1090,9 @@ static void vgroup_duplicate(Object *ob)
BLI_strncpy(name, dg->name, sizeof(name));
}
cdg = defgroup_duplicate(dg);
cdg = BKE_defgroup_duplicate(dg);
BLI_strncpy(cdg->name, name, sizeof(cdg->name));
defgroup_unique_name(cdg, ob);
BKE_object_defgroup_unique_name(cdg, ob);
BLI_addtail(&ob->defbase, cdg);
@ -1104,11 +1106,11 @@ static void vgroup_duplicate(Object *ob)
if (dvert_array) {
for (i = 0; i < dvert_tot; i++) {
MDeformVert *dv = dvert_array[i];
dw_org = defvert_find_index(dv, idg);
dw_org = BKE_defvert_find_index(dv, idg);
if (dw_org) {
/* defvert_verify_index re-allocs org so need to store the weight first */
/* BKE_defvert_ensure_index re-allocs org so need to store the weight first */
const float weight = dw_org->weight;
dw_cpy = defvert_verify_index(dv, icdg);
dw_cpy = BKE_defvert_ensure_index(dv, icdg);
dw_cpy->weight = weight;
}
}
@ -1142,7 +1144,7 @@ static bool vgroup_normalize(Object *ob)
continue;
}
dw = defvert_find_index(dv, def_nr);
dw = BKE_defvert_find_index(dv, def_nr);
if (dw) {
weight_max = max_ff(dw->weight, weight_max);
}
@ -1156,7 +1158,7 @@ static bool vgroup_normalize(Object *ob)
continue;
}
dw = defvert_find_index(dv, def_nr);
dw = BKE_defvert_find_index(dv, def_nr);
if (dw) {
dw->weight /= weight_max;
@ -1579,7 +1581,7 @@ static void vgroup_levels_subset(Object *ob,
j = vgroup_tot;
while (j--) {
if (vgroup_validmap[j]) {
dw = defvert_find_index(dv, j);
dw = BKE_defvert_find_index(dv, j);
if (dw) {
dw->weight = gain * (dw->weight + offset);
@ -1643,13 +1645,13 @@ static bool vgroup_normalize_all(Object *ob,
/* in case its not selected */
if ((dv = dvert_array[i])) {
if (lock_flags) {
defvert_normalize_lock_map(dv, vgroup_validmap, vgroup_tot, lock_flags, defbase_tot);
BKE_defvert_normalize_lock_map(dv, vgroup_validmap, vgroup_tot, lock_flags, defbase_tot);
}
else if (lock_active) {
defvert_normalize_lock_single(dv, vgroup_validmap, vgroup_tot, def_nr);
BKE_defvert_normalize_lock_single(dv, vgroup_validmap, vgroup_tot, def_nr);
}
else {
defvert_normalize_subset(dv, vgroup_validmap, vgroup_tot);
BKE_defvert_normalize_subset(dv, vgroup_validmap, vgroup_tot);
}
}
}
@ -1833,10 +1835,10 @@ static void vgroup_invert_subset(Object *ob,
if (vgroup_validmap[j]) {
if (auto_assign) {
dw = defvert_verify_index(dv, j);
dw = BKE_defvert_ensure_index(dv, j);
}
else {
dw = defvert_find_index(dv, j);
dw = BKE_defvert_find_index(dv, j);
}
if (dw) {
@ -2274,28 +2276,28 @@ static void dvert_mirror_op(MDeformVert *dvert,
SWAP(MDeformVert, *dvert, *dvert_mirr);
}
else {
MDeformWeight *dw = defvert_find_index(dvert, act_vgroup);
MDeformWeight *dw_mirr = defvert_find_index(dvert_mirr, act_vgroup);
MDeformWeight *dw = BKE_defvert_find_index(dvert, act_vgroup);
MDeformWeight *dw_mirr = BKE_defvert_find_index(dvert_mirr, act_vgroup);
if (dw && dw_mirr) {
SWAP(float, dw->weight, dw_mirr->weight);
}
else if (dw) {
dw_mirr = defvert_verify_index(dvert_mirr, act_vgroup);
dw_mirr = BKE_defvert_ensure_index(dvert_mirr, act_vgroup);
dw_mirr->weight = dw->weight;
defvert_remove_group(dvert, dw);
BKE_defvert_remove_group(dvert, dw);
}
else if (dw_mirr) {
dw = defvert_verify_index(dvert, act_vgroup);
dw = BKE_defvert_ensure_index(dvert, act_vgroup);
dw->weight = dw_mirr->weight;
defvert_remove_group(dvert_mirr, dw_mirr);
BKE_defvert_remove_group(dvert_mirr, dw_mirr);
}
}
}
if (flip_vgroups) {
defvert_flip(dvert, flip_map, flip_map_len);
defvert_flip(dvert_mirr, flip_map, flip_map_len);
BKE_defvert_flip(dvert, flip_map, flip_map_len);
BKE_defvert_flip(dvert_mirr, flip_map, flip_map_len);
}
}
else {
@ -2306,16 +2308,16 @@ static void dvert_mirror_op(MDeformVert *dvert,
if (mirror_weights) {
if (all_vgroups) {
defvert_copy(dvert, dvert_mirr);
BKE_defvert_copy(dvert, dvert_mirr);
}
else {
defvert_copy_index(dvert, act_vgroup, dvert_mirr, act_vgroup);
BKE_defvert_copy_index(dvert, act_vgroup, dvert_mirr, act_vgroup);
}
}
/* flip map already modified for 'all_vgroups' */
if (flip_vgroups) {
defvert_flip(dvert, flip_map, flip_map_len);
BKE_defvert_flip(dvert, flip_map, flip_map_len);
}
}
}
@ -2358,8 +2360,8 @@ void ED_vgroup_mirror(Object *ob,
}
if (flip_vgroups) {
flip_map = all_vgroups ? defgroup_flip_map(ob, &flip_map_len, false) :
defgroup_flip_map_single(ob, &flip_map_len, false, def_nr);
flip_map = all_vgroups ? BKE_object_defgroup_flip_map(ob, &flip_map_len, false) :
BKE_object_defgroup_flip_map_single(ob, &flip_map_len, false, def_nr);
BLI_assert(flip_map != NULL);
@ -2576,7 +2578,7 @@ static void vgroup_assign_verts(Object *ob, const float weight)
MDeformVert *dv;
MDeformWeight *dw;
dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset); /* can be NULL */
dw = defvert_verify_index(dv, def_nr);
dw = BKE_defvert_ensure_index(dv, def_nr);
if (dw) {
dw->weight = weight;
}
@ -2598,7 +2600,7 @@ static void vgroup_assign_verts(Object *ob, const float weight)
for (i = 0; i < me->totvert; i++, mv++, dv++) {
if (mv->flag & SELECT) {
MDeformWeight *dw;
dw = defvert_verify_index(dv, def_nr);
dw = BKE_defvert_ensure_index(dv, def_nr);
if (dw) {
dw->weight = weight;
}
@ -2623,7 +2625,7 @@ static void vgroup_assign_verts(Object *ob, const float weight)
if (bp->f1 & SELECT) {
MDeformWeight *dw;
dw = defvert_verify_index(dv, def_nr);
dw = BKE_defvert_ensure_index(dv, def_nr);
if (dw) {
dw->weight = weight;
}
@ -3885,7 +3887,7 @@ static int vgroup_do_remap(Object *ob, const char *name_array, wmOperator *op)
BM_ITER_MESH (eve, &iter, em->bm, BM_VERTS_OF_MESH) {
dvert = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
if (dvert->totweight) {
defvert_remap(dvert, sort_map, defbase_tot);
BKE_defvert_remap(dvert, sort_map, defbase_tot);
}
}
}
@ -3905,7 +3907,7 @@ static int vgroup_do_remap(Object *ob, const char *name_array, wmOperator *op)
if (dvert) {
while (dvert_tot--) {
if (dvert->totweight) {
defvert_remap(dvert, sort_map, defbase_tot);
BKE_defvert_remap(dvert, sort_map, defbase_tot);
}
dvert++;
}
@ -3953,7 +3955,7 @@ static void vgroup_sort_bone_hierarchy(Object *ob, ListBase *bonebase)
if (bonebase != NULL) {
Bone *bone;
for (bone = bonebase->last; bone; bone = bone->prev) {
bDeformGroup *dg = defgroup_find_name(ob, bone->name);
bDeformGroup *dg = BKE_object_defgroup_find_name(ob, bone->name);
vgroup_sort_bone_hierarchy(ob, &bone->childbase);
if (dg != NULL) {
@ -4105,12 +4107,12 @@ static void vgroup_copy_active_to_sel_single(Object *ob, const int def_nr)
if (dvert_act == NULL) {
return;
}
weight_act = defvert_find_weight(dvert_act, def_nr);
weight_act = BKE_defvert_find_weight(dvert_act, def_nr);
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
if (BM_elem_flag_test(eve, BM_ELEM_SELECT) && (eve != eve_act)) {
MDeformVert *dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
MDeformWeight *dw = defvert_find_index(dv, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dv, def_nr);
if (dw) {
dw->weight = weight_act;
@ -4133,12 +4135,12 @@ static void vgroup_copy_active_to_sel_single(Object *ob, const int def_nr)
if (dvert_act == NULL) {
return;
}
weight_act = defvert_find_weight(dvert_act, def_nr);
weight_act = BKE_defvert_find_weight(dvert_act, def_nr);
dv = me->dvert;
for (i = 0; i < me->totvert; i++, dv++) {
if ((me->mvert[i].flag & SELECT) && (dv != dvert_act)) {
MDeformWeight *dw = defvert_find_index(dv, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dv, def_nr);
if (dw) {
dw->weight = weight_act;
if (me->editflag & ME_EDIT_MIRROR_X) {

@ -259,7 +259,7 @@ static int output_toggle_exec(bContext *C, wmOperator *op)
DEG_relations_tag_update(CTX_data_main(C));
}
else {
bDeformGroup *defgroup = defgroup_find_name(ob, name);
bDeformGroup *defgroup = BKE_object_defgroup_find_name(ob, name);
if (defgroup) {
BKE_object_defgroup_remove(ob, defgroup);
DEG_relations_tag_update(CTX_data_main(C));

@ -172,7 +172,7 @@ static MDeformVert *defweight_prev_init(MDeformVert *dvert_prev,
MDeformVert *dv_prev = &dvert_prev[index];
if (dv_prev->flag == 1) {
dv_prev->flag = 0;
defvert_copy(dv_prev, dv_curr);
BKE_defvert_copy(dv_prev, dv_curr);
}
return dv_prev;
}
@ -752,10 +752,10 @@ static void do_weight_paint_vertex_single(
}
if (wp->flag & VP_FLAG_VGROUP_RESTRICT) {
dw = defvert_find_index(dv, wpi->active.index);
dw = BKE_defvert_find_index(dv, wpi->active.index);
}
else {
dw = defvert_verify_index(dv, wpi->active.index);
dw = BKE_defvert_ensure_index(dv, wpi->active.index);
}
if (dw == NULL) {
@ -766,7 +766,7 @@ static void do_weight_paint_vertex_single(
if (index_mirr != -1) {
dv_mirr = &me->dvert[index_mirr];
if (wp->flag & VP_FLAG_VGROUP_RESTRICT) {
dw_mirr = defvert_find_index(dv_mirr, vgroup_mirr);
dw_mirr = BKE_defvert_find_index(dv_mirr, vgroup_mirr);
if (dw_mirr == NULL) {
index_mirr = vgroup_mirr = -1;
@ -775,13 +775,13 @@ static void do_weight_paint_vertex_single(
}
else {
if (index != index_mirr) {
dw_mirr = defvert_verify_index(dv_mirr, vgroup_mirr);
dw_mirr = BKE_defvert_ensure_index(dv_mirr, vgroup_mirr);
}
else {
/* dv and dv_mirr are the same */
int totweight_prev = dv_mirr->totweight;
int dw_offset = (int)(dw - dv_mirr->dw);
dw_mirr = defvert_verify_index(dv_mirr, vgroup_mirr);
dw_mirr = BKE_defvert_ensure_index(dv_mirr, vgroup_mirr);
/* if we added another, get our old one back */
if (totweight_prev != dv_mirr->totweight) {
@ -802,7 +802,7 @@ static void do_weight_paint_vertex_single(
defweight_prev_init(dvert_prev, me->dvert, index_mirr);
}
weight_prev = defvert_find_weight(dv_prev, wpi->active.index);
weight_prev = BKE_defvert_find_weight(dv_prev, wpi->active.index);
}
else {
weight_prev = dw->weight;
@ -1694,7 +1694,7 @@ static float wpaint_get_active_weight(const MDeformVert *dv, const WeightPaintIn
return weight;
}
else {
return defvert_find_weight(dv, wpi->active.index);
return BKE_defvert_find_weight(dv, wpi->active.index);
}
}

@ -160,7 +160,7 @@ static bool vertex_paint_from_weight(Object *ob)
uint j = 0;
do {
uint vidx = me->mloop[mp->loopstart + j].v;
const float weight = defvert_find_weight(&me->dvert[vidx], vgroup_active);
const float weight = BKE_defvert_find_weight(&me->dvert[vidx], vgroup_active);
const uchar grayscale = weight * 255;
lcol->r = grayscale;
lcol->b = grayscale;

@ -211,7 +211,7 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, const wmEvent *even
ToolSettings *ts = vc.scene->toolsettings;
Brush *brush = BKE_paint_brush(&ts->wpaint->paint);
const int vgroup_active = vc.obact->actdef - 1;
float vgroup_weight = defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
float vgroup_weight = BKE_defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
/* use combined weight in multipaint mode,
* since that's what is displayed to the user in the colors */
@ -462,9 +462,9 @@ static bool weight_paint_set(Object *ob, float paintweight)
continue;
}
dw = defvert_verify_index(&me->dvert[vidx], vgroup_active);
dw = BKE_defvert_ensure_index(&me->dvert[vidx], vgroup_active);
if (dw) {
dw_prev = defvert_verify_index(wpp.wpaint_prev + vidx, vgroup_active);
dw_prev = BKE_defvert_ensure_index(wpp.wpaint_prev + vidx, vgroup_active);
dw_prev->weight = dw->weight; /* set the undo weight */
dw->weight = paintweight;
@ -473,12 +473,12 @@ static bool weight_paint_set(Object *ob, float paintweight)
if (j >= 0) {
/* copy, not paint again */
if (vgroup_mirror != -1) {
dw = defvert_verify_index(me->dvert + j, vgroup_mirror);
dw_prev = defvert_verify_index(wpp.wpaint_prev + j, vgroup_mirror);
dw = BKE_defvert_ensure_index(me->dvert + j, vgroup_mirror);
dw_prev = BKE_defvert_ensure_index(wpp.wpaint_prev + j, vgroup_mirror);
}
else {
dw = defvert_verify_index(me->dvert + j, vgroup_active);
dw_prev = defvert_verify_index(wpp.wpaint_prev + j, vgroup_active);
dw = BKE_defvert_ensure_index(me->dvert + j, vgroup_active);
dw_prev = BKE_defvert_ensure_index(wpp.wpaint_prev + j, vgroup_active);
}
dw_prev->weight = dw->weight; /* set the undo weight */
dw->weight = paintweight;
@ -602,7 +602,7 @@ static void gradientVert_update(WPGradient_userData *grad_data, int index)
if (alpha != 0.0f) {
MDeformVert *dv = &me->dvert[index];
MDeformWeight *dw = defvert_verify_index(dv, grad_data->def_nr);
MDeformWeight *dw = BKE_defvert_ensure_index(dv, grad_data->def_nr);
// dw->weight = alpha; // testing
int tool = grad_data->brush->blend;
float testw;
@ -617,14 +617,14 @@ static void gradientVert_update(WPGradient_userData *grad_data, int index)
MDeformVert *dv = &me->dvert[index];
if (vs->flag & VGRAD_STORE_DW_EXIST) {
/* normally we NULL check, but in this case we know it exists */
MDeformWeight *dw = defvert_find_index(dv, grad_data->def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dv, grad_data->def_nr);
dw->weight = vs->weight_orig;
}
else {
/* wasn't originally existing, remove */
MDeformWeight *dw = defvert_find_index(dv, grad_data->def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dv, grad_data->def_nr);
if (dw) {
defvert_remove_group(dv, dw);
BKE_defvert_remove_group(dv, dw);
}
}
}
@ -678,7 +678,7 @@ static void gradientVertInit__mapFunc(void *userData,
}
MDeformVert *dv = &me->dvert[index];
const MDeformWeight *dw = defvert_find_index(dv, grad_data->def_nr);
const MDeformWeight *dw = BKE_defvert_find_index(dv, grad_data->def_nr);
if (dw) {
vs->weight_orig = dw->weight;
vs->flag = VGRAD_STORE_DW_EXIST;

@ -88,7 +88,7 @@ bool ED_wpaint_ensure_data(bContext *C,
bPoseChannel *pchan = BKE_pose_channel_find_name(modob->pose, actbone->name);
if (pchan) {
bDeformGroup *dg = defgroup_find_name(ob, pchan->name);
bDeformGroup *dg = BKE_object_defgroup_find_name(ob, pchan->name);
if (dg == NULL) {
dg = BKE_object_defgroup_add_name(ob, pchan->name); /* sets actdef */
DEG_relations_tag_update(CTX_data_main(C));
@ -140,9 +140,9 @@ int ED_wpaint_mirror_vgroup_ensure(Object *ob, const int vgroup_active)
char name_flip[MAXBONENAME];
BLI_string_flip_side_name(name_flip, defgroup->name, false, sizeof(name_flip));
mirrdef = defgroup_name_index(ob, name_flip);
mirrdef = BKE_object_defgroup_name_index(ob, name_flip);
if (mirrdef == -1) {
if (BKE_defgroup_new(ob, name_flip)) {
if (BKE_object_defgroup_new(ob, name_flip)) {
mirrdef = BLI_listbase_count(&ob->defbase) - 1;
}
}

@ -741,7 +741,7 @@ static void namebutton_cb(bContext *C, void *tsep, char *oldname)
else {
switch (tselem->type) {
case TSE_DEFGROUP:
defgroup_unique_name(te->directdata, (Object *)tselem->id); // id = object
BKE_object_defgroup_unique_name(te->directdata, (Object *)tselem->id); // id = object
break;
case TSE_NLA_ACTION:
BLI_libblock_ensure_unique_name(bmain, tselem->id->name);

@ -1184,7 +1184,7 @@ static void view3d_panel_vgroup(const bContext *C, Panel *pa)
for (i = 0, dg = ob->defbase.first; dg; i++, dg = dg->next) {
bool locked = (dg->flag & DG_LOCK_WEIGHT) != 0;
if (vgroup_validmap[i]) {
MDeformWeight *dw = defvert_find_index(dv, i);
MDeformWeight *dw = BKE_defvert_find_index(dv, i);
if (dw) {
int x, xco = 0;
int icon;

@ -158,7 +158,7 @@ float get_modifier_point_weight(MDeformVert *dvert, bool inverse, int def_nr)
float weight = 1.0f;
if ((dvert != NULL) && (def_nr != -1)) {
MDeformWeight *dw = defvert_find_index(dvert, def_nr);
MDeformWeight *dw = BKE_defvert_find_index(dvert, def_nr);
weight = dw ? dw->weight : -1.0f;
if ((weight >= 0.0f) && (inverse == 1)) {
return -1.0f;

@ -199,7 +199,7 @@ static void deformStroke(GpencilModifierData *md,
return;
}
const int def_nr = defgroup_name_index(ob, mmd->vgname);
const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
bPoseChannel *pchan = BKE_pose_channel_find_name(mmd->object->pose, mmd->subtarget);
float dmat[4][4];

@ -75,7 +75,7 @@ static void deformStroke(GpencilModifierData *md,
bGPDstroke *gps)
{
LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
const int def_nr = defgroup_name_index(ob, mmd->vgname);
const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
if (!is_stroke_affected_by_modifier(ob,
mmd->layername,

@ -88,7 +88,7 @@ static void deformStroke(GpencilModifierData *md,
float vec1[3], vec2[3];
int sc_frame = 0;
int stroke_seed = 0;
const int def_nr = defgroup_name_index(ob, mmd->vgname);
const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
const float unit_v3[3] = {1.0f, 1.0f, 1.0f};
if (!is_stroke_affected_by_modifier(ob,

@ -69,7 +69,7 @@ static void deformStroke(GpencilModifierData *md,
bGPDstroke *gps)
{
OffsetGpencilModifierData *mmd = (OffsetGpencilModifierData *)md;
const int def_nr = defgroup_name_index(ob, mmd->vgname);
const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
float mat[4][4];
float loc[3], rot[3], scale[3];

@ -72,7 +72,7 @@ static void deformStroke(GpencilModifierData *md,
bGPDstroke *gps)
{
OpacityGpencilModifierData *mmd = (OpacityGpencilModifierData *)md;
const int def_nr = defgroup_name_index(ob, mmd->vgname);
const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
if (!is_stroke_affected_by_modifier(ob,
mmd->layername,

@ -65,7 +65,7 @@ static void deformStroke(GpencilModifierData *md,
bGPDstroke *gps)
{
SmoothGpencilModifierData *mmd = (SmoothGpencilModifierData *)md;
const int def_nr = defgroup_name_index(ob, mmd->vgname);
const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
if (!is_stroke_affected_by_modifier(ob,
mmd->layername,

@ -88,7 +88,7 @@ static void deformStroke(GpencilModifierData *md,
bGPDstroke *gps)
{
ThickGpencilModifierData *mmd = (ThickGpencilModifierData *)md;
const int def_nr = defgroup_name_index(ob, mmd->vgname);
const int def_nr = BKE_object_defgroup_name_index(ob, mmd->vgname);
if (!is_stroke_affected_by_modifier(ob,
mmd->layername,

@ -710,7 +710,7 @@ static void rna_VertexGroup_name_set(PointerRNA *ptr, const char *value)
Object *ob = (Object *)ptr->owner_id;
bDeformGroup *dg = (bDeformGroup *)ptr->data;
BLI_strncpy_utf8(dg->name, value, sizeof(dg->name));
defgroup_unique_name(dg, ob);
BKE_object_defgroup_unique_name(dg, ob);
}
static int rna_VertexGroup_index_get(PointerRNA *ptr)
@ -775,13 +775,13 @@ int rna_object_vgroup_name_index_length(PointerRNA *ptr, int index)
void rna_object_vgroup_name_index_set(PointerRNA *ptr, const char *value, short *index)
{
Object *ob = (Object *)ptr->owner_id;
*index = defgroup_name_index(ob, value) + 1;
*index = BKE_object_defgroup_name_index(ob, value) + 1;
}
void rna_object_vgroup_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
{
Object *ob = (Object *)ptr->owner_id;
bDeformGroup *dg = defgroup_find_name(ob, value);
bDeformGroup *dg = BKE_object_defgroup_find_name(ob, value);
if (dg) {
/* No need for BLI_strncpy_utf8, since this matches an existing group. */
BLI_strncpy(result, value, maxlen);

@ -1396,7 +1396,7 @@ static void psys_vg_name_set__internal(PointerRNA *ptr, const char *value, int i
psys->vgroup[index] = 0;
}
else {
int defgrp_index = defgroup_name_index(ob, value);
int defgrp_index = BKE_object_defgroup_name_index(ob, value);
if (defgrp_index == -1) {
return;

@ -148,8 +148,9 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
}
else if (vgroup != -1) {
weight = invert_vgroup ?
1.0f - defvert_array_find_weight_safe(dvert, BM_elem_index_get(v), vgroup) :
defvert_array_find_weight_safe(dvert, BM_elem_index_get(v), vgroup);
1.0f -
BKE_defvert_array_find_weight_safe(dvert, BM_elem_index_get(v), vgroup) :
BKE_defvert_array_find_weight_safe(dvert, BM_elem_index_get(v), vgroup);
/* Check is against 0.5 rather than != 0.0 because cascaded bevel modifiers will
* interpolate weights for newly created vertices, and may cause unexpected "selection" */
if (weight < 0.5f) {
@ -184,13 +185,13 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
}
else if (vgroup != -1) {
weight = invert_vgroup ?
1.0f - defvert_array_find_weight_safe(
1.0f - BKE_defvert_array_find_weight_safe(
dvert, BM_elem_index_get(e->v1), vgroup) :
defvert_array_find_weight_safe(dvert, BM_elem_index_get(e->v1), vgroup);
weight2 = invert_vgroup ?
1.0f - defvert_array_find_weight_safe(
dvert, BM_elem_index_get(e->v2), vgroup) :
defvert_array_find_weight_safe(dvert, BM_elem_index_get(e->v2), vgroup);
BKE_defvert_array_find_weight_safe(dvert, BM_elem_index_get(e->v1), vgroup);
weight2 = invert_vgroup ? 1.0f - BKE_defvert_array_find_weight_safe(
dvert, BM_elem_index_get(e->v2), vgroup) :
BKE_defvert_array_find_weight_safe(
dvert, BM_elem_index_get(e->v2), vgroup);
if (weight < 0.5f || weight2 < 0.5f) {
continue;
}

@ -199,8 +199,9 @@ static void sphere_do(CastModifierData *cmd,
}
if (dvert) {
const float weight = invert_vgroup ? 1.0f - defvert_find_weight(&dvert[i], defgrp_index) :
defvert_find_weight(&dvert[i], defgrp_index);
const float weight = invert_vgroup ?
1.0f - BKE_defvert_find_weight(&dvert[i], defgrp_index) :
BKE_defvert_find_weight(&dvert[i], defgrp_index);
if (weight == 0.0f) {
continue;
@ -370,8 +371,9 @@ static void cuboid_do(CastModifierData *cmd,
}
if (dvert) {
const float weight = invert_vgroup ? 1.0f - defvert_find_weight(&dvert[i], defgrp_index) :
defvert_find_weight(&dvert[i], defgrp_index);
const float weight = invert_vgroup ?
1.0f - BKE_defvert_find_weight(&dvert[i], defgrp_index) :
BKE_defvert_find_weight(&dvert[i], defgrp_index);
if (weight == 0.0f) {
continue;

@ -124,7 +124,7 @@ static void mesh_get_weights(MDeformVert *dvert,
uint i;
for (i = 0; i < numVerts; i++, dvert++) {
const float w = defvert_find_weight(dvert, defgrp_index);
const float w = BKE_defvert_find_weight(dvert, defgrp_index);
if (use_invert_vgroup == false) {
smooth_weights[i] = w;

@ -147,12 +147,12 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
if (dmd->flag & MOD_DECIM_FLAG_INVERT_VGROUP) {
for (i = 0; i < vert_tot; i++) {
vweights[i] = 1.0f - defvert_find_weight(&dvert[i], defgrp_index);
vweights[i] = 1.0f - BKE_defvert_find_weight(&dvert[i], defgrp_index);
}
}
else {
for (i = 0; i < vert_tot; i++) {
vweights[i] = defvert_find_weight(&dvert[i], defgrp_index);
vweights[i] = BKE_defvert_find_weight(&dvert[i], defgrp_index);
}
}
}

@ -193,8 +193,8 @@ static void displaceModifier_do_task(void *__restrict userdata,
float local_vec[3];
if (dvert) {
weight = invert_vgroup ? 1.0f - defvert_find_weight(dvert + iter, defgrp_index) :
defvert_find_weight(dvert + iter, defgrp_index);
weight = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dvert + iter, defgrp_index) :
BKE_defvert_find_weight(dvert + iter, defgrp_index);
if (weight == 0.0f) {
return;
}

@ -130,8 +130,8 @@ static void createFacepa(ExplodeModifierData *emd, ParticleSystemModifierData *p
for (i = 0; i < totvert; i++, dvert++) {
float val = BLI_rng_get_float(rng);
val = (1.0f - emd->protect) * val + emd->protect * 0.5f;
const float weight = invert_vgroup ? 1.0f - defvert_find_weight(dvert, defgrp_index) :
defvert_find_weight(dvert, defgrp_index);
const float weight = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dvert, defgrp_index) :
BKE_defvert_find_weight(dvert, defgrp_index);
if (val < weight) {
vertpa[i] = -1;
}

@ -238,8 +238,8 @@ static void hook_co_apply(struct HookData_cb *hd, const int j)
if (fac) {
if (hd->dvert) {
fac *= hd->invert_vgroup ? 1.0f - defvert_find_weight(&hd->dvert[j], hd->defgrp_index) :
defvert_find_weight(&hd->dvert[j], hd->defgrp_index);
fac *= hd->invert_vgroup ? 1.0f - BKE_defvert_find_weight(&hd->dvert[j], hd->defgrp_index) :
BKE_defvert_find_weight(&hd->dvert[j], hd->defgrp_index);
}
if (fac) {

@ -543,8 +543,8 @@ static void initSystem(
BLI_assert(dvert != NULL);
dv = dvert;
for (i = 0; i < numVerts; i++) {
wpaint = invert_vgroup ? 1.0f - defvert_find_weight(dv, defgrp_index) :
defvert_find_weight(dv, defgrp_index);
wpaint = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dv, defgrp_index) :
BKE_defvert_find_weight(dv, defgrp_index);
dv++;
if (wpaint > 0.0f) {
STACK_PUSH(index_anchors, i);
@ -615,8 +615,8 @@ static int isSystemDifferent(LaplacianDeformModifierData *lmd,
}
dv = dvert;
for (i = 0; i < numVerts; i++) {
wpaint = invert_vgroup ? 1.0f - defvert_find_weight(dv, defgrp_index) :
defvert_find_weight(dv, defgrp_index);
wpaint = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dv, defgrp_index) :
BKE_defvert_find_weight(dv, defgrp_index);
dv++;
if (wpaint > 0.0f) {
total_anchors++;

@ -421,8 +421,8 @@ static void laplaciansmoothModifier_do(
EIG_linear_solver_right_hand_side_add(sys->context, 2, i, vertexCos[i][2]);
if (iter == 0) {
if (dv) {
wpaint = invert_vgroup ? 1.0f - defvert_find_weight(dv, defgrp_index) :
defvert_find_weight(dv, defgrp_index);
wpaint = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dv, defgrp_index) :
BKE_defvert_find_weight(dv, defgrp_index);
dv++;
}
else {

@ -124,7 +124,7 @@ static void compute_vertex_mask__vertex_group_mode(MDeformVert *dvert,
MutableArrayRef<bool> r_vertex_mask)
{
for (int i : r_vertex_mask.index_range()) {
const bool found = defvert_find_weight(&dvert[i], defgrp_index) > threshold;
const bool found = BKE_defvert_find_weight(&dvert[i], defgrp_index) > threshold;
r_vertex_mask[i] = found;
}
}
@ -324,7 +324,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
compute_vertex_mask__armature_mode(dvert, ob, armature_ob, mmd->threshold, vertex_mask);
}
else {
int defgrp_index = defgroup_name_index(ob, mmd->vgroup);
int defgrp_index = BKE_object_defgroup_name_index(ob, mmd->vgroup);
/* Return input mesh if the vertex group does not exist. */
if (defgrp_index == -1) {

@ -284,7 +284,7 @@ static void meshdeform_vert_task(void *__restrict userdata,
}
if (dvert) {
fac = defvert_find_weight(&dvert[iter], defgrp_index);
fac = BKE_defvert_find_weight(&dvert[iter], defgrp_index);
if (mmd->flag & MOD_MDEF_INVERT_VGROUP) {
fac = 1.0f - fac;

@ -316,7 +316,7 @@ static void SimpleDeformModifier_do(SimpleDeformModifierData *smd,
axis_map_table[(smd->mode != MOD_SIMPLEDEFORM_MODE_BEND) ? deform_axis : 2];
for (i = 0; i < numVerts; i++) {
float weight = defvert_array_find_weight_safe(dvert, i, vgroup);
float weight = BKE_defvert_array_find_weight_safe(dvert, i, vgroup);
if (invert_vgroup) {
weight = 1.0f - weight;

@ -943,7 +943,7 @@ static Mesh *subdivide_base(Mesh *orig)
weight = interpf(vg->w2, vg->w1, t);
if (weight > 0) {
defvert_add_index_notest(&outdvert[v], vg->def_nr, weight);
BKE_defvert_add_index_notest(&outdvert[v], vg->def_nr, weight);
}
}
@ -1058,7 +1058,7 @@ static void output_frames(BMesh *bm, SkinNode *sn, const MDeformVert *input_dver
dv = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_MDEFORMVERT);
BLI_assert(dv->totweight == 0);
defvert_copy(dv, input_dvert);
BKE_defvert_copy(dv, input_dvert);
}
}
}

@ -141,8 +141,8 @@ static void smoothModifier_do(
float *vco_new = accumulated_vecs[i];
const float f_new = invert_vgroup ?
(1.0f - defvert_find_weight(dv, defgrp_index)) * fac_new :
defvert_find_weight(dv, defgrp_index) * fac_new;
(1.0f - BKE_defvert_find_weight(dv, defgrp_index)) * fac_new :
BKE_defvert_find_weight(dv, defgrp_index) * fac_new;
if (f_new <= 0.0f) {
continue;
}

@ -578,10 +578,10 @@ Mesh *MOD_solidify_extrude_applyModifier(ModifierData *md,
if (dvert) {
MDeformVert *dv = &dvert[i];
if (defgrp_invert) {
scalar_short_vgroup = 1.0f - defvert_find_weight(dv, defgrp_index);
scalar_short_vgroup = 1.0f - BKE_defvert_find_weight(dv, defgrp_index);
}
else {
scalar_short_vgroup = defvert_find_weight(dv, defgrp_index);
scalar_short_vgroup = BKE_defvert_find_weight(dv, defgrp_index);
}
scalar_short_vgroup = (offset_fac_vg + (scalar_short_vgroup * offset_fac_vg_inv)) *
scalar_short;
@ -625,10 +625,10 @@ Mesh *MOD_solidify_extrude_applyModifier(ModifierData *md,
if (dvert) {
MDeformVert *dv = &dvert[i];
if (defgrp_invert) {
scalar_short_vgroup = 1.0f - defvert_find_weight(dv, defgrp_index);
scalar_short_vgroup = 1.0f - BKE_defvert_find_weight(dv, defgrp_index);
}
else {
scalar_short_vgroup = defvert_find_weight(dv, defgrp_index);
scalar_short_vgroup = BKE_defvert_find_weight(dv, defgrp_index);
}
scalar_short_vgroup = (offset_fac_vg + (scalar_short_vgroup * offset_fac_vg_inv)) *
scalar_short;
@ -740,14 +740,14 @@ Mesh *MOD_solidify_extrude_applyModifier(ModifierData *md,
if (defgrp_invert) {
for (i = 0; i < numVerts; i++, dv++) {
scalar = 1.0f - defvert_find_weight(dv, defgrp_index);
scalar = 1.0f - BKE_defvert_find_weight(dv, defgrp_index);
scalar = offset_fac_vg + (scalar * offset_fac_vg_inv);
vert_angles[i] *= scalar;
}
}
else {
for (i = 0; i < numVerts; i++, dv++) {
scalar = defvert_find_weight(dv, defgrp_index);
scalar = BKE_defvert_find_weight(dv, defgrp_index);
scalar = offset_fac_vg + (scalar * offset_fac_vg_inv);
vert_angles[i] *= scalar;
}

@ -1595,10 +1595,10 @@ Mesh *MOD_solidify_nonmanifold_applyModifier(ModifierData *md,
if (dvert) {
MDeformVert *dv = &dvert[i];
if (defgrp_invert) {
scalar_vgroup = 1.0f - defvert_find_weight(dv, defgrp_index);
scalar_vgroup = 1.0f - BKE_defvert_find_weight(dv, defgrp_index);
}
else {
scalar_vgroup = defvert_find_weight(dv, defgrp_index);
scalar_vgroup = BKE_defvert_find_weight(dv, defgrp_index);
}
scalar_vgroup = offset_fac_vg + (scalar_vgroup * offset_fac_vg_inv);
}

@ -235,7 +235,7 @@ Mesh *MOD_deform_mesh_eval_get(Object *ob,
void MOD_get_vgroup(
Object *ob, struct Mesh *mesh, const char *name, MDeformVert **dvert, int *defgrp_index)
{
*defgrp_index = defgroup_name_index(ob, name);
*defgrp_index = BKE_object_defgroup_name_index(ob, name);
*dvert = NULL;
if (*defgrp_index != -1) {

@ -112,8 +112,8 @@ static void uv_warp_compute(void *__restrict userdata,
for (l = 0; l < mp->totloop; l++, ml++, mluv++) {
float uv[2];
const float weight = data->invert_vgroup ?
1.0f - defvert_find_weight(&dvert[ml->v], defgrp_index) :
defvert_find_weight(&dvert[ml->v], defgrp_index);
1.0f - BKE_defvert_find_weight(&dvert[ml->v], defgrp_index) :
BKE_defvert_find_weight(&dvert[ml->v], defgrp_index);
uv_warp_from_mat4_pair(uv, mluv->uv, warp_mat);
interp_v2_v2v2(mluv->uv, mluv->uv, uv, weight);

@ -235,8 +235,8 @@ static void warpModifier_do(WarpModifierData *wmd,
/* skip if no vert group found */
if (defgrp_index != -1) {
dv = &dvert[i];
weight = invert_vgroup ? 1.0f - defvert_find_weight(dv, defgrp_index) * strength :
defvert_find_weight(dv, defgrp_index) * strength;
weight = invert_vgroup ? 1.0f - BKE_defvert_find_weight(dv, defgrp_index) * strength :
BKE_defvert_find_weight(dv, defgrp_index) * strength;
if (weight <= 0.0f) {
continue;
}

@ -214,8 +214,8 @@ static void waveModifier_do(WaveModifierData *md,
/* get weights */
if (dvert) {
def_weight = invert_group ? 1.0f - defvert_find_weight(&dvert[i], defgrp_index) :
defvert_find_weight(&dvert[i], defgrp_index);
def_weight = invert_group ? 1.0f - BKE_defvert_find_weight(&dvert[i], defgrp_index) :
BKE_defvert_find_weight(&dvert[i], defgrp_index);
/* if this vert isn't in the vgroup, don't deform it */
if (def_weight == 0.0f) {

@ -143,7 +143,7 @@ static void aggregate_item_normal(WeightedNormalModifierData *wnmd,
const bool has_vgroup = dvert != NULL;
const bool vert_of_group = has_vgroup &&
defvert_find_index(&dvert[mv_index], defgrp_index) != NULL;
BKE_defvert_find_index(&dvert[mv_index], defgrp_index) != NULL;
if (has_vgroup &&
((vert_of_group && use_invert_vgroup) || (!vert_of_group && !use_invert_vgroup))) {

@ -212,7 +212,7 @@ void weightvg_do_mask(const ModifierEvalContext *ctx,
MEM_freeN(tex_co);
}
else if ((ref_didx = defgroup_name_index(ob, defgrp_name)) != -1) {
else if ((ref_didx = BKE_object_defgroup_name_index(ob, defgrp_name)) != -1) {
MDeformVert *dvert = NULL;
/* Check whether we want to set vgroup weights from a constant weight factor or a vertex
@ -232,8 +232,8 @@ void weightvg_do_mask(const ModifierEvalContext *ctx,
for (i = 0; i < num; i++) {
int idx = indices ? indices[i] : i;
const float f = invert_vgroup_mask ?
1.0f - defvert_find_weight(&dvert[idx], ref_didx) * fact :
defvert_find_weight(&dvert[idx], ref_didx) * fact;
1.0f - BKE_defvert_find_weight(&dvert[idx], ref_didx) * fact :
BKE_defvert_find_weight(&dvert[idx], ref_didx) * fact;
org_w[i] = (new_w[i] * f) + (org_w[i] * (1.0f - f));
/* If that vertex is not in ref vgroup, assume null factor, and hence do nothing! */
}
@ -271,7 +271,7 @@ void weightvg_update_vg(MDeformVert *dvert,
float w = weights[i];
MDeformVert *dv = &dvert[indices ? indices[i] : i];
MDeformWeight *dw = dws ? dws[i] :
((defgrp_idx >= 0) ? defvert_find_index(dv, defgrp_idx) : NULL);
((defgrp_idx >= 0) ? BKE_defvert_find_index(dv, defgrp_idx) : NULL);
/* Never allow weights out of [0.0, 1.0] range. */
CLAMP(w, 0.0f, 1.0f);
@ -279,7 +279,7 @@ void weightvg_update_vg(MDeformVert *dvert,
/* If the vertex is in this vgroup, remove it if needed, or just update it. */
if (dw != NULL) {
if (do_rem && w < rem_thresh) {
defvert_remove_group(dv, dw);
BKE_defvert_remove_group(dv, dw);
}
else {
dw->weight = w;
@ -287,7 +287,7 @@ void weightvg_update_vg(MDeformVert *dvert,
}
/* Else, add it if needed! */
else if (do_add && w > add_thresh) {
defvert_add_index_notest(dv, defgrp_idx, w);
BKE_defvert_add_index_notest(dv, defgrp_idx, w);
}
}
}

@ -188,7 +188,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
}
/* Get vgroup idx from its name. */
const int defgrp_index = defgroup_name_index(ctx->object, wmd->defgrp_name);
const int defgrp_index = BKE_object_defgroup_name_index(ctx->object, wmd->defgrp_name);
if (defgrp_index == -1) {
return mesh;
}
@ -220,7 +220,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
new_w = MEM_malloc_arrayN(numVerts, sizeof(float), "WeightVGEdit Modifier, new_w");
dw = MEM_malloc_arrayN(numVerts, sizeof(MDeformWeight *), "WeightVGEdit Modifier, dw");
for (i = 0; i < numVerts; i++) {
dw[i] = defvert_find_index(&dvert[i], defgrp_index);
dw[i] = BKE_defvert_find_index(&dvert[i], defgrp_index);
if (dw[i]) {
org_w[i] = new_w[i] = dw[i]->weight;
}

@ -235,14 +235,14 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
}
/* Get vgroup idx from its name. */
const int defgrp_index = defgroup_name_index(ctx->object, wmd->defgrp_name_a);
const int defgrp_index = BKE_object_defgroup_name_index(ctx->object, wmd->defgrp_name_a);
if (defgrp_index == -1) {
return mesh;
}
/* Get second vgroup idx from its name, if given. */
int defgrp_index_other = -1;
if (wmd->defgrp_name_b[0] != '\0') {
defgrp_index_other = defgroup_name_index(ctx->object, wmd->defgrp_name_b);
defgrp_index_other = BKE_object_defgroup_name_index(ctx->object, wmd->defgrp_name_b);
if (defgrp_index_other == -1) {
return mesh;
}
@ -278,11 +278,11 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
case MOD_WVG_SET_A:
/* All vertices in first vgroup. */
for (i = 0; i < numVerts; i++) {
MDeformWeight *dw = defvert_find_index(&dvert[i], defgrp_index);
MDeformWeight *dw = BKE_defvert_find_index(&dvert[i], defgrp_index);
if (dw) {
tdw1[numIdx] = dw;
tdw2[numIdx] = (defgrp_index_other >= 0) ?
defvert_find_index(&dvert[i], defgrp_index_other) :
BKE_defvert_find_index(&dvert[i], defgrp_index_other) :
NULL;
tidx[numIdx++] = i;
}
@ -292,10 +292,10 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
/* All vertices in second vgroup. */
for (i = 0; i < numVerts; i++) {
MDeformWeight *dw = (defgrp_index_other >= 0) ?
defvert_find_index(&dvert[i], defgrp_index_other) :
BKE_defvert_find_index(&dvert[i], defgrp_index_other) :
NULL;
if (dw) {
tdw1[numIdx] = defvert_find_index(&dvert[i], defgrp_index);
tdw1[numIdx] = BKE_defvert_find_index(&dvert[i], defgrp_index);
tdw2[numIdx] = dw;
tidx[numIdx++] = i;
}
@ -304,9 +304,9 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
case MOD_WVG_SET_OR:
/* All vertices in one vgroup or the other. */
for (i = 0; i < numVerts; i++) {
MDeformWeight *adw = defvert_find_index(&dvert[i], defgrp_index);
MDeformWeight *adw = BKE_defvert_find_index(&dvert[i], defgrp_index);
MDeformWeight *bdw = (defgrp_index_other >= 0) ?
defvert_find_index(&dvert[i], defgrp_index_other) :
BKE_defvert_find_index(&dvert[i], defgrp_index_other) :
NULL;
if (adw || bdw) {
tdw1[numIdx] = adw;
@ -318,9 +318,9 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
case MOD_WVG_SET_AND:
/* All vertices in both vgroups. */
for (i = 0; i < numVerts; i++) {
MDeformWeight *adw = defvert_find_index(&dvert[i], defgrp_index);
MDeformWeight *adw = BKE_defvert_find_index(&dvert[i], defgrp_index);
MDeformWeight *bdw = (defgrp_index_other >= 0) ?
defvert_find_index(&dvert[i], defgrp_index_other) :
BKE_defvert_find_index(&dvert[i], defgrp_index_other) :
NULL;
if (adw && bdw) {
tdw1[numIdx] = adw;
@ -333,9 +333,10 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
default:
/* Use all vertices. */
for (i = 0; i < numVerts; i++) {
tdw1[i] = defvert_find_index(&dvert[i], defgrp_index);
tdw2[i] = (defgrp_index_other >= 0) ? defvert_find_index(&dvert[i], defgrp_index_other) :
NULL;
tdw1[i] = BKE_defvert_find_index(&dvert[i], defgrp_index);
tdw2[i] = (defgrp_index_other >= 0) ?
BKE_defvert_find_index(&dvert[i], defgrp_index_other) :
NULL;
}
numIdx = -1;
break;

@ -439,7 +439,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
}
/* Get vgroup idx from its name. */
defgrp_index = defgroup_name_index(ob, wmd->defgrp_name);
defgrp_index = BKE_object_defgroup_name_index(ob, wmd->defgrp_name);
if (defgrp_index == -1) {
return mesh;
}
@ -463,7 +463,7 @@ static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mes
tw = MEM_malloc_arrayN(numVerts, sizeof(float), "WeightVGProximity Modifier, tw");
tdw = MEM_malloc_arrayN(numVerts, sizeof(MDeformWeight *), "WeightVGProximity Modifier, tdw");
for (i = 0; i < numVerts; i++) {
MDeformWeight *_dw = defvert_find_index(&dvert[i], defgrp_index);
MDeformWeight *_dw = BKE_defvert_find_index(&dvert[i], defgrp_index);
if (_dw) {
tidx[numIdx] = i;
tw[numIdx] = _dw->weight;

@ -1629,7 +1629,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd, const ModifierEvalContex
totvert = mesh->totvert;
/* Vertex Group. */
const int defgrp_index = defgroup_name_index(ob, wmd->defgrp_name);
const int defgrp_index = BKE_object_defgroup_name_index(ob, wmd->defgrp_name);
if (defgrp_index != -1) {
MDeformVert *dvert, *dv;
dvert = CustomData_get_layer(&mesh->vdata, CD_MDEFORMVERT);
@ -1638,7 +1638,7 @@ static Mesh *weldModifier_doWeld(WeldModifierData *wmd, const ModifierEvalContex
dv = &dvert[0];
v_mask = BLI_BITMAP_NEW(totvert, __func__);
for (i = 0; i < totvert; i++, dv++) {
const bool found = defvert_find_weight(dv, defgrp_index) > 0.0f;
const bool found = BKE_defvert_find_weight(dv, defgrp_index) > 0.0f;
if (found != invert_vgroup) {
BLI_BITMAP_ENABLE(v_mask, i);
v_mask_act++;

@ -61,7 +61,7 @@ static Mesh *WireframeModifier_do(WireframeModifierData *wmd, Object *ob, Mesh *
Mesh *result;
BMesh *bm;
const int defgrp_index = defgroup_name_index(ob, wmd->defgrp_name);
const int defgrp_index = BKE_object_defgroup_name_index(ob, wmd->defgrp_name);
bm = BKE_mesh_to_bmesh_ex(mesh,
&(struct BMeshCreateParams){0},

@ -381,8 +381,8 @@ PyObject *BPy_BMLoopColor_CreatePyObject(struct MLoopCol *data)
* hiding the #MDeformWeight on access, since the mapping is very close, eg:
*
* \code{.c}
* weight = defvert_find_weight(dv, group_nr);
* defvert_remove_group(dv, dw)
* weight = BKE_defvert_find_weight(dv, group_nr);
* BKE_defvert_remove_group(dv, dw)
* \endcode
*
* \code{.py}
@ -423,7 +423,7 @@ static PyObject *bpy_bmdeformvert_subscript(BPy_BMDeformVert *self, PyObject *ke
return NULL;
}
else {
MDeformWeight *dw = defvert_find_index(self->data, i);
MDeformWeight *dw = BKE_defvert_find_index(self->data, i);
if (dw == NULL) {
PyErr_SetString(PyExc_KeyError,
@ -462,7 +462,7 @@ static int bpy_bmdeformvert_ass_subscript(BPy_BMDeformVert *self, PyObject *key,
return -1;
}
else {
MDeformWeight *dw = defvert_verify_index(self->data, i);
MDeformWeight *dw = BKE_defvert_ensure_index(self->data, i);
const float f = PyFloat_AsDouble(value);
if (f == -1 && PyErr_Occurred()) { // parsed key not a number
PyErr_SetString(PyExc_TypeError,
@ -476,14 +476,14 @@ static int bpy_bmdeformvert_ass_subscript(BPy_BMDeformVert *self, PyObject *key,
}
else {
/* del dvert[group_index] */
MDeformWeight *dw = defvert_find_index(self->data, i);
MDeformWeight *dw = BKE_defvert_find_index(self->data, i);
if (dw == NULL) {
PyErr_SetString(PyExc_KeyError,
"del BMDeformVert[key]: "
"key not found");
}
defvert_remove_group(self->data, dw);
BKE_defvert_remove_group(self->data, dw);
}
return 0;
@ -504,7 +504,7 @@ static int bpy_bmdeformvert_contains(BPy_BMDeformVert *self, PyObject *value)
return -1;
}
return (defvert_find_index(self->data, key) != NULL) ? 1 : 0;
return (BKE_defvert_find_index(self->data, key) != NULL) ? 1 : 0;
}
/* only defined for __contains__ */
@ -623,7 +623,7 @@ static PyObject *bpy_bmdeformvert_get(BPy_BMDeformVert *self, PyObject *args)
return NULL;
}
else {
MDeformWeight *dw = defvert_find_index(self->data, key);
MDeformWeight *dw = BKE_defvert_find_index(self->data, key);
if (dw) {
return PyFloat_FromDouble(dw->weight);
@ -640,7 +640,7 @@ PyDoc_STRVAR(bpy_bmdeformvert_clear_doc,
" Clears all weights.\n");
static PyObject *bpy_bmdeformvert_clear(BPy_BMDeformVert *self)
{
defvert_clear(self->data);
BKE_defvert_clear(self->data);
Py_RETURN_NONE;
}
@ -684,7 +684,7 @@ int BPy_BMDeformVert_AssignPyObject(struct MDeformVert *dvert, PyObject *value)
else {
MDeformVert *dvert_src = ((BPy_BMDeformVert *)value)->data;
if (LIKELY(dvert != dvert_src)) {
defvert_copy(dvert, dvert_src);
BKE_defvert_copy(dvert, dvert_src);
}
return 0;
}

@ -347,7 +347,7 @@ static void pointdensity_cache_vertex_weight(PointDensity *pd,
if (!mdef) {
return;
}
mdef_index = defgroup_name_index(ob, pd->vertex_attribute_name);
mdef_index = BKE_object_defgroup_name_index(ob, pd->vertex_attribute_name);
if (mdef_index < 0) {
mdef_index = ob->actdef - 1;
}

Loading…
Cancel
Save