Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / armature / armature_skinning.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  * API's for creating vertex groups from bones
19  * - Interfaces with heat weighting in meshlaplacian
20  */
21
22 /** \file
23  * \ingroup edarmature
24  */
25
26 #include "DNA_mesh_types.h"
27 #include "DNA_armature_types.h"
28 #include "DNA_object_types.h"
29 #include "DNA_scene_types.h"
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_blenlib.h"
34 #include "BLI_math.h"
35 #include "BLI_string_utils.h"
36
37 #include "BKE_action.h"
38 #include "BKE_armature.h"
39 #include "BKE_deform.h"
40 #include "BKE_mesh_iterators.h"
41 #include "BKE_mesh_runtime.h"
42 #include "BKE_modifier.h"
43 #include "BKE_object_deform.h"
44 #include "BKE_report.h"
45 #include "BKE_subsurf.h"
46
47 #include "DEG_depsgraph.h"
48 #include "DEG_depsgraph_query.h"
49
50 #include "ED_armature.h"
51 #include "ED_mesh.h"
52
53 #include "eigen_capi.h"
54
55 #include "armature_intern.h"
56 #include "meshlaplacian.h"
57
58 /* ******************************* Bone Skinning *********************************************** */
59
60 static int bone_skinnable_cb(Object *UNUSED(ob), Bone *bone, void *datap)
61 {
62   /* Bones that are deforming
63    * are regarded to be "skinnable" and are eligible for
64    * auto-skinning.
65    *
66    * This function performs 2 functions:
67    *
68    *   a) It returns 1 if the bone is skinnable.
69    *      If we loop over all bones with this
70    *      function, we can count the number of
71    *      skinnable bones.
72    *   b) If the pointer data is non null,
73    *      it is treated like a handle to a
74    *      bone pointer -- the bone pointer
75    *      is set to point at this bone, and
76    *      the pointer the handle points to
77    *      is incremented to point to the
78    *      next member of an array of pointers
79    *      to bones. This way we can loop using
80    *      this function to construct an array of
81    *      pointers to bones that point to all
82    *      skinnable bones.
83    */
84   Bone ***hbone;
85   int a, segments;
86   struct {
87     Object *armob;
88     void *list;
89     int heat;
90     bool is_weight_paint;
91   } *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 &&
96           BKE_pose_channel_find_name(data->armob->pose, bone->name)) {
97         segments = bone->segments;
98       }
99       else {
100         segments = 1;
101       }
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 {
160     Object *armob;
161     void *list;
162     int heat;
163     bool is_weight_paint;
164   } *data = datap;
165   bArmature *arm = data->armob->data;
166
167   if (!data->is_weight_paint || !(bone->flag & BONE_HIDDEN_P)) {
168     if (!(bone->flag & BONE_NO_DEFORM)) {
169       if (data->heat && data->armob->pose &&
170           BKE_pose_channel_find_name(data->armob->pose, bone->name)) {
171         segments = bone->segments;
172       }
173       else {
174         segments = 1;
175       }
176
177       if (!data->is_weight_paint || ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED))) {
178         if (!(defgroup = defgroup_find_name(ob, bone->name))) {
179           defgroup = BKE_object_defgroup_add_name(ob, bone->name);
180         }
181         else if (defgroup->flag & DG_LOCK_WEIGHT) {
182           /* In case vgroup already exists and is locked, do not modify it here. See T43814. */
183           defgroup = NULL;
184         }
185       }
186
187       if (data->list != NULL) {
188         hgroup = (bDeformGroup ***)&data->list;
189
190         for (a = 0; a < segments; a++) {
191           **hgroup = defgroup;
192           (*hgroup)++;
193         }
194       }
195       return segments;
196     }
197   }
198   return 0;
199 }
200
201 static void envelope_bone_weighting(Object *ob,
202                                     Mesh *mesh,
203                                     float (*verts)[3],
204                                     int numbones,
205                                     Bone **bonelist,
206                                     bDeformGroup **dgrouplist,
207                                     bDeformGroup **dgroupflip,
208                                     float (*root)[3],
209                                     float (*tip)[3],
210                                     const int *selected,
211                                     float scale)
212 {
213   /* Create vertex group weights from envelopes */
214
215   Bone *bone;
216   bDeformGroup *dgroup;
217   float distance;
218   int i, iflip, j;
219   bool use_topology = (mesh->editflag & ME_EDIT_MIRROR_TOPO) != 0;
220   bool use_mask = false;
221
222   if ((ob->mode & OB_MODE_WEIGHT_PAINT) &&
223       (mesh->editflag & (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL))) {
224     use_mask = true;
225   }
226
227   /* for each vertex in the mesh */
228   for (i = 0; i < mesh->totvert; i++) {
229
230     if (use_mask && !(mesh->mvert[i].flag & SELECT)) {
231       continue;
232     }
233
234     iflip = (dgroupflip) ? mesh_get_x_mirror_vert(ob, NULL, i, use_topology) : -1;
235
236     /* for each skinnable bone */
237     for (j = 0; j < numbones; ++j) {
238       if (!selected[j]) {
239         continue;
240       }
241
242       bone = bonelist[j];
243       dgroup = dgrouplist[j];
244
245       /* store the distance-factor from the vertex to the bone */
246       distance = distfactor_to_bone(verts[i],
247                                     root[j],
248                                     tip[j],
249                                     bone->rad_head * scale,
250                                     bone->rad_tail * scale,
251                                     bone->dist * scale);
252
253       /* add the vert to the deform group if (weight != 0.0) */
254       if (distance != 0.0f) {
255         ED_vgroup_vert_add(ob, dgroup, i, distance, WEIGHT_REPLACE);
256       }
257       else {
258         ED_vgroup_vert_remove(ob, dgroup, i);
259       }
260
261       /* do same for mirror */
262       if (dgroupflip && dgroupflip[j] && iflip != -1) {
263         if (distance != 0.0f) {
264           ED_vgroup_vert_add(ob, dgroupflip[j], iflip, distance, WEIGHT_REPLACE);
265         }
266         else {
267           ED_vgroup_vert_remove(ob, dgroupflip[j], iflip);
268         }
269       }
270     }
271   }
272 }
273
274 static void add_verts_to_dgroups(ReportList *reports,
275                                  Depsgraph *depsgraph,
276                                  Scene *UNUSED(scene),
277                                  Object *ob,
278                                  Object *par,
279                                  int heat,
280                                  const bool mirror)
281 {
282   /* This functions implements the automatic computation of vertex group
283    * weights, either through envelopes or using a heat equilibrium.
284    *
285    * This function can be called both when parenting a mesh to an armature,
286    * or in weightpaint + posemode. In the latter case selection is taken
287    * into account and vertex weights can be mirrored.
288    *
289    * The mesh vertex positions used are either the final deformed coords
290    * from the evaluated mesh in weightpaint mode, the final subsurf coords
291    * when parenting, or simply the original mesh coords.
292    */
293
294   bArmature *arm = par->data;
295   Bone **bonelist, *bone;
296   bDeformGroup **dgrouplist, **dgroupflip;
297   bDeformGroup *dgroup;
298   bPoseChannel *pchan;
299   Mesh *mesh;
300   Mat4 bbone_array[MAX_BBONE_SUBDIV], *bbone = NULL;
301   float(*root)[3], (*tip)[3], (*verts)[3];
302   int *selected;
303   int numbones, vertsfilled = 0, i, j, segments = 0;
304   const bool wpmode = (ob->mode & OB_MODE_WEIGHT_PAINT);
305   struct {
306     Object *armob;
307     void *list;
308     int heat;
309     bool is_weight_paint;
310   } looper_data;
311
312   looper_data.armob = par;
313   looper_data.heat = heat;
314   looper_data.list = NULL;
315   looper_data.is_weight_paint = wpmode;
316
317   /* count the number of skinnable bones */
318   numbones = bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
319
320   if (numbones == 0) {
321     return;
322   }
323
324   if (BKE_object_defgroup_data_create(ob->data) == NULL) {
325     return;
326   }
327
328   /* create an array of pointer to bones that are skinnable
329    * and fill it with all of the skinnable bones */
330   bonelist = MEM_callocN(numbones * sizeof(Bone *), "bonelist");
331   looper_data.list = bonelist;
332   bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
333
334   /* create an array of pointers to the deform groups that
335    * correspond to the skinnable bones (creating them
336    * as necessary. */
337   dgrouplist = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgrouplist");
338   dgroupflip = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgroupflip");
339
340   looper_data.list = dgrouplist;
341   bone_looper(ob, arm->bonebase.first, &looper_data, dgroup_skinnable_cb);
342
343   /* create an array of root and tip positions transformed into
344    * global coords */
345   root = MEM_callocN(numbones * sizeof(float) * 3, "root");
346   tip = MEM_callocN(numbones * sizeof(float) * 3, "tip");
347   selected = MEM_callocN(numbones * sizeof(int), "selected");
348
349   for (j = 0; j < numbones; ++j) {
350     bone = bonelist[j];
351     dgroup = dgrouplist[j];
352
353     /* handle bbone */
354     if (heat) {
355       if (segments == 0) {
356         segments = 1;
357         bbone = NULL;
358
359         if ((par->pose) && (pchan = BKE_pose_channel_find_name(par->pose, bone->name))) {
360           if (bone->segments > 1) {
361             segments = bone->segments;
362             BKE_pchan_bbone_spline_setup(pchan, true, false, bbone_array);
363             bbone = bbone_array;
364           }
365         }
366       }
367
368       segments--;
369     }
370
371     /* compute root and tip */
372     if (bbone) {
373       mul_v3_m4v3(root[j], bone->arm_mat, bbone[segments].mat[3]);
374       if ((segments + 1) < bone->segments) {
375         mul_v3_m4v3(tip[j], bone->arm_mat, bbone[segments + 1].mat[3]);
376       }
377       else {
378         copy_v3_v3(tip[j], bone->arm_tail);
379       }
380     }
381     else {
382       copy_v3_v3(root[j], bone->arm_head);
383       copy_v3_v3(tip[j], bone->arm_tail);
384     }
385
386     mul_m4_v3(par->obmat, root[j]);
387     mul_m4_v3(par->obmat, tip[j]);
388
389     /* set selected */
390     if (wpmode) {
391       if ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED)) {
392         selected[j] = 1;
393       }
394     }
395     else {
396       selected[j] = 1;
397     }
398
399     /* find flipped group */
400     if (dgroup && mirror) {
401       char name_flip[MAXBONENAME];
402
403       BLI_string_flip_side_name(name_flip, dgroup->name, false, sizeof(name_flip));
404       dgroupflip[j] = defgroup_find_name(ob, name_flip);
405     }
406   }
407
408   /* create verts */
409   mesh = (Mesh *)ob->data;
410   verts = MEM_callocN(mesh->totvert * sizeof(*verts), "closestboneverts");
411
412   if (wpmode) {
413     /* if in weight paint mode, use final verts from evaluated mesh */
414     Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
415     Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
416     Mesh *me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
417
418     BKE_mesh_foreach_mapped_vert_coords_get(me_eval, verts, mesh->totvert);
419     vertsfilled = 1;
420   }
421   else if (modifiers_findByType(ob, eModifierType_Subsurf)) {
422     /* is subsurf on? Lets use the verts on the limit surface then.
423      * = same amount of vertices as mesh, but vertices  moved to the
424      * subsurfed position, like for 'optimal'. */
425     subsurf_calculate_limit_positions(mesh, verts);
426     vertsfilled = 1;
427   }
428
429   /* transform verts to global space */
430   for (i = 0; i < mesh->totvert; i++) {
431     if (!vertsfilled) {
432       copy_v3_v3(verts[i], mesh->mvert[i].co);
433     }
434     mul_m4_v3(ob->obmat, verts[i]);
435   }
436
437   /* compute the weights based on gathered vertices and bones */
438   if (heat) {
439     const char *error = NULL;
440
441     heat_bone_weighting(
442         ob, mesh, verts, numbones, dgrouplist, dgroupflip, root, tip, selected, &error);
443     if (error) {
444       BKE_report(reports, RPT_WARNING, error);
445     }
446   }
447   else {
448     envelope_bone_weighting(ob,
449                             mesh,
450                             verts,
451                             numbones,
452                             bonelist,
453                             dgrouplist,
454                             dgroupflip,
455                             root,
456                             tip,
457                             selected,
458                             mat4_to_scale(par->obmat));
459   }
460
461   /* only generated in some cases but can call anyway */
462   ED_mesh_mirror_spatial_table(ob, NULL, NULL, NULL, 'e');
463
464   /* free the memory allocated */
465   MEM_freeN(bonelist);
466   MEM_freeN(dgrouplist);
467   MEM_freeN(dgroupflip);
468   MEM_freeN(root);
469   MEM_freeN(tip);
470   MEM_freeN(selected);
471   MEM_freeN(verts);
472 }
473
474 void ED_object_vgroup_calc_from_armature(ReportList *reports,
475                                          Depsgraph *depsgraph,
476                                          Scene *scene,
477                                          Object *ob,
478                                          Object *par,
479                                          const int mode,
480                                          const bool mirror)
481 {
482   /* Lets try to create some vertex groups
483    * based on the bones of the parent armature.
484    */
485   bArmature *arm = par->data;
486
487   if (mode == ARM_GROUPS_NAME) {
488     const int defbase_tot = BLI_listbase_count(&ob->defbase);
489     int defbase_add;
490     /* Traverse the bone list, trying to create empty vertex
491      * groups corresponding to the bone.
492      */
493     defbase_add = bone_looper(ob, arm->bonebase.first, NULL, vgroup_add_unique_bone_cb);
494
495     if (defbase_add) {
496       /* its possible there are DWeight's outside the range of the current
497        * objects deform groups, in this case the new groups wont be empty [#33889] */
498       ED_vgroup_data_clamp_range(ob->data, defbase_tot);
499     }
500   }
501   else if (ELEM(mode, ARM_GROUPS_ENVELOPE, ARM_GROUPS_AUTO)) {
502     /* Traverse the bone list, trying to create vertex groups
503      * that are populated with the vertices for which the
504      * bone is closest.
505      */
506     add_verts_to_dgroups(reports, depsgraph, scene, ob, par, (mode == ARM_GROUPS_AUTO), mirror);
507   }
508 }