b23081cd6fa13a71520145e82515a46a4d82a487
[blender.git] / source / blender / editors / armature / armature_utils.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 edarmature
22  */
23
24 #include "DNA_armature_types.h"
25 #include "DNA_object_types.h"
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLI_blenlib.h"
30 #include "BLI_math.h"
31 #include "BLI_string_utils.h"
32
33 #include "BKE_armature.h"
34 #include "BKE_context.h"
35 #include "BKE_deform.h"
36 #include "BKE_global.h"
37 #include "BKE_idprop.h"
38 #include "BKE_main.h"
39
40 #include "DEG_depsgraph.h"
41
42 #include "ED_armature.h"
43 #include "ED_util.h"
44
45 #include "armature_intern.h"
46
47 /* *************************************************************** */
48 /* Validation */
49
50 /* Sync selection to parent for connected children */
51 void ED_armature_edit_sync_selection(ListBase *edbo)
52 {
53   EditBone *ebo;
54
55   for (ebo = edbo->first; ebo; ebo = ebo->next) {
56     /* if bone is not selectable, we shouldn't alter this setting... */
57     if ((ebo->flag & BONE_UNSELECTABLE) == 0) {
58       if ((ebo->flag & BONE_CONNECTED) && (ebo->parent)) {
59         if (ebo->parent->flag & BONE_TIPSEL) {
60           ebo->flag |= BONE_ROOTSEL;
61         }
62         else {
63           ebo->flag &= ~BONE_ROOTSEL;
64         }
65       }
66
67       if ((ebo->flag & BONE_TIPSEL) && (ebo->flag & BONE_ROOTSEL)) {
68         ebo->flag |= BONE_SELECTED;
69       }
70       else {
71         ebo->flag &= ~BONE_SELECTED;
72       }
73     }
74   }
75 }
76
77 void ED_armature_edit_validate_active(struct bArmature *arm)
78 {
79   EditBone *ebone = arm->act_edbone;
80
81   if (ebone) {
82     if (ebone->flag & BONE_HIDDEN_A) {
83       arm->act_edbone = NULL;
84     }
85   }
86 }
87
88 /* *************************************************************** */
89 /* Bone Operations */
90
91 /* XXX bone_looper is only to be used when we want to access settings
92  * (i.e. editability/visibility/selected) that context doesn't offer */
93 int bone_looper(Object *ob, Bone *bone, void *data, int (*bone_func)(Object *, Bone *, void *))
94 {
95   /* We want to apply the function bone_func to every bone
96    * in an armature -- feed bone_looper the first bone and
97    * a pointer to the bone_func and watch it go!. The int count
98    * can be useful for counting bones with a certain property
99    * (e.g. skinnable)
100    */
101   int count = 0;
102
103   if (bone) {
104     /* only do bone_func if the bone is non null */
105     count += bone_func(ob, bone, data);
106
107     /* try to execute bone_func for the first child */
108     count += bone_looper(ob, bone->childbase.first, data, bone_func);
109
110     /* try to execute bone_func for the next bone at this
111      * depth of the recursion.
112      */
113     count += bone_looper(ob, bone->next, data, bone_func);
114   }
115
116   return count;
117 }
118
119 /* *************************************************************** */
120 /* Bone Removal */
121
122 void bone_free(bArmature *arm, EditBone *bone)
123 {
124   if (arm->act_edbone == bone) {
125     arm->act_edbone = NULL;
126   }
127
128   if (bone->prop) {
129     IDP_FreeProperty(bone->prop);
130     MEM_freeN(bone->prop);
131   }
132
133   /* Clear references from other edit bones. */
134   for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
135     if (ebone->bbone_next == bone) {
136       ebone->bbone_next = NULL;
137     }
138     if (ebone->bbone_prev == bone) {
139       ebone->bbone_prev = NULL;
140     }
141   }
142
143   BLI_freelinkN(arm->edbo, bone);
144 }
145
146 /**
147  * \param clear_connected: When false caller is responsible for keeping the flag in a valid state.
148  */
149 void ED_armature_ebone_remove_ex(bArmature *arm, EditBone *exBone, bool clear_connected)
150 {
151   EditBone *curBone;
152
153   /* Find any bones that refer to this bone */
154   for (curBone = arm->edbo->first; curBone; curBone = curBone->next) {
155     if (curBone->parent == exBone) {
156       curBone->parent = exBone->parent;
157       if (clear_connected) {
158         curBone->flag &= ~BONE_CONNECTED;
159       }
160     }
161   }
162
163   bone_free(arm, exBone);
164 }
165
166 void ED_armature_ebone_remove(bArmature *arm, EditBone *exBone)
167 {
168   ED_armature_ebone_remove_ex(arm, exBone, true);
169 }
170
171 bool ED_armature_ebone_is_child_recursive(EditBone *ebone_parent, EditBone *ebone_child)
172 {
173   for (ebone_child = ebone_child->parent; ebone_child; ebone_child = ebone_child->parent) {
174     if (ebone_child == ebone_parent) {
175       return true;
176     }
177   }
178   return false;
179 }
180
181 /**
182  * Finds the first parent shared by \a ebone_child
183  *
184  * \param ebone_child: Children bones to search
185  * \param ebone_child_tot: Size of the ebone_child array
186  * \return The shared parent or NULL.
187  */
188 EditBone *ED_armature_ebone_find_shared_parent(EditBone *ebone_child[],
189                                                const unsigned int ebone_child_tot)
190 {
191   unsigned int i;
192   EditBone *ebone_iter;
193
194 #define EBONE_TEMP_UINT(ebone) (*((unsigned int *)(&((ebone)->temp))))
195
196   /* clear all */
197   for (i = 0; i < ebone_child_tot; i++) {
198     for (ebone_iter = ebone_child[i]; ebone_iter; ebone_iter = ebone_iter->parent) {
199       EBONE_TEMP_UINT(ebone_iter) = 0;
200     }
201   }
202
203   /* accumulate */
204   for (i = 0; i < ebone_child_tot; i++) {
205     for (ebone_iter = ebone_child[i]->parent; ebone_iter; ebone_iter = ebone_iter->parent) {
206       EBONE_TEMP_UINT(ebone_iter) += 1;
207     }
208   }
209
210   /* only need search the first chain */
211   for (ebone_iter = ebone_child[0]->parent; ebone_iter; ebone_iter = ebone_iter->parent) {
212     if (EBONE_TEMP_UINT(ebone_iter) == ebone_child_tot) {
213       return ebone_iter;
214     }
215   }
216
217 #undef EBONE_TEMP_UINT
218
219   return NULL;
220 }
221
222 void ED_armature_ebone_to_mat3(EditBone *ebone, float mat[3][3])
223 {
224   float delta[3];
225
226   /* Find the current bone matrix */
227   sub_v3_v3v3(delta, ebone->tail, ebone->head);
228   vec_roll_to_mat3(delta, ebone->roll, mat);
229 }
230
231 void ED_armature_ebone_to_mat4(EditBone *ebone, float mat[4][4])
232 {
233   float m3[3][3];
234
235   ED_armature_ebone_to_mat3(ebone, m3);
236
237   copy_m4_m3(mat, m3);
238   copy_v3_v3(mat[3], ebone->head);
239 }
240
241 void ED_armature_ebone_from_mat3(EditBone *ebone, float mat[3][3])
242 {
243   float vec[3], roll;
244   const float len = len_v3v3(ebone->head, ebone->tail);
245
246   mat3_to_vec_roll(mat, vec, &roll);
247
248   madd_v3_v3v3fl(ebone->tail, ebone->head, vec, len);
249   ebone->roll = roll;
250 }
251
252 void ED_armature_ebone_from_mat4(EditBone *ebone, float mat[4][4])
253 {
254   float mat3[3][3];
255
256   copy_m3_m4(mat3, mat);
257   /* We want normalized matrix here, to be consistent with ebone_to_mat. */
258   BLI_ASSERT_UNIT_M3(mat3);
259
260   sub_v3_v3(ebone->tail, ebone->head);
261   copy_v3_v3(ebone->head, mat[3]);
262   add_v3_v3(ebone->tail, mat[3]);
263   ED_armature_ebone_from_mat3(ebone, mat3);
264 }
265
266 /**
267  * Return a pointer to the bone of the given name
268  */
269 EditBone *ED_armature_ebone_find_name(const ListBase *edbo, const char *name)
270 {
271   return BLI_findstring(edbo, name, offsetof(EditBone, name));
272 }
273
274 /* *************************************************************** */
275 /* Mirroring */
276
277 /**
278  * \see #BKE_pose_channel_get_mirrored (pose-mode, matching function)
279  */
280 EditBone *ED_armature_ebone_get_mirrored(const ListBase *edbo, EditBone *ebo)
281 {
282   char name_flip[MAXBONENAME];
283
284   if (ebo == NULL) {
285     return NULL;
286   }
287
288   BLI_string_flip_side_name(name_flip, ebo->name, false, sizeof(name_flip));
289
290   if (!STREQ(name_flip, ebo->name)) {
291     return ED_armature_ebone_find_name(edbo, name_flip);
292   }
293
294   return NULL;
295 }
296
297 /* ------------------------------------- */
298
299 /* helper function for tools to work on mirrored parts.
300  * it leaves mirrored bones selected then too, which is a good indication of what happened */
301 void armature_select_mirrored_ex(bArmature *arm, const int flag)
302 {
303   BLI_assert((flag & ~(BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL)) == 0);
304   /* Select mirrored bones */
305   if (arm->flag & ARM_MIRROR_EDIT) {
306     EditBone *curBone, *ebone_mirr;
307
308     for (curBone = arm->edbo->first; curBone; curBone = curBone->next) {
309       if (arm->layer & curBone->layer) {
310         if (curBone->flag & flag) {
311           ebone_mirr = ED_armature_ebone_get_mirrored(arm->edbo, curBone);
312           if (ebone_mirr) {
313             ebone_mirr->flag |= (curBone->flag & flag);
314           }
315         }
316       }
317     }
318   }
319 }
320
321 void armature_select_mirrored(bArmature *arm)
322 {
323   armature_select_mirrored_ex(arm, BONE_SELECTED);
324 }
325
326 void armature_tag_select_mirrored(bArmature *arm)
327 {
328   EditBone *curBone;
329
330   /* always untag */
331   for (curBone = arm->edbo->first; curBone; curBone = curBone->next) {
332     curBone->flag &= ~BONE_DONE;
333   }
334
335   /* Select mirrored bones */
336   if (arm->flag & ARM_MIRROR_EDIT) {
337     for (curBone = arm->edbo->first; curBone; curBone = curBone->next) {
338       if (arm->layer & curBone->layer) {
339         if (curBone->flag & (BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL)) {
340           EditBone *ebone_mirr = ED_armature_ebone_get_mirrored(arm->edbo, curBone);
341           if (ebone_mirr && (ebone_mirr->flag & BONE_SELECTED) == 0) {
342             ebone_mirr->flag |= BONE_DONE;
343           }
344         }
345       }
346     }
347
348     for (curBone = arm->edbo->first; curBone; curBone = curBone->next) {
349       if (curBone->flag & BONE_DONE) {
350         EditBone *ebone_mirr = ED_armature_ebone_get_mirrored(arm->edbo, curBone);
351         curBone->flag |= ebone_mirr->flag & (BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL);
352       }
353     }
354   }
355 }
356
357 /* only works when tagged */
358 void armature_tag_unselect(bArmature *arm)
359 {
360   EditBone *curBone;
361
362   for (curBone = arm->edbo->first; curBone; curBone = curBone->next) {
363     if (curBone->flag & BONE_DONE) {
364       curBone->flag &= ~(BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL | BONE_DONE);
365     }
366   }
367 }
368
369 /* ------------------------------------- */
370
371 /* if editbone (partial) selected, copy data */
372 /* context; editmode armature, with mirror editing enabled */
373 void ED_armature_edit_transform_mirror_update(Object *obedit)
374 {
375   bArmature *arm = obedit->data;
376   EditBone *ebo, *eboflip;
377
378   for (ebo = arm->edbo->first; ebo; ebo = ebo->next) {
379     /* no layer check, correct mirror is more important */
380     if (ebo->flag & (BONE_TIPSEL | BONE_ROOTSEL)) {
381       eboflip = ED_armature_ebone_get_mirrored(arm->edbo, ebo);
382
383       if (eboflip) {
384         /* we assume X-axis flipping for now */
385         if (ebo->flag & BONE_TIPSEL) {
386           EditBone *children;
387
388           eboflip->tail[0] = -ebo->tail[0];
389           eboflip->tail[1] = ebo->tail[1];
390           eboflip->tail[2] = ebo->tail[2];
391           eboflip->rad_tail = ebo->rad_tail;
392           eboflip->roll = -ebo->roll;
393           eboflip->curve_out_x = -ebo->curve_out_x;
394           eboflip->roll2 = -ebo->roll2;
395
396           /* Also move connected children, in case children's name aren't mirrored properly */
397           for (children = arm->edbo->first; children; children = children->next) {
398             if (children->parent == eboflip && children->flag & BONE_CONNECTED) {
399               copy_v3_v3(children->head, eboflip->tail);
400               children->rad_head = ebo->rad_tail;
401             }
402           }
403         }
404         if (ebo->flag & BONE_ROOTSEL) {
405           eboflip->head[0] = -ebo->head[0];
406           eboflip->head[1] = ebo->head[1];
407           eboflip->head[2] = ebo->head[2];
408           eboflip->rad_head = ebo->rad_head;
409           eboflip->roll = -ebo->roll;
410           eboflip->curve_in_x = -ebo->curve_in_x;
411           eboflip->roll1 = -ebo->roll1;
412
413           /* Also move connected parent, in case parent's name isn't mirrored properly */
414           if (eboflip->parent && eboflip->flag & BONE_CONNECTED) {
415             EditBone *parent = eboflip->parent;
416             copy_v3_v3(parent->tail, eboflip->head);
417             parent->rad_tail = ebo->rad_head;
418           }
419         }
420         if (ebo->flag & BONE_SELECTED) {
421           eboflip->dist = ebo->dist;
422           eboflip->roll = -ebo->roll;
423           eboflip->xwidth = ebo->xwidth;
424           eboflip->zwidth = ebo->zwidth;
425
426           eboflip->curve_in_x = -ebo->curve_in_x;
427           eboflip->curve_out_x = -ebo->curve_out_x;
428           eboflip->roll1 = -ebo->roll1;
429           eboflip->roll2 = -ebo->roll2;
430         }
431       }
432     }
433   }
434 }
435
436 /* *************************************************************** */
437 /* Armature EditMode Conversions */
438
439 /* converts Bones to EditBone list, used for tools as well */
440 static EditBone *make_boneList_rec(ListBase *edbo,
441                                    ListBase *bones,
442                                    EditBone *parent,
443                                    Bone *actBone)
444 {
445   EditBone *eBone;
446   EditBone *eBoneAct = NULL;
447   EditBone *eBoneTest = NULL;
448   Bone *curBone;
449
450   for (curBone = bones->first; curBone; curBone = curBone->next) {
451     eBone = MEM_callocN(sizeof(EditBone), "make_editbone");
452     eBone->temp.bone = curBone;
453
454     /* Copy relevant data from bone to eBone
455      * Keep selection logic in sync with ED_armature_edit_sync_selection.
456      */
457     eBone->parent = parent;
458     BLI_strncpy(eBone->name, curBone->name, sizeof(eBone->name));
459     eBone->flag = curBone->flag;
460
461     /* fix selection flags */
462     if (eBone->flag & BONE_SELECTED) {
463       /* if the bone is selected the copy its root selection to the parents tip */
464       eBone->flag |= BONE_TIPSEL;
465       if (eBone->parent && (eBone->flag & BONE_CONNECTED)) {
466         eBone->parent->flag |= BONE_TIPSEL;
467       }
468
469       /* For connected bones, take care when changing the selection when we have a
470        * connected parent, this flag is a copy of '(eBone->parent->flag & BONE_TIPSEL)'. */
471       eBone->flag |= BONE_ROOTSEL;
472     }
473     else {
474       /* if the bone is not selected, but connected to its parent
475        * always use the parents tip selection state */
476       if (eBone->parent && (eBone->flag & BONE_CONNECTED)) {
477         eBone->flag &= ~BONE_ROOTSEL;
478       }
479     }
480
481     copy_v3_v3(eBone->head, curBone->arm_head);
482     copy_v3_v3(eBone->tail, curBone->arm_tail);
483     eBone->roll = curBone->arm_roll;
484
485     /* rest of stuff copy */
486     eBone->length = curBone->length;
487     eBone->dist = curBone->dist;
488     eBone->weight = curBone->weight;
489     eBone->xwidth = curBone->xwidth;
490     eBone->zwidth = curBone->zwidth;
491     eBone->rad_head = curBone->rad_head;
492     eBone->rad_tail = curBone->rad_tail;
493     eBone->segments = curBone->segments;
494     eBone->layer = curBone->layer;
495
496     /* Bendy-Bone parameters */
497     eBone->roll1 = curBone->roll1;
498     eBone->roll2 = curBone->roll2;
499     eBone->curve_in_x = curBone->curve_in_x;
500     eBone->curve_in_y = curBone->curve_in_y;
501     eBone->curve_out_x = curBone->curve_out_x;
502     eBone->curve_out_y = curBone->curve_out_y;
503     eBone->ease1 = curBone->ease1;
504     eBone->ease2 = curBone->ease2;
505     eBone->scale_in_x = curBone->scale_in_x;
506     eBone->scale_in_y = curBone->scale_in_y;
507     eBone->scale_out_x = curBone->scale_out_x;
508     eBone->scale_out_y = curBone->scale_out_y;
509
510     eBone->bbone_prev_type = curBone->bbone_prev_type;
511     eBone->bbone_next_type = curBone->bbone_next_type;
512
513     if (curBone->prop) {
514       eBone->prop = IDP_CopyProperty(curBone->prop);
515     }
516
517     BLI_addtail(edbo, eBone);
518
519     /*  Add children if necessary */
520     if (curBone->childbase.first) {
521       eBoneTest = make_boneList_rec(edbo, &curBone->childbase, eBone, actBone);
522       if (eBoneTest) {
523         eBoneAct = eBoneTest;
524       }
525     }
526
527     if (curBone == actBone) {
528       eBoneAct = eBone;
529     }
530   }
531
532   return eBoneAct;
533 }
534
535 static EditBone *find_ebone_link(ListBase *edbo, Bone *link)
536 {
537   if (link != NULL) {
538     for (EditBone *ebone = edbo->first; ebone; ebone = ebone->next) {
539       if (ebone->temp.bone == link) {
540         return ebone;
541       }
542     }
543   }
544
545   return NULL;
546 }
547
548 EditBone *make_boneList(ListBase *edbo, ListBase *bones, struct Bone *actBone)
549 {
550   BLI_assert(!edbo->first && !edbo->last);
551
552   EditBone *active = make_boneList_rec(edbo, bones, NULL, actBone);
553
554   for (EditBone *ebone = edbo->first; ebone; ebone = ebone->next) {
555     Bone *bone = ebone->temp.bone;
556
557     /* Convert custom B-Bone handle links. */
558     ebone->bbone_prev = find_ebone_link(edbo, bone->bbone_prev);
559     ebone->bbone_next = find_ebone_link(edbo, bone->bbone_next);
560   }
561
562   return active;
563 }
564
565 /**
566  * This function:
567  * - Sets local head/tail rest locations using parent bone's arm_mat.
568  * - Calls #BKE_armature_where_is_bone() which uses parent's transform (arm_mat)
569  *   to define this bone's transform.
570  * - Fixes (converts) EditBone roll into Bone roll.
571  * - Calls again #BKE_armature_where_is_bone(),
572  *   since roll fiddling may have changed things for our bone.
573  *
574  * \note The order is crucial here, we can only handle child
575  * if all its parents in chain have already been handled (this is ensured by recursive process).
576  */
577 static void armature_finalize_restpose(ListBase *bonelist, ListBase *editbonelist)
578 {
579   Bone *curBone;
580   EditBone *ebone;
581
582   for (curBone = bonelist->first; curBone; curBone = curBone->next) {
583     /* Set bone's local head/tail.
584      * Note that it's important to use final parent's restpose (arm_mat) here,
585      * instead of setting those values from editbone's matrix (see T46010). */
586     if (curBone->parent) {
587       float parmat_inv[4][4];
588
589       invert_m4_m4(parmat_inv, curBone->parent->arm_mat);
590
591       /* Get the new head and tail */
592       sub_v3_v3v3(curBone->head, curBone->arm_head, curBone->parent->arm_tail);
593       sub_v3_v3v3(curBone->tail, curBone->arm_tail, curBone->parent->arm_tail);
594
595       mul_mat3_m4_v3(parmat_inv, curBone->head);
596       mul_mat3_m4_v3(parmat_inv, curBone->tail);
597     }
598     else {
599       copy_v3_v3(curBone->head, curBone->arm_head);
600       copy_v3_v3(curBone->tail, curBone->arm_tail);
601     }
602
603     /* Set local matrix and arm_mat (restpose).
604      * Do not recurse into children here, armature_finalize_restpose() is already recursive. */
605     BKE_armature_where_is_bone(curBone, curBone->parent, false);
606
607     /* Find the associated editbone */
608     for (ebone = editbonelist->first; ebone; ebone = ebone->next) {
609       if (ebone->temp.bone == curBone) {
610         float premat[3][3];
611         float postmat[3][3];
612         float difmat[3][3];
613         float imat[3][3];
614
615         /* Get the ebone premat and its inverse. */
616         ED_armature_ebone_to_mat3(ebone, premat);
617         invert_m3_m3(imat, premat);
618
619         /* Get the bone postmat. */
620         copy_m3_m4(postmat, curBone->arm_mat);
621
622         mul_m3_m3m3(difmat, imat, postmat);
623
624 #if 0
625         printf("Bone %s\n", curBone->name);
626         print_m4("premat", premat);
627         print_m4("postmat", postmat);
628         print_m4("difmat", difmat);
629         printf("Roll = %f\n", RAD2DEGF(-atan2(difmat[2][0], difmat[2][2])));
630 #endif
631
632         curBone->roll = -atan2f(difmat[2][0], difmat[2][2]);
633
634         /* and set restposition again */
635         BKE_armature_where_is_bone(curBone, curBone->parent, false);
636         break;
637       }
638     }
639
640     /* Recurse into children... */
641     armature_finalize_restpose(&curBone->childbase, editbonelist);
642   }
643 }
644
645 /* put EditMode back in Object */
646 void ED_armature_from_edit(Main *bmain, bArmature *arm)
647 {
648   EditBone *eBone, *neBone;
649   Bone *newBone;
650   Object *obt;
651
652   /* armature bones */
653   BKE_armature_bonelist_free(&arm->bonebase);
654   arm->act_bone = NULL;
655
656   /* remove zero sized bones, this gives unstable restposes */
657   for (eBone = arm->edbo->first; eBone; eBone = neBone) {
658     float len_sq = len_squared_v3v3(eBone->head, eBone->tail);
659     neBone = eBone->next;
660     if (len_sq <= SQUARE(0.000001f)) { /* FLT_EPSILON is too large? */
661       EditBone *fBone;
662
663       /* Find any bones that refer to this bone */
664       for (fBone = arm->edbo->first; fBone; fBone = fBone->next) {
665         if (fBone->parent == eBone) {
666           fBone->parent = eBone->parent;
667         }
668       }
669       if (G.debug & G_DEBUG) {
670         printf("Warning: removed zero sized bone: %s\n", eBone->name);
671       }
672       bone_free(arm, eBone);
673     }
674   }
675
676   /*  Copy the bones from the editData into the armature */
677   for (eBone = arm->edbo->first; eBone; eBone = eBone->next) {
678     newBone = MEM_callocN(sizeof(Bone), "bone");
679     eBone->temp.bone = newBone; /* Associate the real Bones with the EditBones */
680
681     BLI_strncpy(newBone->name, eBone->name, sizeof(newBone->name));
682     copy_v3_v3(newBone->arm_head, eBone->head);
683     copy_v3_v3(newBone->arm_tail, eBone->tail);
684     newBone->arm_roll = eBone->roll;
685
686     newBone->flag = eBone->flag;
687
688     if (eBone == arm->act_edbone) {
689       /* don't change active selection, this messes up separate which uses
690        * editmode toggle and can separate active bone which is de-selected originally */
691
692       /* important, editbones can be active with only 1 point selected */
693       /* newBone->flag |= BONE_SELECTED; */
694       arm->act_bone = newBone;
695     }
696     newBone->roll = 0.0f;
697
698     newBone->weight = eBone->weight;
699     newBone->dist = eBone->dist;
700
701     newBone->xwidth = eBone->xwidth;
702     newBone->zwidth = eBone->zwidth;
703     newBone->rad_head = eBone->rad_head;
704     newBone->rad_tail = eBone->rad_tail;
705     newBone->segments = eBone->segments;
706     newBone->layer = eBone->layer;
707
708     /* Bendy-Bone parameters */
709     newBone->roll1 = eBone->roll1;
710     newBone->roll2 = eBone->roll2;
711     newBone->curve_in_x = eBone->curve_in_x;
712     newBone->curve_in_y = eBone->curve_in_y;
713     newBone->curve_out_x = eBone->curve_out_x;
714     newBone->curve_out_y = eBone->curve_out_y;
715     newBone->ease1 = eBone->ease1;
716     newBone->ease2 = eBone->ease2;
717     newBone->scale_in_x = eBone->scale_in_x;
718     newBone->scale_in_y = eBone->scale_in_y;
719     newBone->scale_out_x = eBone->scale_out_x;
720     newBone->scale_out_y = eBone->scale_out_y;
721
722     newBone->bbone_prev_type = eBone->bbone_prev_type;
723     newBone->bbone_next_type = eBone->bbone_next_type;
724
725     if (eBone->prop) {
726       newBone->prop = IDP_CopyProperty(eBone->prop);
727     }
728   }
729
730   /* Fix parenting in a separate pass to ensure ebone->bone connections are valid at this point.
731    * Do not set bone->head/tail here anymore,
732    * using EditBone data for that is not OK since our later fiddling with parent's arm_mat
733    * (for roll conversion) may have some small but visible impact on locations (T46010). */
734   for (eBone = arm->edbo->first; eBone; eBone = eBone->next) {
735     newBone = eBone->temp.bone;
736     if (eBone->parent) {
737       newBone->parent = eBone->parent->temp.bone;
738       BLI_addtail(&newBone->parent->childbase, newBone);
739     }
740     /*  ...otherwise add this bone to the armature's bonebase */
741     else {
742       BLI_addtail(&arm->bonebase, newBone);
743     }
744
745     /* Also transfer B-Bone custom handles. */
746     if (eBone->bbone_prev) {
747       newBone->bbone_prev = eBone->bbone_prev->temp.bone;
748     }
749     if (eBone->bbone_next) {
750       newBone->bbone_next = eBone->bbone_next->temp.bone;
751     }
752   }
753
754   /* Finalize definition of restpose data (roll, bone_mat, arm_mat, head/tail...). */
755   armature_finalize_restpose(&arm->bonebase, arm->edbo);
756
757   /* so all users of this armature should get rebuilt */
758   for (obt = bmain->objects.first; obt; obt = obt->id.next) {
759     if (obt->data == arm) {
760       BKE_pose_rebuild(bmain, obt, arm, true);
761     }
762   }
763
764   DEG_id_tag_update(&arm->id, 0);
765 }
766
767 void ED_armature_edit_free(struct bArmature *arm)
768 {
769   EditBone *eBone;
770
771   /*  Clear the editbones list */
772   if (arm->edbo) {
773     if (arm->edbo->first) {
774       for (eBone = arm->edbo->first; eBone; eBone = eBone->next) {
775         if (eBone->prop) {
776           IDP_FreeProperty(eBone->prop);
777           MEM_freeN(eBone->prop);
778         }
779       }
780
781       BLI_freelistN(arm->edbo);
782     }
783     MEM_freeN(arm->edbo);
784     arm->edbo = NULL;
785     arm->act_edbone = NULL;
786   }
787 }
788
789 /* Put armature in EditMode */
790 void ED_armature_to_edit(bArmature *arm)
791 {
792   ED_armature_edit_free(arm);
793   arm->edbo = MEM_callocN(sizeof(ListBase), "edbo armature");
794   arm->act_edbone = make_boneList(arm->edbo, &arm->bonebase, arm->act_bone);
795 }
796
797 /* *************************************************************** */
798 /* Used by Undo for Armature EditMode*/
799
800 /* free's bones and their properties */
801
802 void ED_armature_ebone_listbase_free(ListBase *lb)
803 {
804   EditBone *ebone, *ebone_next;
805
806   for (ebone = lb->first; ebone; ebone = ebone_next) {
807     ebone_next = ebone->next;
808
809     if (ebone->prop) {
810       IDP_FreeProperty(ebone->prop);
811       MEM_freeN(ebone->prop);
812     }
813
814     MEM_freeN(ebone);
815   }
816
817   BLI_listbase_clear(lb);
818 }
819
820 void ED_armature_ebone_listbase_copy(ListBase *lb_dst, ListBase *lb_src)
821 {
822   EditBone *ebone_src;
823   EditBone *ebone_dst;
824
825   BLI_assert(BLI_listbase_is_empty(lb_dst));
826
827   for (ebone_src = lb_src->first; ebone_src; ebone_src = ebone_src->next) {
828     ebone_dst = MEM_dupallocN(ebone_src);
829     if (ebone_dst->prop) {
830       ebone_dst->prop = IDP_CopyProperty(ebone_dst->prop);
831     }
832     ebone_src->temp.ebone = ebone_dst;
833     BLI_addtail(lb_dst, ebone_dst);
834   }
835
836   /* set pointers */
837   for (ebone_dst = lb_dst->first; ebone_dst; ebone_dst = ebone_dst->next) {
838     if (ebone_dst->parent) {
839       ebone_dst->parent = ebone_dst->parent->temp.ebone;
840     }
841     if (ebone_dst->bbone_next) {
842       ebone_dst->bbone_next = ebone_dst->bbone_next->temp.ebone;
843     }
844     if (ebone_dst->bbone_prev) {
845       ebone_dst->bbone_prev = ebone_dst->bbone_prev->temp.ebone;
846     }
847   }
848 }
849
850 void ED_armature_ebone_listbase_temp_clear(ListBase *lb)
851 {
852   EditBone *ebone;
853   /* be sure they don't hang ever */
854   for (ebone = lb->first; ebone; ebone = ebone->next) {
855     ebone->temp.p = NULL;
856   }
857 }
858
859 /* *************************************************************** */
860 /* Low level selection functions which hide connected-parent
861  * flag behavior which gets tricky to handle in selection operators.
862  * (no flushing in ED_armature_ebone_select.*, that should be explicit) */
863
864 int ED_armature_ebone_selectflag_get(const EditBone *ebone)
865 {
866   if (ebone->parent && (ebone->flag & BONE_CONNECTED)) {
867     return ((ebone->flag & (BONE_SELECTED | BONE_TIPSEL)) |
868             ((ebone->parent->flag & BONE_TIPSEL) ? BONE_ROOTSEL : 0));
869   }
870   else {
871     return (ebone->flag & (BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL));
872   }
873 }
874
875 void ED_armature_ebone_selectflag_set(EditBone *ebone, int flag)
876 {
877   flag = flag & (BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL);
878
879   if (ebone->parent && (ebone->flag & BONE_CONNECTED)) {
880     ebone->flag &= ~(BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL);
881     ebone->parent->flag &= ~BONE_TIPSEL;
882
883     ebone->flag |= flag;
884     ebone->parent->flag |= (flag & BONE_ROOTSEL) ? BONE_TIPSEL : 0;
885   }
886   else {
887     ebone->flag &= ~(BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL);
888     ebone->flag |= flag;
889   }
890 }
891
892 void ED_armature_ebone_selectflag_enable(EditBone *ebone, int flag)
893 {
894   BLI_assert((flag & (BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL)) != 0);
895   ED_armature_ebone_selectflag_set(ebone, ebone->flag | flag);
896 }
897
898 void ED_armature_ebone_selectflag_disable(EditBone *ebone, int flag)
899 {
900   BLI_assert((flag & (BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL)) != 0);
901   ED_armature_ebone_selectflag_set(ebone, ebone->flag & ~flag);
902 }
903
904 /* could be used in more places */
905 void ED_armature_ebone_select_set(EditBone *ebone, bool select)
906 {
907   int flag;
908   if (select) {
909     BLI_assert((ebone->flag & BONE_UNSELECTABLE) == 0);
910     flag = (BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
911   }
912   else {
913     flag = 0;
914   }
915   ED_armature_ebone_selectflag_set(ebone, flag);
916 }