Fix T70439: Local view always including new objects
[blender.git] / source / blender / editors / transform / transform_convert_armature.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  */
19
20 /** \file
21  * \ingroup edtransform
22  */
23
24 #include "DNA_armature_types.h"
25 #include "DNA_constraint_types.h"
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLI_math.h"
30
31 #include "BKE_action.h"
32 #include "BKE_armature.h"
33 #include "BKE_constraint.h"
34 #include "BKE_context.h"
35 #include "BKE_main.h"
36 #include "BKE_report.h"
37
38 #include "BIK_api.h"
39
40 #include "ED_armature.h"
41
42 #include "DEG_depsgraph.h"
43 #include "DEG_depsgraph_query.h"
44
45 #include "transform.h"
46 #include "transform_convert.h"
47
48 bKinematicConstraint *has_targetless_ik(bPoseChannel *pchan)
49 {
50   bConstraint *con = pchan->constraints.first;
51
52   for (; con; con = con->next) {
53     if (con->type == CONSTRAINT_TYPE_KINEMATIC && (con->enforce != 0.0f)) {
54       bKinematicConstraint *data = con->data;
55
56       if (data->tar == NULL) {
57         return data;
58       }
59       if (data->tar->type == OB_ARMATURE && data->subtarget[0] == 0) {
60         return data;
61       }
62     }
63   }
64   return NULL;
65 }
66
67 static void add_pose_transdata(
68     TransInfo *t, bPoseChannel *pchan, Object *ob, TransDataContainer *tc, TransData *td)
69 {
70   Bone *bone = pchan->bone;
71   float pmat[3][3], omat[3][3];
72   float cmat[3][3], tmat[3][3];
73   float vec[3];
74
75   copy_v3_v3(vec, pchan->pose_mat[3]);
76   copy_v3_v3(td->center, vec);
77
78   td->ob = ob;
79   td->flag = TD_SELECTED;
80   if (bone->flag & BONE_HINGE_CHILD_TRANSFORM) {
81     td->flag |= TD_NOCENTER;
82   }
83
84   if (bone->flag & BONE_TRANSFORM_CHILD) {
85     td->flag |= TD_NOCENTER;
86     td->flag |= TD_NO_LOC;
87   }
88
89   td->protectflag = pchan->protectflag;
90
91   td->loc = pchan->loc;
92   copy_v3_v3(td->iloc, pchan->loc);
93
94   td->ext->size = pchan->size;
95   copy_v3_v3(td->ext->isize, pchan->size);
96
97   if (pchan->rotmode > 0) {
98     td->ext->rot = pchan->eul;
99     td->ext->rotAxis = NULL;
100     td->ext->rotAngle = NULL;
101     td->ext->quat = NULL;
102
103     copy_v3_v3(td->ext->irot, pchan->eul);
104   }
105   else if (pchan->rotmode == ROT_MODE_AXISANGLE) {
106     td->ext->rot = NULL;
107     td->ext->rotAxis = pchan->rotAxis;
108     td->ext->rotAngle = &pchan->rotAngle;
109     td->ext->quat = NULL;
110
111     td->ext->irotAngle = pchan->rotAngle;
112     copy_v3_v3(td->ext->irotAxis, pchan->rotAxis);
113   }
114   else {
115     td->ext->rot = NULL;
116     td->ext->rotAxis = NULL;
117     td->ext->rotAngle = NULL;
118     td->ext->quat = pchan->quat;
119
120     copy_qt_qt(td->ext->iquat, pchan->quat);
121   }
122   td->ext->rotOrder = pchan->rotmode;
123
124   /* proper way to get parent transform + own transform + constraints transform */
125   copy_m3_m4(omat, ob->obmat);
126
127   /* New code, using "generic" BKE_bone_parent_transform_calc_from_pchan(). */
128   {
129     BoneParentTransform bpt;
130     float rpmat[3][3];
131
132     BKE_bone_parent_transform_calc_from_pchan(pchan, &bpt);
133     if (t->mode == TFM_TRANSLATION) {
134       copy_m3_m4(pmat, bpt.loc_mat);
135     }
136     else {
137       copy_m3_m4(pmat, bpt.rotscale_mat);
138     }
139
140     /* Grrr! Exceptional case: When translating pose bones that are either Hinge or NoLocal,
141      * and want align snapping, we just need both loc_mat and rotscale_mat.
142      * So simply always store rotscale mat in td->ext, and always use it to apply rotations...
143      * Ugly to need such hacks! :/ */
144     copy_m3_m4(rpmat, bpt.rotscale_mat);
145
146     if (constraints_list_needinv(t, &pchan->constraints)) {
147       copy_m3_m4(tmat, pchan->constinv);
148       invert_m3_m3(cmat, tmat);
149       mul_m3_series(td->mtx, cmat, omat, pmat);
150       mul_m3_series(td->ext->r_mtx, cmat, omat, rpmat);
151     }
152     else {
153       mul_m3_series(td->mtx, omat, pmat);
154       mul_m3_series(td->ext->r_mtx, omat, rpmat);
155     }
156     invert_m3_m3(td->ext->r_smtx, td->ext->r_mtx);
157   }
158
159   pseudoinverse_m3_m3(td->smtx, td->mtx, PSEUDOINVERSE_EPSILON);
160
161   /* exceptional case: rotate the pose bone which also applies transformation
162    * when a parentless bone has BONE_NO_LOCAL_LOCATION [] */
163   if (!ELEM(t->mode, TFM_TRANSLATION, TFM_RESIZE) &&
164       (pchan->bone->flag & BONE_NO_LOCAL_LOCATION)) {
165     if (pchan->parent) {
166       /* same as td->smtx but without pchan->bone->bone_mat */
167       td->flag |= TD_PBONE_LOCAL_MTX_C;
168       mul_m3_m3m3(td->ext->l_smtx, pchan->bone->bone_mat, td->smtx);
169     }
170     else {
171       td->flag |= TD_PBONE_LOCAL_MTX_P;
172     }
173   }
174
175   /* for axismat we use bone's own transform */
176   copy_m3_m4(pmat, pchan->pose_mat);
177   mul_m3_m3m3(td->axismtx, omat, pmat);
178   normalize_m3(td->axismtx);
179
180   if (ELEM(t->mode, TFM_BONESIZE, TFM_BONE_ENVELOPE_DIST)) {
181     bArmature *arm = tc->poseobj->data;
182
183     if ((t->mode == TFM_BONE_ENVELOPE_DIST) || (arm->drawtype == ARM_ENVELOPE)) {
184       td->loc = NULL;
185       td->val = &bone->dist;
186       td->ival = bone->dist;
187     }
188     else {
189       // abusive storage of scale in the loc pointer :)
190       td->loc = &bone->xwidth;
191       copy_v3_v3(td->iloc, td->loc);
192       td->val = NULL;
193     }
194   }
195
196   /* in this case we can do target-less IK grabbing */
197   if (t->mode == TFM_TRANSLATION) {
198     bKinematicConstraint *data = has_targetless_ik(pchan);
199     if (data) {
200       if (data->flag & CONSTRAINT_IK_TIP) {
201         copy_v3_v3(data->grabtarget, pchan->pose_tail);
202       }
203       else {
204         copy_v3_v3(data->grabtarget, pchan->pose_head);
205       }
206       td->loc = data->grabtarget;
207       copy_v3_v3(td->iloc, td->loc);
208       data->flag |= CONSTRAINT_IK_AUTO;
209
210       /* only object matrix correction */
211       copy_m3_m3(td->mtx, omat);
212       pseudoinverse_m3_m3(td->smtx, td->mtx, PSEUDOINVERSE_EPSILON);
213     }
214   }
215
216   /* store reference to first constraint */
217   td->con = pchan->constraints.first;
218 }
219
220 /* adds the IK to pchan - returns if added */
221 static short pose_grab_with_ik_add(bPoseChannel *pchan)
222 {
223   bKinematicConstraint *targetless = NULL;
224   bKinematicConstraint *data;
225   bConstraint *con;
226
227   /* Sanity check */
228   if (pchan == NULL) {
229     return 0;
230   }
231
232   /* Rule: not if there's already an IK on this channel */
233   for (con = pchan->constraints.first; con; con = con->next) {
234     if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
235       data = con->data;
236
237       if (data->tar == NULL || (data->tar->type == OB_ARMATURE && data->subtarget[0] == '\0')) {
238         /* make reference to constraint to base things off later
239          * (if it's the last targetless constraint encountered) */
240         targetless = (bKinematicConstraint *)con->data;
241
242         /* but, if this is a targetless IK, we make it auto anyway (for the children loop) */
243         if (con->enforce != 0.0f) {
244           data->flag |= CONSTRAINT_IK_AUTO;
245
246           /* if no chain length has been specified,
247            * just make things obey standard rotation locks too */
248           if (data->rootbone == 0) {
249             for (; pchan; pchan = pchan->parent) {
250               /* here, we set ik-settings for bone from pchan->protectflag */
251               // XXX: careful with quats/axis-angle rotations where we're locking 4d components
252               if (pchan->protectflag & OB_LOCK_ROTX) {
253                 pchan->ikflag |= BONE_IK_NO_XDOF_TEMP;
254               }
255               if (pchan->protectflag & OB_LOCK_ROTY) {
256                 pchan->ikflag |= BONE_IK_NO_YDOF_TEMP;
257               }
258               if (pchan->protectflag & OB_LOCK_ROTZ) {
259                 pchan->ikflag |= BONE_IK_NO_ZDOF_TEMP;
260               }
261             }
262           }
263
264           return 0;
265         }
266       }
267
268       if ((con->flag & CONSTRAINT_DISABLE) == 0 && (con->enforce != 0.0f)) {
269         return 0;
270       }
271     }
272   }
273
274   con = BKE_constraint_add_for_pose(NULL, pchan, "TempConstraint", CONSTRAINT_TYPE_KINEMATIC);
275
276   /* for draw, but also for detecting while pose solving */
277   pchan->constflag |= (PCHAN_HAS_IK | PCHAN_HAS_TARGET);
278
279   data = con->data;
280   if (targetless) {
281     /* if exists, use values from last targetless (but disabled) IK-constraint as base */
282     *data = *targetless;
283   }
284   else {
285     data->flag = CONSTRAINT_IK_TIP;
286   }
287   data->flag |= CONSTRAINT_IK_TEMP | CONSTRAINT_IK_AUTO | CONSTRAINT_IK_POS;
288   copy_v3_v3(data->grabtarget, pchan->pose_tail);
289
290   /* watch-it! has to be 0 here, since we're still on the
291    * same bone for the first time through the loop T25885. */
292   data->rootbone = 0;
293
294   /* we only include bones that are part of a continual connected chain */
295   do {
296     /* here, we set ik-settings for bone from pchan->protectflag */
297     // XXX: careful with quats/axis-angle rotations where we're locking 4d components
298     if (pchan->protectflag & OB_LOCK_ROTX) {
299       pchan->ikflag |= BONE_IK_NO_XDOF_TEMP;
300     }
301     if (pchan->protectflag & OB_LOCK_ROTY) {
302       pchan->ikflag |= BONE_IK_NO_YDOF_TEMP;
303     }
304     if (pchan->protectflag & OB_LOCK_ROTZ) {
305       pchan->ikflag |= BONE_IK_NO_ZDOF_TEMP;
306     }
307
308     /* now we count this pchan as being included */
309     data->rootbone++;
310
311     /* continue to parent, but only if we're connected to it */
312     if (pchan->bone->flag & BONE_CONNECTED) {
313       pchan = pchan->parent;
314     }
315     else {
316       pchan = NULL;
317     }
318   } while (pchan);
319
320   /* make a copy of maximum chain-length */
321   data->max_rootbone = data->rootbone;
322
323   return 1;
324 }
325
326 /* bone is a candidate to get IK, but we don't do it if it has children connected */
327 static short pose_grab_with_ik_children(bPose *pose, Bone *bone)
328 {
329   Bone *bonec;
330   short wentdeeper = 0, added = 0;
331
332   /* go deeper if children & children are connected */
333   for (bonec = bone->childbase.first; bonec; bonec = bonec->next) {
334     if (bonec->flag & BONE_CONNECTED) {
335       wentdeeper = 1;
336       added += pose_grab_with_ik_children(pose, bonec);
337     }
338   }
339   if (wentdeeper == 0) {
340     bPoseChannel *pchan = BKE_pose_channel_find_name(pose, bone->name);
341     if (pchan) {
342       added += pose_grab_with_ik_add(pchan);
343     }
344   }
345
346   return added;
347 }
348
349 /* main call which adds temporal IK chains */
350 static short pose_grab_with_ik(Main *bmain, Object *ob)
351 {
352   bArmature *arm;
353   bPoseChannel *pchan, *parent;
354   Bone *bonec;
355   short tot_ik = 0;
356
357   if ((ob == NULL) || (ob->pose == NULL) || (ob->mode & OB_MODE_POSE) == 0) {
358     return 0;
359   }
360
361   arm = ob->data;
362
363   /* Rule: allow multiple Bones
364    * (but they must be selected, and only one ik-solver per chain should get added) */
365   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
366     if (pchan->bone->layer & arm->layer) {
367       if (pchan->bone->flag & BONE_SELECTED) {
368         /* Rule: no IK for solitatry (unconnected) bones */
369         for (bonec = pchan->bone->childbase.first; bonec; bonec = bonec->next) {
370           if (bonec->flag & BONE_CONNECTED) {
371             break;
372           }
373         }
374         if ((pchan->bone->flag & BONE_CONNECTED) == 0 && (bonec == NULL)) {
375           continue;
376         }
377
378         /* rule: if selected Bone is not a root bone, it gets a temporal IK */
379         if (pchan->parent) {
380           /* only adds if there's no IK yet (and no parent bone was selected) */
381           for (parent = pchan->parent; parent; parent = parent->parent) {
382             if (parent->bone->flag & BONE_SELECTED) {
383               break;
384             }
385           }
386           if (parent == NULL) {
387             tot_ik += pose_grab_with_ik_add(pchan);
388           }
389         }
390         else {
391           /* rule: go over the children and add IK to the tips */
392           tot_ik += pose_grab_with_ik_children(ob->pose, pchan->bone);
393         }
394       }
395     }
396   }
397
398   /* iTaSC needs clear for new IK constraints */
399   if (tot_ik) {
400     BIK_clear_data(ob->pose);
401     /* TODO(sergey): Consider doing partial update only. */
402     DEG_relations_tag_update(bmain);
403   }
404
405   return (tot_ik) ? 1 : 0;
406 }
407
408 static void pose_mirror_info_init(PoseInitData_Mirror *pid,
409                                   bPoseChannel *pchan,
410                                   bPoseChannel *pchan_orig,
411                                   bool is_mirror_relative)
412 {
413   pid->pchan = pchan;
414   copy_v3_v3(pid->orig.loc, pchan->loc);
415   copy_v3_v3(pid->orig.size, pchan->size);
416   pid->orig.curve_in_x = pchan->curve_in_x;
417   pid->orig.curve_out_x = pchan->curve_out_x;
418   pid->orig.roll1 = pchan->roll1;
419   pid->orig.roll2 = pchan->roll2;
420
421   if (pchan->rotmode > 0) {
422     copy_v3_v3(pid->orig.eul, pchan->eul);
423   }
424   else if (pchan->rotmode == ROT_MODE_AXISANGLE) {
425     copy_v3_v3(pid->orig.axis_angle, pchan->rotAxis);
426     pid->orig.axis_angle[3] = pchan->rotAngle;
427   }
428   else {
429     copy_qt_qt(pid->orig.quat, pchan->quat);
430   }
431
432   if (is_mirror_relative) {
433     float pchan_mtx[4][4];
434     float pchan_mtx_mirror[4][4];
435
436     float flip_mtx[4][4];
437     unit_m4(flip_mtx);
438     flip_mtx[0][0] = -1;
439
440     BKE_pchan_to_mat4(pchan_orig, pchan_mtx_mirror);
441     BKE_pchan_to_mat4(pchan, pchan_mtx);
442
443     mul_m4_m4m4(pchan_mtx_mirror, pchan_mtx_mirror, flip_mtx);
444     mul_m4_m4m4(pchan_mtx_mirror, flip_mtx, pchan_mtx_mirror);
445
446     invert_m4(pchan_mtx_mirror);
447     mul_m4_m4m4(pid->offset_mtx, pchan_mtx, pchan_mtx_mirror);
448   }
449   else {
450     unit_m4(pid->offset_mtx);
451   }
452 }
453
454 static void pose_mirror_info_restore(const PoseInitData_Mirror *pid)
455 {
456   bPoseChannel *pchan = pid->pchan;
457   copy_v3_v3(pchan->loc, pid->orig.loc);
458   copy_v3_v3(pchan->size, pid->orig.size);
459   pchan->curve_in_x = pid->orig.curve_in_x;
460   pchan->curve_out_x = pid->orig.curve_out_x;
461   pchan->roll1 = pid->orig.roll1;
462   pchan->roll2 = pid->orig.roll2;
463
464   if (pchan->rotmode > 0) {
465     copy_v3_v3(pchan->eul, pid->orig.eul);
466   }
467   else if (pchan->rotmode == ROT_MODE_AXISANGLE) {
468     copy_v3_v3(pchan->rotAxis, pid->orig.axis_angle);
469     pchan->rotAngle = pid->orig.axis_angle[3];
470   }
471   else {
472     copy_qt_qt(pchan->quat, pid->orig.quat);
473   }
474 }
475
476 /**
477  * When objects array is NULL, use 't->data_container' as is.
478  */
479 void createTransPose(TransInfo *t)
480 {
481   Main *bmain = CTX_data_main(t->context);
482
483   t->data_len_all = 0;
484
485   bool has_translate_rotate_buf[2] = {false, false};
486   bool *has_translate_rotate = (t->mode == TFM_TRANSLATION) ? has_translate_rotate_buf : NULL;
487
488   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
489     Object *ob = tc->poseobj;
490     bPose *pose = ob->pose;
491
492     bArmature *arm;
493
494     /* check validity of state */
495     arm = BKE_armature_from_object(tc->poseobj);
496     if ((arm == NULL) || (pose == NULL)) {
497       continue;
498     }
499
500     const bool mirror = ((pose->flag & POSE_MIRROR_EDIT) != 0);
501
502     /* set flags and count total */
503     tc->data_len = count_set_pose_transflags(ob, t->mode, t->around, has_translate_rotate);
504     if (tc->data_len == 0) {
505       continue;
506     }
507
508     if (arm->flag & ARM_RESTPOS) {
509       if (ELEM(t->mode, TFM_DUMMY, TFM_BONESIZE) == 0) {
510         BKE_report(t->reports, RPT_ERROR, "Cannot change Pose when 'Rest Position' is enabled");
511         tc->data_len = 0;
512         continue;
513       }
514     }
515
516     /* do we need to add temporal IK chains? */
517     if ((pose->flag & POSE_AUTO_IK) && t->mode == TFM_TRANSLATION) {
518       if (pose_grab_with_ik(bmain, ob)) {
519         t->flag |= T_AUTOIK;
520         has_translate_rotate[0] = true;
521       }
522     }
523
524     if (mirror) {
525       int total_mirrored = 0;
526       for (bPoseChannel *pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
527         if ((pchan->bone->flag & BONE_TRANSFORM) &&
528             BKE_pose_channel_get_mirrored(ob->pose, pchan->name)) {
529           total_mirrored++;
530         }
531       }
532
533       PoseInitData_Mirror *pid = MEM_mallocN((total_mirrored + 1) * sizeof(PoseInitData_Mirror),
534                                              "PoseInitData_Mirror");
535
536       /* Trick to terminate iteration. */
537       pid[total_mirrored].pchan = NULL;
538
539       tc->custom.type.data = pid;
540       tc->custom.type.use_free = true;
541     }
542   }
543
544   /* if there are no translatable bones, do rotation */
545   if ((t->mode == TFM_TRANSLATION) && !has_translate_rotate[0]) {
546     if (has_translate_rotate[1]) {
547       t->mode = TFM_ROTATION;
548     }
549     else {
550       t->mode = TFM_RESIZE;
551     }
552   }
553
554   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
555     if (tc->data_len == 0) {
556       continue;
557     }
558     Object *ob = tc->poseobj;
559     TransData *td;
560     TransDataExtension *tdx;
561     int i;
562
563     PoseInitData_Mirror *pid = tc->custom.type.data;
564     int pid_index = 0;
565     bPose *pose = ob->pose;
566
567     if (pose == NULL) {
568       continue;
569     }
570
571     const bool mirror = ((pose->flag & POSE_MIRROR_EDIT) != 0);
572     const bool is_mirror_relative = ((pose->flag & POSE_MIRROR_RELATIVE) != 0);
573
574     tc->poseobj = ob; /* we also allow non-active objects to be transformed, in weightpaint */
575
576     /* init trans data */
577     td = tc->data = MEM_callocN(tc->data_len * sizeof(TransData), "TransPoseBone");
578     tdx = tc->data_ext = MEM_callocN(tc->data_len * sizeof(TransDataExtension),
579                                      "TransPoseBoneExt");
580     for (i = 0; i < tc->data_len; i++, td++, tdx++) {
581       td->ext = tdx;
582       td->val = NULL;
583     }
584
585     /* use pose channels to fill trans data */
586     td = tc->data;
587     for (bPoseChannel *pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
588       if (pchan->bone->flag & BONE_TRANSFORM) {
589         add_pose_transdata(t, pchan, ob, tc, td);
590
591         if (mirror) {
592           bPoseChannel *pchan_mirror = BKE_pose_channel_get_mirrored(ob->pose, pchan->name);
593           if (pchan_mirror) {
594             pose_mirror_info_init(&pid[pid_index], pchan_mirror, pchan, is_mirror_relative);
595             pid_index++;
596           }
597         }
598
599         td++;
600       }
601     }
602
603     if (td != (tc->data + tc->data_len)) {
604       BKE_report(t->reports, RPT_DEBUG, "Bone selection count error");
605     }
606
607     /* initialize initial auto=ik chainlen's? */
608     if (t->flag & T_AUTOIK) {
609       transform_autoik_update(t, 0);
610     }
611   }
612
613   t->flag |= T_POSE;
614   /* disable PET, its not usable in pose mode yet [#32444] */
615   t->flag &= ~T_PROP_EDIT_ALL;
616 }
617
618 void restoreMirrorPoseBones(TransDataContainer *tc)
619 {
620   bPose *pose = tc->poseobj->pose;
621
622   if (!(pose->flag & POSE_MIRROR_EDIT)) {
623     return;
624   }
625
626   for (PoseInitData_Mirror *pid = tc->custom.type.data; pid->pchan; pid++) {
627     pose_mirror_info_restore(pid);
628   }
629 }
630
631 void restoreBones(TransDataContainer *tc)
632 {
633   bArmature *arm;
634   BoneInitData *bid = tc->custom.type.data;
635   EditBone *ebo;
636
637   if (tc->obedit) {
638     arm = tc->obedit->data;
639   }
640   else {
641     BLI_assert(tc->poseobj != NULL);
642     arm = tc->poseobj->data;
643   }
644
645   while (bid->bone) {
646     ebo = bid->bone;
647
648     ebo->dist = bid->dist;
649     ebo->rad_head = bid->rad_head;
650     ebo->rad_tail = bid->rad_tail;
651     ebo->roll = bid->roll;
652     ebo->xwidth = bid->xwidth;
653     ebo->zwidth = bid->zwidth;
654     copy_v3_v3(ebo->head, bid->head);
655     copy_v3_v3(ebo->tail, bid->tail);
656
657     if (arm->flag & ARM_MIRROR_EDIT) {
658       EditBone *ebo_child;
659
660       /* Also move connected ebo_child, in case ebo_child's name aren't mirrored properly */
661       for (ebo_child = arm->edbo->first; ebo_child; ebo_child = ebo_child->next) {
662         if ((ebo_child->flag & BONE_CONNECTED) && (ebo_child->parent == ebo)) {
663           copy_v3_v3(ebo_child->head, ebo->tail);
664           ebo_child->rad_head = ebo->rad_tail;
665         }
666       }
667
668       /* Also move connected parent, in case parent's name isn't mirrored properly */
669       if ((ebo->flag & BONE_CONNECTED) && ebo->parent) {
670         EditBone *parent = ebo->parent;
671         copy_v3_v3(parent->tail, ebo->head);
672         parent->rad_tail = ebo->rad_head;
673       }
674     }
675
676     bid++;
677   }
678 }
679
680 /* ********************* armature ************** */
681 void createTransArmatureVerts(TransInfo *t)
682 {
683   t->data_len_all = 0;
684
685   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
686     EditBone *ebo, *eboflip;
687     bArmature *arm = tc->obedit->data;
688     ListBase *edbo = arm->edbo;
689     bool mirror = ((arm->flag & ARM_MIRROR_EDIT) != 0);
690     int total_mirrored = 0;
691
692     tc->data_len = 0;
693     for (ebo = edbo->first; ebo; ebo = ebo->next) {
694       const int data_len_prev = tc->data_len;
695
696       if (EBONE_VISIBLE(arm, ebo) && !(ebo->flag & BONE_EDITMODE_LOCKED)) {
697         if (ELEM(t->mode, TFM_BONESIZE, TFM_BONE_ENVELOPE_DIST)) {
698           if (ebo->flag & BONE_SELECTED) {
699             tc->data_len++;
700           }
701         }
702         else if (t->mode == TFM_BONE_ROLL) {
703           if (ebo->flag & BONE_SELECTED) {
704             tc->data_len++;
705           }
706         }
707         else {
708           if (ebo->flag & BONE_TIPSEL) {
709             tc->data_len++;
710           }
711           if (ebo->flag & BONE_ROOTSEL) {
712             tc->data_len++;
713           }
714         }
715       }
716
717       if (mirror && (data_len_prev < tc->data_len)) {
718         eboflip = ED_armature_ebone_get_mirrored(arm->edbo, ebo);
719         if (eboflip) {
720           total_mirrored++;
721         }
722       }
723     }
724     if (!tc->data_len) {
725       continue;
726     }
727
728     if (mirror) {
729       BoneInitData *bid = MEM_mallocN((total_mirrored + 1) * sizeof(BoneInitData), "BoneInitData");
730
731       /* trick to terminate iteration */
732       bid[total_mirrored].bone = NULL;
733
734       tc->custom.type.data = bid;
735       tc->custom.type.use_free = true;
736     }
737     t->data_len_all += tc->data_len;
738   }
739
740   transform_around_single_fallback(t);
741   t->data_len_all = -1;
742
743   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
744     if (!tc->data_len) {
745       continue;
746     }
747
748     EditBone *ebo, *eboflip;
749     bArmature *arm = tc->obedit->data;
750     ListBase *edbo = arm->edbo;
751     TransData *td, *td_old;
752     float mtx[3][3], smtx[3][3], bonemat[3][3];
753     bool mirror = ((arm->flag & ARM_MIRROR_EDIT) != 0);
754     BoneInitData *bid = tc->custom.type.data;
755
756     copy_m3_m4(mtx, tc->obedit->obmat);
757     pseudoinverse_m3_m3(smtx, mtx, PSEUDOINVERSE_EPSILON);
758
759     td = tc->data = MEM_callocN(tc->data_len * sizeof(TransData), "TransEditBone");
760     int i = 0;
761
762     for (ebo = edbo->first; ebo; ebo = ebo->next) {
763       td_old = td;
764       ebo->oldlength =
765           ebo->length;  // length==0.0 on extrude, used for scaling radius of bone points
766
767       if (EBONE_VISIBLE(arm, ebo) && !(ebo->flag & BONE_EDITMODE_LOCKED)) {
768         if (t->mode == TFM_BONE_ENVELOPE) {
769           if (ebo->flag & BONE_ROOTSEL) {
770             td->val = &ebo->rad_head;
771             td->ival = *td->val;
772
773             copy_v3_v3(td->center, ebo->head);
774             td->flag = TD_SELECTED;
775
776             copy_m3_m3(td->smtx, smtx);
777             copy_m3_m3(td->mtx, mtx);
778
779             td->loc = NULL;
780             td->ext = NULL;
781             td->ob = tc->obedit;
782
783             td++;
784           }
785           if (ebo->flag & BONE_TIPSEL) {
786             td->val = &ebo->rad_tail;
787             td->ival = *td->val;
788             copy_v3_v3(td->center, ebo->tail);
789             td->flag = TD_SELECTED;
790
791             copy_m3_m3(td->smtx, smtx);
792             copy_m3_m3(td->mtx, mtx);
793
794             td->loc = NULL;
795             td->ext = NULL;
796             td->ob = tc->obedit;
797
798             td++;
799           }
800         }
801         else if (ELEM(t->mode, TFM_BONESIZE, TFM_BONE_ENVELOPE_DIST)) {
802           if (ebo->flag & BONE_SELECTED) {
803             if ((t->mode == TFM_BONE_ENVELOPE_DIST) || (arm->drawtype == ARM_ENVELOPE)) {
804               td->loc = NULL;
805               td->val = &ebo->dist;
806               td->ival = ebo->dist;
807             }
808             else {
809               // abusive storage of scale in the loc pointer :)
810               td->loc = &ebo->xwidth;
811               copy_v3_v3(td->iloc, td->loc);
812               td->val = NULL;
813             }
814             copy_v3_v3(td->center, ebo->head);
815             td->flag = TD_SELECTED;
816
817             /* use local bone matrix */
818             ED_armature_ebone_to_mat3(ebo, bonemat);
819             mul_m3_m3m3(td->mtx, mtx, bonemat);
820             invert_m3_m3(td->smtx, td->mtx);
821
822             copy_m3_m3(td->axismtx, td->mtx);
823             normalize_m3(td->axismtx);
824
825             td->ext = NULL;
826             td->ob = tc->obedit;
827
828             td++;
829           }
830         }
831         else if (t->mode == TFM_BONE_ROLL) {
832           if (ebo->flag & BONE_SELECTED) {
833             td->loc = NULL;
834             td->val = &(ebo->roll);
835             td->ival = ebo->roll;
836
837             copy_v3_v3(td->center, ebo->head);
838             td->flag = TD_SELECTED;
839
840             td->ext = NULL;
841             td->ob = tc->obedit;
842
843             td++;
844           }
845         }
846         else {
847           if (ebo->flag & BONE_TIPSEL) {
848             copy_v3_v3(td->iloc, ebo->tail);
849
850             /* Don't allow single selected tips to have a modified center,
851              * causes problem with snapping (see T45974).
852              * However, in rotation mode, we want to keep that 'rotate bone around root with
853              * only its tip selected' behavior (see T46325). */
854             if ((t->around == V3D_AROUND_LOCAL_ORIGINS) &&
855                 ((t->mode == TFM_ROTATION) || (ebo->flag & BONE_ROOTSEL))) {
856               copy_v3_v3(td->center, ebo->head);
857             }
858             else {
859               copy_v3_v3(td->center, td->iloc);
860             }
861
862             td->loc = ebo->tail;
863             td->flag = TD_SELECTED;
864             if (ebo->flag & BONE_EDITMODE_LOCKED) {
865               td->protectflag = OB_LOCK_LOC | OB_LOCK_ROT | OB_LOCK_SCALE;
866             }
867
868             copy_m3_m3(td->smtx, smtx);
869             copy_m3_m3(td->mtx, mtx);
870
871             ED_armature_ebone_to_mat3(ebo, td->axismtx);
872
873             if ((ebo->flag & BONE_ROOTSEL) == 0) {
874               td->extra = ebo;
875               td->ival = ebo->roll;
876             }
877
878             td->ext = NULL;
879             td->val = NULL;
880             td->ob = tc->obedit;
881
882             td++;
883           }
884           if (ebo->flag & BONE_ROOTSEL) {
885             copy_v3_v3(td->iloc, ebo->head);
886             copy_v3_v3(td->center, td->iloc);
887             td->loc = ebo->head;
888             td->flag = TD_SELECTED;
889             if (ebo->flag & BONE_EDITMODE_LOCKED) {
890               td->protectflag = OB_LOCK_LOC | OB_LOCK_ROT | OB_LOCK_SCALE;
891             }
892
893             copy_m3_m3(td->smtx, smtx);
894             copy_m3_m3(td->mtx, mtx);
895
896             ED_armature_ebone_to_mat3(ebo, td->axismtx);
897
898             td->extra = ebo; /* to fix roll */
899             td->ival = ebo->roll;
900
901             td->ext = NULL;
902             td->val = NULL;
903             td->ob = tc->obedit;
904
905             td++;
906           }
907         }
908       }
909
910       if (mirror && (td_old != td)) {
911         eboflip = ED_armature_ebone_get_mirrored(arm->edbo, ebo);
912         if (eboflip) {
913           bid[i].bone = eboflip;
914           bid[i].dist = eboflip->dist;
915           bid[i].rad_head = eboflip->rad_head;
916           bid[i].rad_tail = eboflip->rad_tail;
917           bid[i].roll = eboflip->roll;
918           bid[i].xwidth = eboflip->xwidth;
919           bid[i].zwidth = eboflip->zwidth;
920           copy_v3_v3(bid[i].head, eboflip->head);
921           copy_v3_v3(bid[i].tail, eboflip->tail);
922           i++;
923         }
924       }
925     }
926
927     if (mirror) {
928       /* trick to terminate iteration */
929       BLI_assert(i + 1 == (MEM_allocN_len(bid) / sizeof(*bid)));
930       bid[i].bone = NULL;
931     }
932   }
933 }