2a3688526d0a96082721a1bbbcc9d12f9e13feb5
[blender.git] / 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, int 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, int 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 }