source/blender/editors/armature/armature_skinning.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  19  * All rights reserved.
  20  *
  21  * Contributor(s): Blender Foundation, 2002-2009 full recode.
  22  *
  23  * ***** END GPL LICENSE BLOCK *****
  24  *
  25  * API's for creating vertex groups from bones
  26  * - Interfaces with heat weighting in meshlaplacian
  27  */
  28
  29 /** \file blender/editors/armature/armature_skinning.c
  30  *  \ingroup edarmature
  31  */
  32
  33 #include "DNA_mesh_types.h"
  34 #include "DNA_armature_types.h"
  35 #include "DNA_object_types.h"
  36 #include "DNA_scene_types.h"
  37
  38 #include "MEM_guardedalloc.h"
  39
  40 #include "BLI_blenlib.h"
  41 #include "BLI_math.h"
  42
  43 #include "BKE_action.h"
  44 #include "BKE_armature.h"
  45 #include "BKE_deform.h"
  46 #include "BKE_report.h"
  47 #include "BKE_subsurf.h"
  48 #include "BKE_modifier.h"
  49
  50 #include "ED_armature.h"
  51 #include "ED_mesh.h"
  52
  53
  54 #include "armature_intern.h"
  55 #include "meshlaplacian.h"
  56
  57 #if 0
  58 #include "reeb.h"
  59 #endif
  60
  61 /* ********************************** Bone Skinning *********************************************** */
  62
  63 static int bone_skinnable_cb(Object *ob, Bone *bone, void *datap)
  64 {
  65         /* Bones that are deforming
  66          * are regarded to be "skinnable" and are eligible for
  67          * auto-skinning.
  68          *
  69          * This function performs 2 functions:
  70          *
  71          *   a) It returns 1 if the bone is skinnable.
  72          *      If we loop over all bones with this
  73          *      function, we can count the number of
  74          *      skinnable bones.
  75          *   b) If the pointer data is non null,
  76          *      it is treated like a handle to a
  77          *      bone pointer -- the bone pointer
  78          *      is set to point at this bone, and
  79          *      the pointer the handle points to
  80          *      is incremented to point to the
  81          *      next member of an array of pointers
  82          *      to bones. This way we can loop using
  83          *      this function to construct an array of
  84          *      pointers to bones that point to all
  85          *      skinnable bones.
  86          */
  87         Bone ***hbone;
  88         int a, segments;
  89         struct { Object *armob; void *list; int heat; } *data = datap;
  90
  91         if (!(ob->mode & OB_MODE_WEIGHT_PAINT) || !(bone->flag & BONE_HIDDEN_P)) {
  92                 if (!(bone->flag & BONE_NO_DEFORM)) {
  93                         if (data->heat && data->armob->pose && BKE_pose_channel_find_name(data->armob->pose, bone->name))
  94                                 segments = bone->segments;
  95                         else
  96                                 segments = 1;
  97
  98                         if (data->list != NULL) {
  99                                 hbone = (Bone ***) &data->list;
 100
 101                                 for (a = 0; a < segments; a++) {
 102                                         **hbone = bone;
 103                                         ++*hbone;
 104                                 }
 105                         }
 106                         return segments;
 107                 }
 108         }
 109         return 0;
 110 }
 111
 112 static int vgroup_add_unique_bone_cb(Object *ob, Bone *bone, void *UNUSED(ptr))
 113 {
 114         /* This group creates a vertex group to ob that has the
 115          * same name as bone (provided the bone is skinnable).
 116          * If such a vertex group already exist the routine exits.
 117          */
 118         if (!(bone->flag & BONE_NO_DEFORM)) {
 119                 if (!defgroup_find_name(ob, bone->name)) {
 120                         ED_vgroup_add_name(ob, bone->name);
 121                         return 1;
 122                 }
 123         }
 124         return 0;
 125 }
 126
 127 static int dgroup_skinnable_cb(Object *ob, Bone *bone, void *datap)
 128 {
 129         /* Bones that are deforming
 130          * are regarded to be "skinnable" and are eligible for
 131          * auto-skinning.
 132          *
 133          * This function performs 2 functions:
 134          *
 135          *   a) If the bone is skinnable, it creates
 136          *      a vertex group for ob that has
 137          *      the name of the skinnable bone
 138          *      (if one doesn't exist already).
 139          *   b) If the pointer data is non null,
 140          *      it is treated like a handle to a
 141          *      bDeformGroup pointer -- the
 142          *      bDeformGroup pointer is set to point
 143          *      to the deform group with the bone's
 144          *      name, and the pointer the handle
 145          *      points to is incremented to point to the
 146          *      next member of an array of pointers
 147          *      to bDeformGroups. This way we can loop using
 148          *      this function to construct an array of
 149          *      pointers to bDeformGroups, all with names
 150          *      of skinnable bones.
 151          */
 152         bDeformGroup ***hgroup, *defgroup = NULL;
 153         int a, segments;
 154         struct { Object *armob; void *list; int heat; } *data = datap;
 155         int wpmode = (ob->mode & OB_MODE_WEIGHT_PAINT);
 156         bArmature *arm = data->armob->data;
 157
 158         if (!wpmode || !(bone->flag & BONE_HIDDEN_P)) {
 159                 if (!(bone->flag & BONE_NO_DEFORM)) {
 160                         if (data->heat && data->armob->pose && BKE_pose_channel_find_name(data->armob->pose, bone->name))
 161                                 segments = bone->segments;
 162                         else
 163                                 segments = 1;
 164
 165                         if (!wpmode || ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED)))
 166                                 if (!(defgroup = defgroup_find_name(ob, bone->name)))
 167                                         defgroup = ED_vgroup_add_name(ob, bone->name);
 168
 169                         if (data->list != NULL) {
 170                                 hgroup = (bDeformGroup ***) &data->list;
 171
 172                                 for (a = 0; a < segments; a++) {
 173                                         **hgroup = defgroup;
 174                                         ++*hgroup;
 175                                 }
 176                         }
 177                         return segments;
 178                 }
 179         }
 180         return 0;
 181 }
 182
 183 static void add_vgroups__mapFunc(void *userData, int index, const float co[3],
 184                                  const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
 185 {
 186         /* DerivedMesh mapFunc for getting final coords in weight paint mode */
 187
 188         float (*verts)[3] = userData;
 189         copy_v3_v3(verts[index], co);
 190 }
 191
 192 static void envelope_bone_weighting(Object *ob, Mesh *mesh, float (*verts)[3], int numbones, Bone **bonelist,
 193                                     bDeformGroup **dgrouplist, bDeformGroup **dgroupflip,
 194                                     float (*root)[3], float (*tip)[3], int *selected, float scale)
 195 {
 196         /* Create vertex group weights from envelopes */
 197
 198         Bone *bone;
 199         bDeformGroup *dgroup;
 200         float distance;
 201         int i, iflip, j;
 202         bool use_topology = (mesh->editflag & ME_EDIT_MIRROR_TOPO) != 0;
 203
 204         /* for each vertex in the mesh */
 205         for (i = 0; i < mesh->totvert; i++) {
 206                 iflip = (dgroupflip) ? mesh_get_x_mirror_vert(ob, i, use_topology) : 0;
 207
 208                 /* for each skinnable bone */
 209                 for (j = 0; j < numbones; ++j) {
 210                         if (!selected[j])
 211                                 continue;
 212
 213                         bone = bonelist[j];
 214                         dgroup = dgrouplist[j];
 215
 216                         /* store the distance-factor from the vertex to the bone */
 217                         distance = distfactor_to_bone(verts[i], root[j], tip[j],
 218                                                       bone->rad_head * scale, bone->rad_tail * scale, bone->dist * scale);
 219
 220                         /* add the vert to the deform group if (weight != 0.0) */
 221                         if (distance != 0.0f)
 222                                 ED_vgroup_vert_add(ob, dgroup, i, distance, WEIGHT_REPLACE);
 223                         else
 224                                 ED_vgroup_vert_remove(ob, dgroup, i);
 225
 226                         /* do same for mirror */
 227                         if (dgroupflip && dgroupflip[j] && iflip >= 0) {
 228                                 if (distance != 0.0f)
 229                                         ED_vgroup_vert_add(ob, dgroupflip[j], iflip, distance,
 230                                                            WEIGHT_REPLACE);
 231                                 else
 232                                         ED_vgroup_vert_remove(ob, dgroupflip[j], iflip);
 233                         }
 234                 }
 235         }
 236 }
 237
 238 static void add_verts_to_dgroups(ReportList *reports, Scene *scene, Object *ob, Object *par, int heat, bool mirror)
 239 {
 240         /* This functions implements the automatic computation of vertex group
 241          * weights, either through envelopes or using a heat equilibrium.
 242          *
 243          * This function can be called both when parenting a mesh to an armature,
 244          * or in weightpaint + posemode. In the latter case selection is taken
 245          * into account and vertex weights can be mirrored.
 246          *
 247          * The mesh vertex positions used are either the final deformed coords
 248          * from the derivedmesh in weightpaint mode, the final subsurf coords
 249          * when parenting, or simply the original mesh coords.
 250          */
 251
 252         bArmature *arm = par->data;
 253         Bone **bonelist, *bone;
 254         bDeformGroup **dgrouplist, **dgroupflip;
 255         bDeformGroup *dgroup;
 256         bPoseChannel *pchan;
 257         Mesh *mesh;
 258         Mat4 bbone_array[MAX_BBONE_SUBDIV], *bbone = NULL;
 259         float (*root)[3], (*tip)[3], (*verts)[3];
 260         int *selected;
 261         int numbones, vertsfilled = 0, i, j, segments = 0;
 262         int wpmode = (ob->mode & OB_MODE_WEIGHT_PAINT);
 263         struct { Object *armob; void *list; int heat; } looper_data;
 264
 265         looper_data.armob = par;
 266         looper_data.heat = heat;
 267         looper_data.list = NULL;
 268
 269         /* count the number of skinnable bones */
 270         numbones = bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
 271
 272         if (numbones == 0)
 273                 return;
 274
 275         if (ED_vgroup_data_create(ob->data) == FALSE)
 276                 return;
 277
 278         /* create an array of pointer to bones that are skinnable
 279          * and fill it with all of the skinnable bones */
 280         bonelist = MEM_callocN(numbones * sizeof(Bone *), "bonelist");
 281         looper_data.list = bonelist;
 282         bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
 283
 284         /* create an array of pointers to the deform groups that
 285          * correspond to the skinnable bones (creating them
 286          * as necessary. */
 287         dgrouplist = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgrouplist");
 288         dgroupflip = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgroupflip");
 289
 290         looper_data.list = dgrouplist;
 291         bone_looper(ob, arm->bonebase.first, &looper_data, dgroup_skinnable_cb);
 292
 293         /* create an array of root and tip positions transformed into
 294          * global coords */
 295         root = MEM_callocN(numbones * sizeof(float) * 3, "root");
 296         tip = MEM_callocN(numbones * sizeof(float) * 3, "tip");
 297         selected = MEM_callocN(numbones * sizeof(int), "selected");
 298
 299         for (j = 0; j < numbones; ++j) {
 300                 bone = bonelist[j];
 301                 dgroup = dgrouplist[j];
 302
 303                 /* handle bbone */
 304                 if (heat) {
 305                         if (segments == 0) {
 306                                 segments = 1;
 307                                 bbone = NULL;
 308
 309                                 if ((par->pose) && (pchan = BKE_pose_channel_find_name(par->pose, bone->name))) {
 310                                         if (bone->segments > 1) {
 311                                                 segments = bone->segments;
 312                                                 b_bone_spline_setup(pchan, 1, bbone_array);
 313                                                 bbone = bbone_array;
 314                                         }
 315                                 }
 316                         }
 317
 318                         segments--;
 319                 }
 320
 321                 /* compute root and tip */
 322                 if (bbone) {
 323                         mul_v3_m4v3(root[j], bone->arm_mat, bbone[segments].mat[3]);
 324                         if ((segments + 1) < bone->segments) {
 325                                 mul_v3_m4v3(tip[j], bone->arm_mat, bbone[segments + 1].mat[3]);
 326                         }
 327                         else {
 328                                 copy_v3_v3(tip[j], bone->arm_tail);
 329                         }
 330                 }
 331                 else {
 332                         copy_v3_v3(root[j], bone->arm_head);
 333                         copy_v3_v3(tip[j], bone->arm_tail);
 334                 }
 335
 336                 mul_m4_v3(par->obmat, root[j]);
 337                 mul_m4_v3(par->obmat, tip[j]);
 338
 339                 /* set selected */
 340                 if (wpmode) {
 341                         if ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED))
 342                                 selected[j] = 1;
 343                 }
 344                 else
 345                         selected[j] = 1;
 346
 347                 /* find flipped group */
 348                 if (dgroup && mirror) {
 349                         char name_flip[MAXBONENAME];
 350
 351                         BKE_deform_flip_side_name(name_flip, dgroup->name, false);
 352                         dgroupflip[j] = defgroup_find_name(ob, name_flip);
 353                 }
 354         }
 355
 356         /* create verts */
 357         mesh = (Mesh *)ob->data;
 358         verts = MEM_callocN(mesh->totvert * sizeof(*verts), "closestboneverts");
 359
 360         if (wpmode) {
 361                 /* if in weight paint mode, use final verts from derivedmesh */
 362                 DerivedMesh *dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
 363
 364                 if (dm->foreachMappedVert) {
 365                         dm->foreachMappedVert(dm, add_vgroups__mapFunc, (void *)verts, DM_FOREACH_NOP);
 366                         vertsfilled = 1;
 367                 }
 368
 369                 dm->release(dm);
 370         }
 371         else if (modifiers_findByType(ob, eModifierType_Subsurf)) {
 372                 /* is subsurf on? Lets use the verts on the limit surface then.
 373                  * = same amount of vertices as mesh, but vertices  moved to the
 374                  * subsurfed position, like for 'optimal'. */
 375                 subsurf_calculate_limit_positions(mesh, verts);
 376                 vertsfilled = 1;
 377         }
 378
 379         /* transform verts to global space */
 380         for (i = 0; i < mesh->totvert; i++) {
 381                 if (!vertsfilled)
 382                         copy_v3_v3(verts[i], mesh->mvert[i].co);
 383                 mul_m4_v3(ob->obmat, verts[i]);
 384         }
 385
 386         /* compute the weights based on gathered vertices and bones */
 387         if (heat) {
 388                 const char *error = NULL;
 389
 390 #ifdef WITH_OPENNL
 391                 heat_bone_weighting(ob, mesh, verts, numbones, dgrouplist, dgroupflip,
 392                                     root, tip, selected, &error);
 393 #else
 394                 error = "Built without OpenNL";
 395 #endif
 396                 if (error) {
 397                         BKE_report(reports, RPT_WARNING, error);
 398                 }
 399         }
 400         else {
 401                 envelope_bone_weighting(ob, mesh, verts, numbones, bonelist, dgrouplist,
 402                                         dgroupflip, root, tip, selected, mat4_to_scale(par->obmat));
 403         }
 404
 405         /* only generated in some cases but can call anyway */
 406         ED_mesh_mirror_spatial_table(ob, NULL, NULL, 'e');
 407
 408         /* free the memory allocated */
 409         MEM_freeN(bonelist);
 410         MEM_freeN(dgrouplist);
 411         MEM_freeN(dgroupflip);
 412         MEM_freeN(root);
 413         MEM_freeN(tip);
 414         MEM_freeN(selected);
 415         MEM_freeN(verts);
 416 }
 417
 418 void create_vgroups_from_armature(ReportList *reports, Scene *scene, Object *ob, Object *par, int mode, bool mirror)
 419 {
 420         /* Lets try to create some vertex groups
 421          * based on the bones of the parent armature.
 422          */
 423         bArmature *arm = par->data;
 424
 425         if (mode == ARM_GROUPS_NAME) {
 426                 const int defbase_tot = BLI_countlist(&ob->defbase);
 427                 int defbase_add;
 428                 /* Traverse the bone list, trying to create empty vertex
 429                  * groups corresponding to the bone.
 430                  */
 431                 defbase_add = bone_looper(ob, arm->bonebase.first, NULL, vgroup_add_unique_bone_cb);
 432
 433                 if (defbase_add) {
 434                         /* its possible there are DWeight's outside the range of the current
 435                          * objects deform groups, in this case the new groups wont be empty [#33889] */
 436                         ED_vgroup_data_clamp_range(ob->data, defbase_tot);
 437                 }
 438         }
 439         else if (mode == ARM_GROUPS_ENVELOPE || mode == ARM_GROUPS_AUTO) {
 440                 /* Traverse the bone list, trying to create vertex groups
 441                  * that are populated with the vertices for which the
 442                  * bone is closest.
 443                  */
 444                 add_verts_to_dgroups(reports, scene, ob, par, (mode == ARM_GROUPS_AUTO), mirror);
 445         }
 446 }