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