Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
[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_object_deform.h"
47 #include "BKE_report.h"
48 #include "BKE_subsurf.h"
49 #include "BKE_modifier.h"
50
51 #include "ED_armature.h"
52 #include "ED_mesh.h"
53
54 #include "eigen_capi.h"
55
56 #include "armature_intern.h"
57 #include "meshlaplacian.h"
58
59 #if 0
60 #include "reeb.h"
61 #endif
62
63 /* ********************************** Bone Skinning *********************************************** */
64
65 static int bone_skinnable_cb(Object *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; } *data = datap;
92
93         if (!(ob->mode & OB_MODE_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; } *data = datap;
157         int wpmode = (ob->mode & OB_MODE_WEIGHT_PAINT);
158         bArmature *arm = data->armob->data;
159
160         if (!wpmode || !(bone->flag & BONE_HIDDEN_P)) {
161                 if (!(bone->flag & BONE_NO_DEFORM)) {
162                         if (data->heat && data->armob->pose && BKE_pose_channel_find_name(data->armob->pose, bone->name))
163                                 segments = bone->segments;
164                         else
165                                 segments = 1;
166                         
167                         if (!wpmode || ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED))) {
168                                 if (!(defgroup = defgroup_find_name(ob, bone->name))) {
169                                         defgroup = BKE_object_defgroup_add_name(ob, bone->name);
170                                 }
171                                 else if (defgroup->flag & DG_LOCK_WEIGHT) {
172                                         /* In case vgroup already exists and is locked, do not modify it here. See T43814. */
173                                         defgroup = NULL;
174                                 }
175                         }
176                         
177                         if (data->list != NULL) {
178                                 hgroup = (bDeformGroup ***) &data->list;
179                                 
180                                 for (a = 0; a < segments; a++) {
181                                         **hgroup = defgroup;
182                                         ++*hgroup;
183                                 }
184                         }
185                         return segments;
186                 }
187         }
188         return 0;
189 }
190
191 static void envelope_bone_weighting(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(ReportList *reports, Scene *scene, Object *ob, Object *par,
250                                  int heat, const bool mirror)
251 {
252         /* This functions implements the automatic computation of vertex group
253          * weights, either through envelopes or using a heat equilibrium.
254          *
255          * This function can be called both when parenting a mesh to an armature,
256          * or in weightpaint + posemode. In the latter case selection is taken
257          * into account and vertex weights can be mirrored.
258          *
259          * The mesh vertex positions used are either the final deformed coords
260          * from the derivedmesh in weightpaint mode, the final subsurf coords
261          * when parenting, or simply the original mesh coords.
262          */
263
264         bArmature *arm = par->data;
265         Bone **bonelist, *bone;
266         bDeformGroup **dgrouplist, **dgroupflip;
267         bDeformGroup *dgroup;
268         bPoseChannel *pchan;
269         Mesh *mesh;
270         Mat4 bbone_array[MAX_BBONE_SUBDIV], *bbone = NULL;
271         float (*root)[3], (*tip)[3], (*verts)[3];
272         int *selected;
273         int numbones, vertsfilled = 0, i, j, segments = 0;
274         int wpmode = (ob->mode & OB_MODE_WEIGHT_PAINT);
275         struct { Object *armob; void *list; int heat; } looper_data;
276
277         looper_data.armob = par;
278         looper_data.heat = heat;
279         looper_data.list = NULL;
280
281         /* count the number of skinnable bones */
282         numbones = bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
283         
284         if (numbones == 0)
285                 return;
286         
287         if (BKE_object_defgroup_data_create(ob->data) == NULL)
288                 return;
289
290         /* create an array of pointer to bones that are skinnable
291          * and fill it with all of the skinnable bones */
292         bonelist = MEM_callocN(numbones * sizeof(Bone *), "bonelist");
293         looper_data.list = bonelist;
294         bone_looper(ob, arm->bonebase.first, &looper_data, bone_skinnable_cb);
295
296         /* create an array of pointers to the deform groups that
297          * correspond to the skinnable bones (creating them
298          * as necessary. */
299         dgrouplist = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgrouplist");
300         dgroupflip = MEM_callocN(numbones * sizeof(bDeformGroup *), "dgroupflip");
301
302         looper_data.list = dgrouplist;
303         bone_looper(ob, arm->bonebase.first, &looper_data, dgroup_skinnable_cb);
304
305         /* create an array of root and tip positions transformed into
306          * global coords */
307         root = MEM_callocN(numbones * sizeof(float) * 3, "root");
308         tip = MEM_callocN(numbones * sizeof(float) * 3, "tip");
309         selected = MEM_callocN(numbones * sizeof(int), "selected");
310
311         for (j = 0; j < numbones; ++j) {
312                 bone = bonelist[j];
313                 dgroup = dgrouplist[j];
314                 
315                 /* handle bbone */
316                 if (heat) {
317                         if (segments == 0) {
318                                 segments = 1;
319                                 bbone = NULL;
320                                 
321                                 if ((par->pose) && (pchan = BKE_pose_channel_find_name(par->pose, bone->name))) {
322                                         if (bone->segments > 1) {
323                                                 segments = bone->segments;
324                                                 b_bone_spline_setup(pchan, 1, bbone_array);
325                                                 bbone = bbone_array;
326                                         }
327                                 }
328                         }
329                         
330                         segments--;
331                 }
332                 
333                 /* compute root and tip */
334                 if (bbone) {
335                         mul_v3_m4v3(root[j], bone->arm_mat, bbone[segments].mat[3]);
336                         if ((segments + 1) < bone->segments) {
337                                 mul_v3_m4v3(tip[j], bone->arm_mat, bbone[segments + 1].mat[3]);
338                         }
339                         else {
340                                 copy_v3_v3(tip[j], bone->arm_tail);
341                         }
342                 }
343                 else {
344                         copy_v3_v3(root[j], bone->arm_head);
345                         copy_v3_v3(tip[j], bone->arm_tail);
346                 }
347                 
348                 mul_m4_v3(par->obmat, root[j]);
349                 mul_m4_v3(par->obmat, tip[j]);
350                 
351                 /* set selected */
352                 if (wpmode) {
353                         if ((arm->layer & bone->layer) && (bone->flag & BONE_SELECTED))
354                                 selected[j] = 1;
355                 }
356                 else
357                         selected[j] = 1;
358                 
359                 /* find flipped group */
360                 if (dgroup && mirror) {
361                         char name_flip[MAXBONENAME];
362
363                         BKE_deform_flip_side_name(name_flip, dgroup->name, false);
364                         dgroupflip[j] = defgroup_find_name(ob, name_flip);
365                 }
366         }
367
368         /* create verts */
369         mesh = (Mesh *)ob->data;
370         verts = MEM_callocN(mesh->totvert * sizeof(*verts), "closestboneverts");
371
372         if (wpmode) {
373                 /* if in weight paint mode, use final verts from derivedmesh */
374                 DerivedMesh *dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH);
375                 
376                 if (dm->foreachMappedVert) {
377                         mesh_get_mapped_verts_coords(dm, verts, mesh->totvert);
378                         vertsfilled = 1;
379                 }
380                 
381                 dm->release(dm);
382         }
383         else if (modifiers_findByType(ob, eModifierType_Subsurf)) {
384                 /* is subsurf on? Lets use the verts on the limit surface then.
385                  * = same amount of vertices as mesh, but vertices  moved to the
386                  * subsurfed position, like for 'optimal'. */
387                 subsurf_calculate_limit_positions(mesh, verts);
388                 vertsfilled = 1;
389         }
390
391         /* transform verts to global space */
392         for (i = 0; i < mesh->totvert; i++) {
393                 if (!vertsfilled)
394                         copy_v3_v3(verts[i], mesh->mvert[i].co);
395                 mul_m4_v3(ob->obmat, verts[i]);
396         }
397
398         /* compute the weights based on gathered vertices and bones */
399         if (heat) {
400                 const char *error = NULL;
401
402                 heat_bone_weighting(ob, mesh, verts, numbones, dgrouplist, dgroupflip,
403                                     root, tip, selected, &error);
404                 if (error) {
405                         BKE_report(reports, RPT_WARNING, error);
406                 }
407         }
408         else {
409                 envelope_bone_weighting(ob, mesh, verts, numbones, bonelist, dgrouplist,
410                                         dgroupflip, root, tip, selected, mat4_to_scale(par->obmat));
411         }
412
413         /* only generated in some cases but can call anyway */
414         ED_mesh_mirror_spatial_table(ob, NULL, NULL, NULL, 'e');
415
416         /* free the memory allocated */
417         MEM_freeN(bonelist);
418         MEM_freeN(dgrouplist);
419         MEM_freeN(dgroupflip);
420         MEM_freeN(root);
421         MEM_freeN(tip);
422         MEM_freeN(selected);
423         MEM_freeN(verts);
424 }
425
426 void create_vgroups_from_armature(ReportList *reports, Scene *scene, Object *ob, Object *par,
427                                   const int mode, const bool mirror)
428 {
429         /* Lets try to create some vertex groups 
430          * based on the bones of the parent armature.
431          */
432         bArmature *arm = par->data;
433
434         if (mode == ARM_GROUPS_NAME) {
435                 const int defbase_tot = BLI_listbase_count(&ob->defbase);
436                 int defbase_add;
437                 /* Traverse the bone list, trying to create empty vertex 
438                  * groups corresponding to the bone.
439                  */
440                 defbase_add = bone_looper(ob, arm->bonebase.first, NULL, vgroup_add_unique_bone_cb);
441
442                 if (defbase_add) {
443                         /* its possible there are DWeight's outside the range of the current
444                          * objects deform groups, in this case the new groups wont be empty [#33889] */
445                         ED_vgroup_data_clamp_range(ob->data, defbase_tot);
446                 }
447         }
448         else if (ELEM(mode, ARM_GROUPS_ENVELOPE, ARM_GROUPS_AUTO)) {
449                 /* Traverse the bone list, trying to create vertex groups 
450                  * that are populated with the vertices for which the
451                  * bone is closest.
452                  */
453                 add_verts_to_dgroups(reports, scene, ob, par, (mode == ARM_GROUPS_AUTO), mirror);
454         }
455 }