Merge branch 'master' into blender2.8
[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 #include "BLI_string_utils.h"
43
44 #include "BKE_action.h"
45 #include "BKE_armature.h"
46 #include "BKE_context.h"
47 #include "BKE_deform.h"
48 #include "BKE_object_deform.h"
49 #include "BKE_report.h"
50 #include "BKE_subsurf.h"
51 #include "BKE_modifier.h"
52
53 #include "DEG_depsgraph.h"
54
55 #include "ED_armature.h"
56 #include "ED_mesh.h"
57
58 #include "eigen_capi.h"
59
60 #include "armature_intern.h"
61 #include "meshlaplacian.h"
62
63 /* ********************************** Bone Skinning *********************************************** */
64
65 static int bone_skinnable_cb(Object *UNUSED(ob), Bone *bone, void *datap)
66 {
67         /* Bones that are deforming
68          * are regarded to be "skinnable" and are eligible for
69          * auto-skinning.
70          *
71          * This function performs 2 functions:
72          *
73          *   a) It returns 1 if the bone is skinnable.
74          *      If we loop over all bones with this
75          *      function, we can count the number of
76          *      skinnable bones.
77          *   b) If the pointer data is non null,
78          *      it is treated like a handle to a
79          *      bone pointer -- the bone pointer
80          *      is set to point at this bone, and
81          *      the pointer the handle points to
82          *      is incremented to point to the
83          *      next member of an array of pointers
84          *      to bones. This way we can loop using
85          *      this function to construct an array of
86          *      pointers to bones that point to all
87          *      skinnable bones.
88          */
89         Bone ***hbone;
90         int a, segments;
91         struct { Object *armob; void *list; int heat; bool is_weight_paint; } *data = datap;
92
93         if (!(data->is_weight_paint) || !(bone->flag & BONE_HIDDEN_P)) {
94                 if (!(bone->flag & BONE_NO_DEFORM)) {
95                         if (data->heat && data->armob->pose && BKE_pose_channel_find_name(data->armob->pose, bone->name))
96                                 segments = bone->segments;
97                         else
98                                 segments = 1;
99
100                         if (data->list != NULL) {
101                                 hbone = (Bone ***) &data->list;
102
103                                 for (a = 0; a < segments; a++) {
104                                         **hbone = bone;
105                                         ++*hbone;
106                                 }
107                         }
108                         return segments;
109                 }
110         }
111         return 0;
112 }
113
114 static int vgroup_add_unique_bone_cb(Object *ob, Bone *bone, void *UNUSED(ptr))
115 {
116         /* This group creates a vertex group to ob that has the
117          * same name as bone (provided the bone is skinnable).
118          * If such a vertex group already exist the routine exits.
119          */
120         if (!(bone->flag & BONE_NO_DEFORM)) {
121                 if (!defgroup_find_name(ob, bone->name)) {
122                         BKE_object_defgroup_add_name(ob, bone->name);
123                         return 1;
124                 }
125         }
126         return 0;
127 }
128
129 static int dgroup_skinnable_cb(Object *ob, Bone *bone, void *datap)
130 {
131         /* Bones that are deforming
132          * are regarded to be "skinnable" and are eligible for
133          * auto-skinning.
134          *
135          * This function performs 2 functions:
136          *
137          *   a) If the bone is skinnable, it creates
138          *      a vertex group for ob that has
139          *      the name of the skinnable bone
140          *      (if one doesn't exist already).
141          *   b) If the pointer data is non null,
142          *      it is treated like a handle to a
143          *      bDeformGroup pointer -- the
144          *      bDeformGroup pointer is set to point
145          *      to the deform group with the bone's
146          *      name, and the pointer the handle
147          *      points to is incremented to point to the
148          *      next member of an array of pointers
149          *      to bDeformGroups. This way we can loop using
150          *      this function to construct an array of
151          *      pointers to bDeformGroups, all with names
152          *      of skinnable bones.
153          */
154         bDeformGroup ***hgroup, *defgroup = NULL;
155         int a, segments;
156         struct { Object *armob; void *list; int heat; bool is_weight_paint; } *data = datap;
157         bArmature *arm = data->armob->data;
158
159         if (!data->is_weight_paint || !(bone->flag & BONE_HIDDEN_P)) {
160                 if (!(bone->flag & BONE_NO_DEFORM)) {
161                         if (data->heat && data->armob->pose && BKE_pose_channel_find_name(data->armob->pose, bone->name))
162                                 segments = bone->segments;
163                         else
164                                 segments = 1;
165
166                         if (!data->is_weight_paint || ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED))) {
167                                 if (!(defgroup = defgroup_find_name(ob, bone->name))) {
168                                         defgroup = BKE_object_defgroup_add_name(ob, bone->name);
169                                 }
170                                 else if (defgroup->flag & DG_LOCK_WEIGHT) {
171                                         /* In case vgroup already exists and is locked, do not modify it here. See T43814. */
172                                         defgroup = NULL;
173                                 }
174                         }
175
176                         if (data->list != NULL) {
177                                 hgroup = (bDeformGroup ***) &data->list;
178
179                                 for (a = 0; a < segments; a++) {
180                                         **hgroup = defgroup;
181                                         ++*hgroup;
182                                 }
183                         }
184                         return segments;
185                 }
186         }
187         return 0;
188 }
189
190 static void envelope_bone_weighting(
191         Object *ob, Mesh *mesh, float (*verts)[3], int numbones, Bone **bonelist,
192         bDeformGroup **dgrouplist, bDeformGroup **dgroupflip,
193         float (*root)[3], float (*tip)[3], const int *selected, float scale)
194 {
195         /* Create vertex group weights from envelopes */
196
197         Bone *bone;
198         bDeformGroup *dgroup;
199         float distance;
200         int i, iflip, j;
201         bool use_topology = (mesh->editflag & ME_EDIT_MIRROR_TOPO) != 0;
202         bool use_mask = false;
203
204         if ((ob->mode & OB_MODE_WEIGHT_PAINT) &&
205             (mesh->editflag & (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL)))
206         {
207                 use_mask = true;
208         }
209
210         /* for each vertex in the mesh */
211         for (i = 0; i < mesh->totvert; i++) {
212
213                 if (use_mask && !(mesh->mvert[i].flag & SELECT)) {
214                         continue;
215                 }
216
217                 iflip = (dgroupflip) ? mesh_get_x_mirror_vert(ob, NULL, i, use_topology) : -1;
218
219                 /* for each skinnable bone */
220                 for (j = 0; j < numbones; ++j) {
221                         if (!selected[j])
222                                 continue;
223
224                         bone = bonelist[j];
225                         dgroup = dgrouplist[j];
226
227                         /* store the distance-factor from the vertex to the bone */
228                         distance = distfactor_to_bone(verts[i], root[j], tip[j],
229                                                       bone->rad_head * scale, bone->rad_tail * scale, bone->dist * scale);
230
231                         /* add the vert to the deform group if (weight != 0.0) */
232                         if (distance != 0.0f)
233                                 ED_vgroup_vert_add(ob, dgroup, i, distance, WEIGHT_REPLACE);
234                         else
235                                 ED_vgroup_vert_remove(ob, dgroup, i);
236
237                         /* do same for mirror */
238                         if (dgroupflip && dgroupflip[j] && iflip != -1) {
239                                 if (distance != 0.0f)
240                                         ED_vgroup_vert_add(ob, dgroupflip[j], iflip, distance,
241                                                            WEIGHT_REPLACE);
242                                 else
243                                         ED_vgroup_vert_remove(ob, dgroupflip[j], iflip);
244                         }
245                 }
246         }
247 }
248
249 static void add_verts_to_dgroups(
250         ReportList *reports, Depsgraph *depsgraph, Scene *scene, Object *ob, Object *par,
251         int heat, const bool mirror)
252 {
253         /* This functions implements the automatic computation of vertex group
254          * weights, either through envelopes or using a heat equilibrium.
255          *
256          * This function can be called both when parenting a mesh to an armature,
257          * or in weightpaint + posemode. In the latter case selection is taken
258          * into account and vertex weights can be mirrored.
259          *
260          * The mesh vertex positions used are either the final deformed coords
261          * from the derivedmesh in weightpaint mode, the final subsurf coords
262          * when parenting, or simply the original mesh coords.
263          */
264
265         bArmature *arm = par->data;
266         Bone **bonelist, *bone;
267         bDeformGroup **dgrouplist, **dgroupflip;
268         bDeformGroup *dgroup;
269         bPoseChannel *pchan;
270         Mesh *mesh;
271         Mat4 bbone_array[MAX_BBONE_SUBDIV], *bbone = NULL;
272         float (*root)[3], (*tip)[3], (*verts)[3];
273         int *selected;
274         int numbones, vertsfilled = 0, i, j, segments = 0;
275         const bool wpmode = (ob->mode & OB_MODE_WEIGHT_PAINT);
276         struct { Object *armob; void *list; int heat; bool is_weight_paint; } looper_data;
277
278         looper_data.armob = par;
279         looper_data.heat = heat;
280         looper_data.list = NULL;
281         looper_data.is_weight_paint = wpmode;
282
283         /* count the number of skinnable bones */
284         numbones = bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
285
286         if (numbones == 0)
287                 return;
288
289         if (BKE_object_defgroup_data_create(ob->data) == NULL)
290                 return;
291
292         /* create an array of pointer to bones that are skinnable
293          * and fill it with all of the skinnable bones */
294         bonelist = MEM_callocN(numbones * sizeof(Bone *), "bonelist");
295         looper_data.list = bonelist;
296         bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
297
298         /* create an array of pointers to the deform groups that
299          * correspond to the skinnable bones (creating them
300          * as necessary. */
301         dgrouplist = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgrouplist");
302         dgroupflip = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgroupflip");
303
304         looper_data.list = dgrouplist;
305         bone_looper(ob, arm->bonebase.first, &looper_data, dgroup_skinnable_cb);
306
307         /* create an array of root and tip positions transformed into
308          * global coords */
309         root = MEM_callocN(numbones * sizeof(float) * 3, "root");
310         tip = MEM_callocN(numbones * sizeof(float) * 3, "tip");
311         selected = MEM_callocN(numbones * sizeof(int), "selected");
312
313         for (j = 0; j < numbones; ++j) {
314                 bone = bonelist[j];
315                 dgroup = dgrouplist[j];
316
317                 /* handle bbone */
318                 if (heat) {
319                         if (segments == 0) {
320                                 segments = 1;
321                                 bbone = NULL;
322
323                                 if ((par->pose) && (pchan = BKE_pose_channel_find_name(par->pose, bone->name))) {
324                                         if (bone->segments > 1) {
325                                                 segments = bone->segments;
326                                                 b_bone_spline_setup(pchan, 1, bbone_array);
327                                                 bbone = bbone_array;
328                                         }
329                                 }
330                         }
331
332                         segments--;
333                 }
334
335                 /* compute root and tip */
336                 if (bbone) {
337                         mul_v3_m4v3(root[j], bone->arm_mat, bbone[segments].mat[3]);
338                         if ((segments + 1) < bone->segments) {
339                                 mul_v3_m4v3(tip[j], bone->arm_mat, bbone[segments + 1].mat[3]);
340                         }
341                         else {
342                                 copy_v3_v3(tip[j], bone->arm_tail);
343                         }
344                 }
345                 else {
346                         copy_v3_v3(root[j], bone->arm_head);
347                         copy_v3_v3(tip[j], bone->arm_tail);
348                 }
349
350                 mul_m4_v3(par->obmat, root[j]);
351                 mul_m4_v3(par->obmat, tip[j]);
352
353                 /* set selected */
354                 if (wpmode) {
355                         if ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED))
356                                 selected[j] = 1;
357                 }
358                 else
359                         selected[j] = 1;
360
361                 /* find flipped group */
362                 if (dgroup && mirror) {
363                         char name_flip[MAXBONENAME];
364
365                         BLI_string_flip_side_name(name_flip, dgroup->name, false, sizeof(name_flip));
366                         dgroupflip[j] = defgroup_find_name(ob, name_flip);
367                 }
368         }
369
370         /* create verts */
371         mesh = (Mesh *)ob->data;
372         verts = MEM_callocN(mesh->totvert * sizeof(*verts), "closestboneverts");
373
374         if (wpmode) {
375                 /* if in weight paint mode, use final verts from derivedmesh */
376                 DerivedMesh *dm = mesh_get_derived_final(depsgraph, scene, ob, CD_MASK_BAREMESH);
377
378                 if (dm->foreachMappedVert) {
379                         mesh_get_mapped_verts_coords(dm, verts, mesh->totvert);
380                         vertsfilled = 1;
381                 }
382
383                 dm->release(dm);
384         }
385         else if (modifiers_findByType(ob, eModifierType_Subsurf)) {
386                 /* is subsurf on? Lets use the verts on the limit surface then.
387                  * = same amount of vertices as mesh, but vertices  moved to the
388                  * subsurfed position, like for 'optimal'. */
389                 subsurf_calculate_limit_positions(mesh, verts);
390                 vertsfilled = 1;
391         }
392
393         /* transform verts to global space */
394         for (i = 0; i < mesh->totvert; i++) {
395                 if (!vertsfilled)
396                         copy_v3_v3(verts[i], mesh->mvert[i].co);
397                 mul_m4_v3(ob->obmat, verts[i]);
398         }
399
400         /* compute the weights based on gathered vertices and bones */
401         if (heat) {
402                 const char *error = NULL;
403
404                 heat_bone_weighting(
405                         ob, mesh, verts, numbones, dgrouplist, dgroupflip,
406                         root, tip, selected, &error);
407                 if (error) {
408                         BKE_report(reports, RPT_WARNING, error);
409                 }
410         }
411         else {
412                 envelope_bone_weighting(
413                         ob, mesh, verts, numbones, bonelist, dgrouplist,
414                         dgroupflip, root, tip, selected, mat4_to_scale(par->obmat));
415         }
416
417         /* only generated in some cases but can call anyway */
418         ED_mesh_mirror_spatial_table(ob, NULL, NULL, NULL, 'e');
419
420         /* free the memory allocated */
421         MEM_freeN(bonelist);
422         MEM_freeN(dgrouplist);
423         MEM_freeN(dgroupflip);
424         MEM_freeN(root);
425         MEM_freeN(tip);
426         MEM_freeN(selected);
427         MEM_freeN(verts);
428 }
429
430 void ED_object_vgroup_calc_from_armature(
431         ReportList *reports, Depsgraph *depsgraph, Scene *scene, Object *ob, Object *par,
432         const int mode, const bool mirror)
433 {
434         /* Lets try to create some vertex groups
435          * based on the bones of the parent armature.
436          */
437         bArmature *arm = par->data;
438
439         if (mode == ARM_GROUPS_NAME) {
440                 const int defbase_tot = BLI_listbase_count(&ob->defbase);
441                 int defbase_add;
442                 /* Traverse the bone list, trying to create empty vertex
443                  * groups corresponding to the bone.
444                  */
445                 defbase_add = bone_looper(ob, arm->bonebase.first, NULL, vgroup_add_unique_bone_cb);
446
447                 if (defbase_add) {
448                         /* its possible there are DWeight's outside the range of the current
449                          * objects deform groups, in this case the new groups wont be empty [#33889] */
450                         ED_vgroup_data_clamp_range(ob->data, defbase_tot);
451                 }
452         }
453         else if (ELEM(mode, ARM_GROUPS_ENVELOPE, ARM_GROUPS_AUTO)) {
454                 /* Traverse the bone list, trying to create vertex groups
455                  * that are populated with the vertices for which the
456                  * bone is closest.
457                  */
458                 add_verts_to_dgroups(reports, depsgraph, scene, ob, par, (mode == ARM_GROUPS_AUTO), mirror);
459         }
460 }