kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

use consistent naming for deform.c, also moved defvert_remove_index into deform.c, was local in modifier code.

Browse Source
This commit is contained in:
Campbell Barton 2011-11-30 07:39:54 +00:00
parent b202bf0564
commit 064d46eef0
3 changed files with 155 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
source/blender/blenkernel/BKE_deform.h
View File

@ -52,14 +52,16 @@ void 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_remove_index(struct MDeformVert *dvert, int defgroup, struct MDeformWeight *dw);
float defvert_find_weight(const struct MDeformVert *dvert, const int group_num);
float defvert_array_find_weight_safe(const struct MDeformVert *dvert, int index, int group_num);
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);
void defvert_copy(struct MDeformVert *dvert_r, const struct MDeformVert *dvert);
void defvert_copy_index(struct MDeformVert *dv_dst, const struct MDeformVert *dv_src, const int defgroup);
void defvert_sync(struct MDeformVert *dvert_r, const struct MDeformVert *dvert, int use_verify);
void defvert_sync_mapped(struct MDeformVert *dvert_r, const struct MDeformVert *dvert, const int *flip_map, const int flip_map_len, const int use_verify);
void defvert_copy(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src);
void defvert_copy_index(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src, const int defgroup);
void defvert_sync(struct MDeformVert *dvert_dst, const struct MDeformVert *dvert_src, int 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 int use_verify);
void defvert_remap (struct MDeformVert *dvert, int *map);
void defvert_flip(struct MDeformVert *dvert, const int *flip_map, const int flip_map_len);
void defvert_normalize(struct MDeformVert *dvert);

245
source/blender/blenkernel/intern/deform.c
View File

