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