use consistent naming for deform.c, also moved defvert_remove_index into deform.c...
authorCampbell Barton <ideasman42@gmail.com>
Wed, 30 Nov 2011 07:39:54 +0000 (07:39 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 30 Nov 2011 07:39:54 +0000 (07:39 +0000)
source/blender/blenkernel/BKE_deform.h
source/blender/blenkernel/intern/deform.c
source/blender/modifiers/intern/MOD_weightvg_util.c

index 2dcafd769d873e6625a9a7565100c26288df874a..ed8ea6911346a28ae0b3a98967ccbb7ab2829358 100644 (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);
index 021433dee9e50a682351684096263bc85dc47dd1..1f09d98d697c359d92ed4641a5bcd6371c03095a 100644 (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);
-
-                       if(dw_r) {
-                               dw_r->weight= dw->weight;
+               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_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]);
-
-                               if(dw_r) {
-                                       dw_r->weight= dw->weight;
+               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_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  */
-       ifIS_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 ifIS_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 dw_new;
+}
 
-       return newdw;
+/* 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;
+       }
 }
index c2a9ae7555d7e04d25da1d547a43d38517f214e2..e206000f41ddbe305a73a4fce873ee655edd2ad3 100644 (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;