@ -45,7 +45,7 @@
#include "BLI_utildefines.h"
void defgroup_copy_list (ListBase *outbase, ListBase *inbase)
void defgroup_copy_list(ListBase *outbase, ListBase *inbase)
{
bDeformGroup *defgroup, *defgroupn;
@ -57,7 +57,7 @@ void defgroup_copy_list (ListBase *outbase, ListBase *inbase)
}
}
bDeformGroup *defgroup_duplicate (bDeformGroup *ingroup)
bDeformGroup *defgroup_duplicate(bDeformGroup *ingroup)
{
bDeformGroup *outgroup;
@ -65,7 +65,7 @@ bDeformGroup *defgroup_duplicate (bDeformGroup *ingroup)
return NULL;
outgroup=MEM_callocN(sizeof(bDeformGroup), "copy deformGroup");
/* For now, just copy everything over. */
memcpy (outgroup, ingroup, sizeof(bDeformGroup));
@ -75,22 +75,22 @@ bDeformGroup *defgroup_duplicate (bDeformGroup *ingroup)
}
/* copy & overwrite weights */
void defvert_copy (MDeformVert *dvert_r, const MDeformVert *dvert)
void defvert_copy(MDeformVert *dvert_dst, const MDeformVert *dvert_src)
{
if(dvert_r->totweight == dvert->totweight) {
if(dvert->totweight)
memcpy(dvert_r->dw, dvert->dw, dvert->totweight * sizeof(MDeformWeight));
if (dvert_dst->totweight == dvert_src->totweight) {
if (dvert_src->totweight)
memcpy(dvert_dst->dw, dvert_src->dw, dvert_src->totweight * sizeof(MDeformWeight));
}
else {
if(dvert_r->dw)
MEM_freeN(dvert_r->dw);
if (dvert_dst->dw)
MEM_freeN(dvert_dst->dw);
if(dvert->totweight)
dvert_r->dw= MEM_dupallocN(dvert->dw);
if (dvert_src->totweight)
dvert_dst->dw= MEM_dupallocN(dvert_src->dw);
else
dvert_r->dw= NULL;
dvert_dst->dw= NULL;
dvert_r->totweight = dvert->totweight;
dvert_dst->totweight = dvert_src->totweight;
}
}
@ -98,20 +98,20 @@ void defvert_copy (MDeformVert *dvert_r, const MDeformVert *dvert)
* - do nothing if neither are set.
* - add destination weight if needed.
*/
void defvert_copy_index (MDeformVert *dv_dst, const MDeformVert *dv_src, const int defgroup)
void defvert_copy_index(MDeformVert *dvert_dst, const MDeformVert *dvert_src, const int defgroup)
{
MDeformWeight *dw_src, *dw_dst;
dw_src= defvert_find_index(dv_src, defgroup);
dw_src= defvert_find_index(dvert_src, defgroup);
if (dw_src) {
/* source is valid, verify destination */
dw_dst= defvert_verify_index(dv_dst, defgroup);
dw_dst= defvert_verify_index(dvert_dst, defgroup);
dw_dst->weight= dw_src->weight;
}
else {
/* source was NULL, assign zero, could also remove */
dw_dst= defvert_find_index(dv_dst, defgroup);
dw_dst= defvert_find_index(dvert_dst, defgroup);
if (dw_dst) {
dw_dst->weight= 0.0f;
@ -122,37 +122,38 @@ void defvert_copy_index (MDeformVert *dv_dst, const MDeformVert *dv_src, const i
/* only sync over matching weights, don't add or remove groups
* warning, loop within loop.
*/
void defvert_sync (MDeformVert *dvert_r, const MDeformVert *dvert, int use_verify)
void defvert_sync(MDeformVert *dvert_dst, const MDeformVert *dvert_src, int use_verify)
{
if(dvert->totweight && dvert_r->totweight) {
if (dvert_src->totweight && dvert_dst->totweight) {
int i;
MDeformWeight *dw;
for(i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++) {
MDeformWeight *dw_r;
if(use_verify) dw_r= defvert_verify_index(dvert_r, dw->def_nr);
else dw_r= defvert_find_index(dvert_r, dw->def_nr);
MDeformWeight *dw_src;
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);
else dw_dst= defvert_find_index(dvert_dst, dw_src->def_nr);
if(dw_r) {
dw_r->weight= dw->weight;
if (dw_dst) {
dw_dst->weight= dw_src->weight;
}
}
}
}
/* be sure all flip_map values are valid */
void defvert_sync_mapped (MDeformVert *dvert_r, const MDeformVert *dvert, const int *flip_map, const int flip_map_len, const int use_verify)
void defvert_sync_mapped(MDeformVert *dvert_dst, const MDeformVert *dvert_src,
const int *flip_map, const int flip_map_len, const int use_verify)
{
if (dvert->totweight && dvert_r->totweight) {
if (dvert_src->totweight && dvert_dst->totweight) {
int i;
MDeformWeight *dw;
for (i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++) {
if (dw->def_nr < flip_map_len) {
MDeformWeight *dw_r;
if(use_verify) dw_r= defvert_verify_index(dvert_r, flip_map[dw->def_nr]);
else dw_r= defvert_find_index(dvert_r, flip_map[dw->def_nr]);
MDeformWeight *dw_src;
for (i=0, dw_src=dvert_src->dw; i < dvert_src->totweight; i++, dw_src++) {
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]);
else dw_dst= defvert_find_index(dvert_dst, flip_map[dw_src->def_nr]);
if(dw_r) {
dw_r->weight= dw->weight;
if (dw_dst) {
dw_dst->weight= dw_src->weight;
}
}
}
@ -160,18 +161,18 @@ void defvert_sync_mapped (MDeformVert *dvert_r, const MDeformVert *dvert, const
}
/* be sure all flip_map values are valid */
void defvert_remap (MDeformVert *dvert, int *map)
void defvert_remap(MDeformVert *dvert, int *map)
{
MDeformWeight *dw;
int i;
for(i=0, dw=dvert->dw; i<dvert->totweight; i++, dw++) {
for (i=0, dw=dvert->dw; i<dvert->totweight; i++, dw++) {
dw->def_nr= map[dw->def_nr];
}
}
void defvert_normalize (MDeformVert *dvert)
void defvert_normalize(MDeformVert *dvert)
{
if(dvert->totweight<=0) {
if (dvert->totweight<=0) {
/* nothing */
}
else if (dvert->totweight==1) {
@ -181,30 +182,30 @@ void defvert_normalize (MDeformVert *dvert)
int i;
float tot= 0.0f;
MDeformWeight *dw;
for(i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
for (i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
tot += dw->weight;
if(tot > 0.0f) {
for(i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
if (tot > 0.0f) {
for (i=0, dw=dvert->dw; i < dvert->totweight; i++, dw++)
dw->weight /= tot;
}
}
}
void defvert_flip (MDeformVert *dvert, const int *flip_map, const int flip_map_len)
void defvert_flip(MDeformVert *dvert, const int *flip_map, const int flip_map_len)
{
MDeformWeight *dw;
int i;
for(dw= dvert->dw, i=0; i<dvert->totweight; dw++, i++) {
if((dw->def_nr < flip_map_len) && (flip_map[dw->def_nr] >= 0)) {
for (dw= dvert->dw, i=0; i<dvert->totweight; dw++, i++) {
if ((dw->def_nr < flip_map_len) && (flip_map[dw->def_nr] >= 0)) {
dw->def_nr= flip_map[dw->def_nr];
}
}
}
bDeformGroup *defgroup_find_name (Object *ob, const char *name)
bDeformGroup *defgroup_find_name(Object *ob, const char *name)
{
/* return a pointer to the deform group with this name
* or return NULL otherwise.
@ -219,7 +220,7 @@ bDeformGroup *defgroup_find_name (Object *ob, const char *name)
return NULL;
}
int defgroup_name_index (Object *ob, const char *name)
int defgroup_name_index(Object *ob, const char *name)
{
/* Return the location of the named deform group within the list of
* deform groups. This function is a combination of defgroup_find_index and
@ -228,8 +229,8 @@ int defgroup_name_index (Object *ob, const char *name)
*/
bDeformGroup *curdef;
int def_nr;
if(name && name[0] != '\0') {
if (name && name[0] != '\0') {
for (curdef=ob->defbase.first, def_nr=0; curdef; curdef=curdef->next, def_nr++) {
if (!strcmp(curdef->name, name))
return def_nr;
@ -239,7 +240,7 @@ int defgroup_name_index (Object *ob, const char *name)
return -1;
}
int defgroup_find_index (Object *ob, bDeformGroup *dg)
int defgroup_find_index(Object *ob, bDeformGroup *dg)
{
/* Fetch the location of this deform group
* within the linked list of deform groups.
@ -275,7 +276,7 @@ int defgroup_find_index (Object *ob, bDeformGroup *dg)
* constant for this)
*/
if (eg == NULL) return -1;
return def_nr;
}
@ -284,7 +285,7 @@ int *defgroup_flip_map(Object *ob, int *flip_map_len, int use_default)
{
int totdg= *flip_map_len= BLI_countlist(&ob->defbase);
if(totdg==0) {
if (totdg==0) {
return NULL;
}
else {
@ -297,16 +298,16 @@ int *defgroup_flip_map(Object *ob, int *flip_map_len, int use_default)
}
for (dg=ob->defbase.first, i=0; dg; dg=dg->next, i++) {
if(map[i] == -1) { /* may be calculated previously */
if (map[i] == -1) { /* may be calculated previously */
/* incase no valid value is found, use this */
if(use_default)
if (use_default)
map[i]= i;
flip_side_name(name, dg->name, FALSE);
if(strcmp(name, dg->name)) {
if (strcmp(name, dg->name)) {
flip_num= defgroup_name_index(ob, name);
if(flip_num >= 0) {
if (flip_num >= 0) {
map[i]= flip_num;
map[flip_num]= i; /* save an extra lookup */
}
@ -322,7 +323,7 @@ int *defgroup_flip_map_single(Object *ob, int *flip_map_len, int use_default, in
{
int totdg= *flip_map_len= BLI_countlist(&ob->defbase);
if(totdg==0) {
if (totdg==0) {
return NULL;
}
else {
@ -338,10 +339,10 @@ int *defgroup_flip_map_single(Object *ob, int *flip_map_len, int use_default, in
dg= BLI_findlink(&ob->defbase, defgroup);
flip_side_name(name, dg->name, FALSE);
if(strcmp(name, dg->name)) {
if (strcmp(name, dg->name)) {
flip_num= defgroup_name_index(ob, name);
if(flip_num >= 0) {
if (flip_num >= 0) {
map[defgroup]= flip_num;
map[flip_num]= defgroup;
}
@ -356,11 +357,11 @@ int defgroup_flip_index(Object *ob, int index, int use_default)
bDeformGroup *dg= BLI_findlink(&ob->defbase, index);
int flip_index = -1;
if(dg) {
if (dg) {
char name[sizeof(dg->name)];
flip_side_name(name, dg->name, 0);
if(strcmp(name, dg->name))
if (strcmp(name, dg->name))
flip_index= defgroup_name_index(ob, name);
}
@ -370,7 +371,7 @@ int defgroup_flip_index(Object *ob, int index, int use_default)
static int defgroup_find_name_dupe(const char *name, bDeformGroup *dg, Object *ob)
{
bDeformGroup *curdef;
for (curdef = ob->defbase.first; curdef; curdef=curdef->next) {
if (dg!=curdef) {
if (!strcmp(curdef->name, name)) {
@ -388,7 +389,7 @@ static int 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 defgroup_unique_name(bDeformGroup *dg, Object *ob)
{
struct {Object *ob; void *dg;} data;
data.ob= ob;
@ -400,7 +401,7 @@ void defgroup_unique_name (bDeformGroup *dg, Object *ob)
/* finds the best possible flipped name. For renaming; check for unique names afterwards */
/* if strip_number: removes number extensions
* note: dont use sizeof() for 'name' or 'from_name' */
void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP_NAME], int strip_number)
void flip_side_name(char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP_NAME], int strip_number)
{
int len;
char prefix[MAX_VGROUP_NAME]= ""; /* The part before the facing */
@ -410,15 +411,15 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
char *index=NULL;
len= BLI_strnlen(from_name, MAX_VGROUP_NAME);
if(len<3) return; // we don't do names like .R or .L
if (len < 3) return; // we don't do names like .R or .L
BLI_strncpy(name, from_name, MAX_VGROUP_NAME);
/* We first check the case with a .### extension, let's find the last period */
if(isdigit(name[len-1])) {
if (isdigit(name[len-1])) {
index= strrchr(name, '.'); // last occurrence
if (index && isdigit(index[1]) ) { // doesnt handle case bone.1abc2 correct..., whatever!
if(strip_number==0)
if (strip_number==0)
BLI_strncpy(number, index, sizeof(number));
*index= 0;
len= BLI_strnlen(name, MAX_VGROUP_NAME);
@ -430,7 +431,7 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
#define IS_SEPARATOR(a) ((a)=='.' || (a)==' ' || (a)=='-' || (a)=='_')
/* first case; separator . - _ with extensions r R l L */
if( IS_SEPARATOR(name[len-2]) ) {
if (IS_SEPARATOR(name[len-2]) ) {
switch(name[len-1]) {
case 'l':
prefix[len-1]= 0;
@ -451,7 +452,7 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
}
}
/* case; beginning with r R l L , with separator after it */
else if( IS_SEPARATOR(name[1]) ) {
else if (IS_SEPARATOR(name[1]) ) {
switch(name[0]) {
case 'l':
strcpy(replace, "r");
@ -475,14 +476,14 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
break;
}
}
else if(len > 5) {
else if (len > 5) {
/* hrms, why test for a separator? lets do the rule 'ultimate left or right' */
index = BLI_strcasestr(prefix, "right");
if (index==prefix || index==prefix+len-5) {
if(index[0]=='r')
if (index[0]=='r')
strcpy (replace, "left");
else {
if(index[1]=='I')
if (index[1]=='I')
strcpy (replace, "LEFT");
else
strcpy (replace, "Left");
@ -493,10 +494,10 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
else {
index = BLI_strcasestr(prefix, "left");
if (index==prefix || index==prefix+len-4) {
if(index[0]=='l')
if (index[0]=='l')
strcpy (replace, "right");
else {
if(index[1]=='E')
if (index[1]=='E')
strcpy (replace, "RIGHT");
else
strcpy (replace, "Right");
@ -512,30 +513,32 @@ void flip_side_name (char name[MAX_VGROUP_NAME], const char from_name[MAX_VGROUP
BLI_snprintf (name, MAX_VGROUP_NAME, "%s%s%s%s", prefix, replace, suffix, number);
}
float defvert_find_weight(const struct MDeformVert *dvert, const int group_num)
float defvert_find_weight(const struct MDeformVert *dvert, const int defgroup)
{
MDeformWeight *dw= defvert_find_index(dvert, group_num);
MDeformWeight *dw= defvert_find_index(dvert, defgroup);
return dw ? dw->weight : 0.0f;
}
float defvert_array_find_weight_safe(const struct MDeformVert *dvert, int index, int group_num)
float defvert_array_find_weight_safe(const struct MDeformVert *dvert, const int index, const int defgroup)
{
if(group_num == -1 || dvert == NULL)
if (defgroup == -1 || dvert == NULL)
return 1.0f;
return defvert_find_weight(dvert+index, group_num);
return defvert_find_weight(dvert+index, defgroup);
}
MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
{
if(dvert && defgroup >= 0) {
if (dvert && defgroup >= 0) {
MDeformWeight *dw = dvert->dw;
int i;
for(i=dvert->totweight; i>0; i--, dw++)
if(dw->def_nr == defgroup)
for (i=dvert->totweight; i>0; i--, dw++) {
if (dw->def_nr == defgroup) {
return dw;
}
}
}
return NULL;
@ -543,30 +546,74 @@ MDeformWeight *defvert_find_index(const MDeformVert *dvert, const int defgroup)
/* Ensures that mv has a deform weight entry for the specified defweight group */
/* Note this function is mirrored in editmesh_tools.c, for use for editvertices */
MDeformWeight *defvert_verify_index(MDeformVert *dv, const int defgroup)
MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
{
MDeformWeight *newdw;
MDeformWeight *dw_new;
/* do this check always, this function is used to check for it */
if(!dv || defgroup < 0)
if (!dvert || defgroup < 0)
return NULL;
newdw= defvert_find_index(dv, defgroup);
if(newdw)
return newdw;
dw_new= defvert_find_index(dvert, defgroup);
if (dw_new)
return dw_new;
newdw= MEM_callocN(sizeof(MDeformWeight)*(dv->totweight+1), "deformWeight");
if (dv->dw) {
memcpy(newdw, dv->dw, sizeof(MDeformWeight)*dv->totweight);
MEM_freeN(dv->dw);
dw_new= MEM_callocN(sizeof(MDeformWeight)*(dvert->totweight+1), "deformWeight");
if (dvert->dw) {
memcpy(dw_new, dvert->dw, sizeof(MDeformWeight)*dvert->totweight);
MEM_freeN(dvert->dw);
}
dv->dw= newdw;
newdw += dv->totweight;
newdw->weight= 0.0f;
newdw->def_nr= defgroup;
dvert->dw= dw_new;
dw_new += dvert->totweight;
dw_new->weight= 0.0f;
dw_new->def_nr= defgroup;
/* Group index */
dv->totweight++;
dvert->totweight++;
return newdw;
return dw_new;
}
/* Removes the given vertex from the vertex group, specified either by its defgrp_idx,
* or directly by its MDeformWeight pointer, if dw is not NULL.
* WARNING: This function frees the given MDeformWeight, do not use it afterward! */
void defvert_remove_index(MDeformVert *dvert, int defgroup, MDeformWeight *dw)
{
MDeformWeight *dw_new;
int i;
/* Get index of removed MDeformWeight. */
if (dw == NULL) {
dw = dvert->dw;
for (i = dvert->totweight; i > 0; i--, dw++) {
if (dw->def_nr == defgroup)
break;
}
i--;
}
else {
i = dw - dvert->dw;
/* Security check! */
if(i < 0 || i >= dvert->totweight)
return;
}
dvert->totweight--;
/* If there are still other deform weights attached to this vert then remove
* this deform weight, and reshuffle the others.
*/
if (dvert->totweight) {
dw_new = MEM_mallocN(sizeof(MDeformWeight)*(dvert->totweight), __func__);
if (dvert->dw){
memcpy(dw_new, dvert->dw, sizeof(MDeformWeight)*i);
memcpy(dw_new+i, dvert->dw+i+1, sizeof(MDeformWeight)*(dvert->totweight-i));
MEM_freeN(dvert->dw);
}
dvert->dw = dw_new;
}
else {
/* If there are no other deform weights left then just remove this one. */
MEM_freeN(dvert->dw);
dvert->dw = NULL;
}
}

47
source/blender/modifiers/intern/MOD_weightvg_util.c
View File

@ -240,51 +240,6 @@ static void defvert_add_to_group(MDeformVert *dv, int defgrp_idx, const float we
dv->totweight++;
}
/* Removes the given vertex from the vertex group, specified either by its defgrp_idx,
* or directly by its MDeformWeight pointer, if dw is not NULL.
* WARNING: This function frees the given MDeformWeight, do not use it afterward! */
static void defvert_remove_from_group(MDeformVert *dv, int defgrp_idx, MDeformWeight *dw)
{
/* TODO, move this into deform.c as a generic function. */
MDeformWeight *newdw;
int i;
/* Get index of removed MDeformWeight. */
if(dw == NULL) {
dw = dv->dw;
for (i = dv->totweight; i > 0; i--, dw++) {
if (dw->def_nr == defgrp_idx)
break;
}
i--;
}
else {
i = dw - dv->dw;
/* Security check! */
if(i < 0 || i >= dv->totweight)
return;
}
dv->totweight--;
/* If there are still other deform weights attached to this vert then remove
* this deform weight, and reshuffle the others.
*/
if(dv->totweight) {
newdw = MEM_mallocN(sizeof(MDeformWeight)*(dv->totweight), "defvert_remove_from_group, new deformWeight");
if(dv->dw){
memcpy(newdw, dv->dw, sizeof(MDeformWeight)*i);
memcpy(newdw+i, dv->dw+i+1, sizeof(MDeformWeight)*(dv->totweight-i));
MEM_freeN(dv->dw);
}
dv->dw = newdw;
}
/* If there are no other deform weights left then just remove this one. */
else {
MEM_freeN(dv->dw);
dv->dw = NULL;
}
}
/* Applies weights to given vgroup (defgroup), and optionnaly add/remove vertices from the group.
* If dws is not NULL, it must be an array of MDeformWeight pointers of same length as weights (and
@ -309,7 +264,7 @@ void weightvg_update_vg(MDeformVert *dvert, int defgrp_idx, MDeformWeight **dws,
/* 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_from_group(dv, defgrp_idx, dw);
defvert_remove_index(dv, defgrp_idx, dw);
}
else {
dw->weight = w;