Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / armature / armature_add.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  * Operators and API's for creating bones
19  */
20
21 /** \file
22  * \ingroup edarmature
23  */
24
25 #include "DNA_armature_types.h"
26 #include "DNA_constraint_types.h"
27 #include "DNA_object_types.h"
28 #include "DNA_scene_types.h"
29
30 #include "MEM_guardedalloc.h"
31
32 #include "BLI_blenlib.h"
33 #include "BLI_math.h"
34 #include "BLI_ghash.h"
35 #include "BLI_string_utils.h"
36
37 #include "BKE_action.h"
38 #include "BKE_constraint.h"
39 #include "BKE_context.h"
40 #include "BKE_idprop.h"
41 #include "BKE_deform.h"
42 #include "BKE_layer.h"
43
44 #include "RNA_access.h"
45 #include "RNA_define.h"
46
47 #include "WM_api.h"
48 #include "WM_types.h"
49
50 #include "ED_armature.h"
51 #include "ED_screen.h"
52 #include "ED_view3d.h"
53
54 #include "armature_intern.h"
55
56 /* *************** Adding stuff in editmode *************** */
57
58 /* default bone add, returns it selected, but without tail set */
59 /* XXX should be used everywhere, now it mallocs bones still locally in functions */
60 EditBone *ED_armature_ebone_add(bArmature *arm, const char *name)
61 {
62   EditBone *bone = MEM_callocN(sizeof(EditBone), "eBone");
63
64   BLI_strncpy(bone->name, name, sizeof(bone->name));
65   ED_armature_ebone_unique_name(arm->edbo, bone->name, NULL);
66
67   BLI_addtail(arm->edbo, bone);
68
69   bone->flag |= BONE_TIPSEL;
70   bone->weight = 1.0f;
71   bone->dist = 0.25f;
72   bone->xwidth = 0.1f;
73   bone->zwidth = 0.1f;
74   bone->rad_head = 0.10f;
75   bone->rad_tail = 0.05f;
76   bone->segments = 1;
77   bone->layer = arm->layer;
78
79   /* Bendy-Bone parameters */
80   bone->roll1 = 0.0f;
81   bone->roll2 = 0.0f;
82   bone->curveInX = 0.0f;
83   bone->curveInY = 0.0f;
84   bone->curveOutX = 0.0f;
85   bone->curveOutY = 0.0f;
86   bone->ease1 = 1.0f;
87   bone->ease2 = 1.0f;
88   bone->scaleIn = 1.0f;
89   bone->scaleOut = 1.0f;
90
91   return bone;
92 }
93
94 EditBone *ED_armature_ebone_add_primitive(Object *obedit_arm, float length, bool view_aligned)
95 {
96   bArmature *arm = obedit_arm->data;
97   EditBone *bone;
98
99   ED_armature_edit_deselect_all(obedit_arm);
100
101   /* Create a bone */
102   bone = ED_armature_ebone_add(arm, "Bone");
103
104   arm->act_edbone = bone;
105
106   zero_v3(bone->head);
107   zero_v3(bone->tail);
108
109   bone->tail[view_aligned ? 1 : 2] = length;
110
111   return bone;
112 }
113
114 /* previously addvert_armature */
115 /* the ctrl-click method */
116
117 /** Note this is already ported to multi-objects as it is.
118  * Since only the active bone is extruded even for single objects,
119  * it makes sense to stick to the active object here.
120  *
121  * If we want the support to be expanded we should something like the
122  * offset we do for mesh click extrude.
123  */
124 static int armature_click_extrude_exec(bContext *C, wmOperator *UNUSED(op))
125 {
126   bArmature *arm;
127   EditBone *ebone, *newbone, *flipbone;
128   float mat[3][3], imat[3][3];
129   int a, to_root = 0;
130   Object *obedit;
131   Scene *scene;
132
133   scene = CTX_data_scene(C);
134   obedit = CTX_data_edit_object(C);
135   arm = obedit->data;
136
137   /* find the active or selected bone */
138   for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
139     if (EBONE_VISIBLE(arm, ebone)) {
140       if (ebone->flag & BONE_TIPSEL || arm->act_edbone == ebone) {
141         break;
142       }
143     }
144   }
145
146   if (ebone == NULL) {
147     for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
148       if (EBONE_VISIBLE(arm, ebone)) {
149         if (ebone->flag & BONE_ROOTSEL || arm->act_edbone == ebone) {
150           break;
151         }
152       }
153     }
154     if (ebone == NULL) {
155       return OPERATOR_CANCELLED;
156     }
157
158     to_root = 1;
159   }
160
161   ED_armature_edit_deselect_all(obedit);
162
163   /* we re-use code for mirror editing... */
164   flipbone = NULL;
165   if (arm->flag & ARM_MIRROR_EDIT) {
166     flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
167   }
168
169   for (a = 0; a < 2; a++) {
170     if (a == 1) {
171       if (flipbone == NULL) {
172         break;
173       }
174       else {
175         SWAP(EditBone *, flipbone, ebone);
176       }
177     }
178
179     newbone = ED_armature_ebone_add(arm, ebone->name);
180     arm->act_edbone = newbone;
181
182     if (to_root) {
183       copy_v3_v3(newbone->head, ebone->head);
184       newbone->rad_head = ebone->rad_tail;
185       newbone->parent = ebone->parent;
186     }
187     else {
188       copy_v3_v3(newbone->head, ebone->tail);
189       newbone->rad_head = ebone->rad_tail;
190       newbone->parent = ebone;
191       newbone->flag |= BONE_CONNECTED;
192     }
193
194     const View3DCursor *curs = &scene->cursor;
195     copy_v3_v3(newbone->tail, curs->location);
196     sub_v3_v3v3(newbone->tail, newbone->tail, obedit->obmat[3]);
197
198     if (a == 1) {
199       newbone->tail[0] = -newbone->tail[0];
200     }
201
202     copy_m3_m4(mat, obedit->obmat);
203     invert_m3_m3(imat, mat);
204     mul_m3_v3(imat, newbone->tail);
205
206     newbone->length = len_v3v3(newbone->head, newbone->tail);
207     newbone->rad_tail = newbone->length * 0.05f;
208     newbone->dist = newbone->length * 0.25f;
209   }
210
211   ED_armature_edit_sync_selection(arm->edbo);
212
213   WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);
214
215   return OPERATOR_FINISHED;
216 }
217
218 static int armature_click_extrude_invoke(bContext *C, wmOperator *op, const wmEvent *event)
219 {
220   /* TODO most of this code is copied from set3dcursor_invoke,
221    * it would be better to reuse code in set3dcursor_invoke */
222
223   /* temporarily change 3d cursor position */
224   Scene *scene;
225   ARegion *ar;
226   View3D *v3d;
227   float tvec[3], oldcurs[3], mval_f[2];
228   int retv;
229
230   scene = CTX_data_scene(C);
231   ar = CTX_wm_region(C);
232   v3d = CTX_wm_view3d(C);
233
234   View3DCursor *cursor = &scene->cursor;
235
236   copy_v3_v3(oldcurs, cursor->location);
237
238   copy_v2fl_v2i(mval_f, event->mval);
239   ED_view3d_win_to_3d(v3d, ar, cursor->location, mval_f, tvec);
240   copy_v3_v3(cursor->location, tvec);
241
242   /* extrude to the where new cursor is and store the operation result */
243   retv = armature_click_extrude_exec(C, op);
244
245   /* restore previous 3d cursor position */
246   copy_v3_v3(cursor->location, oldcurs);
247
248   return retv;
249 }
250
251 void ARMATURE_OT_click_extrude(wmOperatorType *ot)
252 {
253   /* identifiers */
254   ot->name = "Click-Extrude";
255   ot->idname = "ARMATURE_OT_click_extrude";
256   ot->description = "Create a new bone going from the last selected joint to the mouse position";
257
258   /* api callbacks */
259   ot->invoke = armature_click_extrude_invoke;
260   ot->exec = armature_click_extrude_exec;
261   ot->poll = ED_operator_editarmature;
262
263   /* flags */
264   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
265
266   /* props */
267 }
268
269 /* adds an EditBone between the nominated locations (should be in the right space) */
270 EditBone *add_points_bone(Object *obedit, float head[3], float tail[3])
271 {
272   EditBone *ebo;
273
274   ebo = ED_armature_ebone_add(obedit->data, "Bone");
275
276   copy_v3_v3(ebo->head, head);
277   copy_v3_v3(ebo->tail, tail);
278
279   return ebo;
280 }
281
282 static EditBone *get_named_editbone(ListBase *edbo, const char *name)
283 {
284   EditBone *eBone;
285
286   if (name) {
287     for (eBone = edbo->first; eBone; eBone = eBone->next) {
288       if (STREQ(name, eBone->name)) {
289         return eBone;
290       }
291     }
292   }
293
294   return NULL;
295 }
296
297 /* Call this before doing any duplications
298  * */
299 void preEditBoneDuplicate(ListBase *editbones)
300 {
301   /* clear temp */
302   ED_armature_ebone_listbase_temp_clear(editbones);
303 }
304
305 /**
306  * Helper function for #postEditBoneDuplicate,
307  * return the destination pchan from the original.
308  */
309 static bPoseChannel *pchan_duplicate_map(const bPose *pose,
310                                          GHash *name_map,
311                                          bPoseChannel *pchan_src)
312 {
313   bPoseChannel *pchan_dst = NULL;
314   const char *name_src = pchan_src->name;
315   const char *name_dst = BLI_ghash_lookup(name_map, name_src);
316   if (name_dst) {
317     pchan_dst = BKE_pose_channel_find_name(pose, name_dst);
318   }
319
320   if (pchan_dst == NULL) {
321     pchan_dst = pchan_src;
322   }
323
324   return pchan_dst;
325 }
326
327 void postEditBoneDuplicate(struct ListBase *editbones, Object *ob)
328 {
329   if (ob->pose == NULL) {
330     return;
331   }
332
333   BKE_pose_channels_hash_free(ob->pose);
334   BKE_pose_channels_hash_make(ob->pose);
335
336   GHash *name_map = BLI_ghash_str_new(__func__);
337
338   for (EditBone *ebone_src = editbones->first; ebone_src; ebone_src = ebone_src->next) {
339     EditBone *ebone_dst = ebone_src->temp.ebone;
340     if (!ebone_dst) {
341       ebone_dst = ED_armature_ebone_get_mirrored(editbones, ebone_src);
342     }
343     if (ebone_dst) {
344       BLI_ghash_insert(name_map, ebone_src->name, ebone_dst->name);
345     }
346   }
347
348   for (EditBone *ebone_src = editbones->first; ebone_src; ebone_src = ebone_src->next) {
349     EditBone *ebone_dst = ebone_src->temp.ebone;
350     if (ebone_dst) {
351       bPoseChannel *pchan_src = BKE_pose_channel_find_name(ob->pose, ebone_src->name);
352       if (pchan_src) {
353         bPoseChannel *pchan_dst = BKE_pose_channel_find_name(ob->pose, ebone_dst->name);
354         if (pchan_dst) {
355           if (pchan_src->custom_tx) {
356             pchan_dst->custom_tx = pchan_duplicate_map(ob->pose, name_map, pchan_src->custom_tx);
357           }
358           if (pchan_src->bbone_prev) {
359             pchan_dst->bbone_prev = pchan_duplicate_map(ob->pose, name_map, pchan_src->bbone_prev);
360           }
361           if (pchan_src->bbone_next) {
362             pchan_dst->bbone_next = pchan_duplicate_map(ob->pose, name_map, pchan_src->bbone_next);
363           }
364         }
365       }
366     }
367   }
368
369   BLI_ghash_free(name_map, NULL, NULL);
370 }
371
372 /*
373  * Note: When duplicating cross objects, editbones here is the list of bones
374  * from the SOURCE object but ob is the DESTINATION object
375  * */
376 void updateDuplicateSubtargetObjects(EditBone *dupBone,
377                                      ListBase *editbones,
378                                      Object *src_ob,
379                                      Object *dst_ob)
380 {
381   /* If an edit bone has been duplicated, lets
382    * update it's constraints if the subtarget
383    * they point to has also been duplicated
384    */
385   EditBone *oldtarget, *newtarget;
386   bPoseChannel *pchan;
387   bConstraint *curcon;
388   ListBase *conlist;
389
390   if ((pchan = BKE_pose_channel_verify(dst_ob->pose, dupBone->name))) {
391     if ((conlist = &pchan->constraints)) {
392       for (curcon = conlist->first; curcon; curcon = curcon->next) {
393         /* does this constraint have a subtarget in
394          * this armature?
395          */
396         const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(curcon);
397         ListBase targets = {NULL, NULL};
398         bConstraintTarget *ct;
399
400         if (cti && cti->get_constraint_targets) {
401           cti->get_constraint_targets(curcon, &targets);
402
403           for (ct = targets.first; ct; ct = ct->next) {
404             if ((ct->tar == src_ob) && (ct->subtarget[0])) {
405               ct->tar = dst_ob; /* update target */
406               oldtarget = get_named_editbone(editbones, ct->subtarget);
407               if (oldtarget) {
408                 /* was the subtarget bone duplicated too? If
409                  * so, update the constraint to point at the
410                  * duplicate of the old subtarget.
411                  */
412                 if (oldtarget->temp.ebone) {
413                   newtarget = oldtarget->temp.ebone;
414                   BLI_strncpy(ct->subtarget, newtarget->name, sizeof(ct->subtarget));
415                 }
416               }
417             }
418           }
419
420           if (cti->flush_constraint_targets) {
421             cti->flush_constraint_targets(curcon, &targets, 0);
422           }
423         }
424       }
425     }
426   }
427 }
428
429 void updateDuplicateSubtarget(EditBone *dupBone, ListBase *editbones, Object *ob)
430 {
431   updateDuplicateSubtargetObjects(dupBone, editbones, ob, ob);
432 }
433
434 EditBone *duplicateEditBoneObjects(
435     EditBone *curBone, const char *name, ListBase *editbones, Object *src_ob, Object *dst_ob)
436 {
437   EditBone *eBone = MEM_mallocN(sizeof(EditBone), "addup_editbone");
438
439   /* Copy data from old bone to new bone */
440   memcpy(eBone, curBone, sizeof(EditBone));
441
442   curBone->temp.ebone = eBone;
443   eBone->temp.ebone = curBone;
444
445   if (name != NULL) {
446     BLI_strncpy(eBone->name, name, sizeof(eBone->name));
447   }
448
449   ED_armature_ebone_unique_name(editbones, eBone->name, NULL);
450   BLI_addtail(editbones, eBone);
451
452   /* copy the ID property */
453   if (curBone->prop) {
454     eBone->prop = IDP_CopyProperty(curBone->prop);
455   }
456
457   /* Lets duplicate the list of constraints that the
458    * current bone has.
459    */
460   if (src_ob->pose) {
461     bPoseChannel *chanold, *channew;
462
463     chanold = BKE_pose_channel_verify(src_ob->pose, curBone->name);
464     if (chanold) {
465       /* WARNING: this creates a new posechannel, but there will not be an attached bone
466        * yet as the new bones created here are still 'EditBones' not 'Bones'.
467        */
468       channew = BKE_pose_channel_verify(dst_ob->pose, eBone->name);
469
470       if (channew) {
471         BKE_pose_channel_copy_data(channew, chanold);
472       }
473     }
474   }
475
476   return eBone;
477 }
478
479 EditBone *duplicateEditBone(EditBone *curBone, const char *name, ListBase *editbones, Object *ob)
480 {
481   return duplicateEditBoneObjects(curBone, name, editbones, ob, ob);
482 }
483
484 static int armature_duplicate_selected_exec(bContext *C, wmOperator *op)
485 {
486   ViewLayer *view_layer = CTX_data_view_layer(C);
487   const bool do_flip_names = RNA_boolean_get(op->ptr, "do_flip_names");
488
489   /* cancel if nothing selected */
490   if (CTX_DATA_COUNT(C, selected_bones) == 0) {
491     return OPERATOR_CANCELLED;
492   }
493
494   uint objects_len = 0;
495   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
496       view_layer, CTX_wm_view3d(C), &objects_len);
497   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
498     EditBone *ebone_iter;
499     /* The beginning of the duplicated bones in the edbo list */
500     EditBone *ebone_first_dupe = NULL;
501
502     Object *ob = objects[ob_index];
503     bArmature *arm = ob->data;
504
505     ED_armature_edit_sync_selection(arm->edbo);  // XXX why is this needed?
506
507     preEditBoneDuplicate(arm->edbo);
508
509     /* Select mirrored bones */
510     if (arm->flag & ARM_MIRROR_EDIT) {
511       for (ebone_iter = arm->edbo->first; ebone_iter; ebone_iter = ebone_iter->next) {
512         if (EBONE_VISIBLE(arm, ebone_iter) && (ebone_iter->flag & BONE_SELECTED)) {
513           EditBone *ebone;
514
515           ebone = ED_armature_ebone_get_mirrored(arm->edbo, ebone_iter);
516           if (ebone) {
517             ebone->flag |= BONE_SELECTED;
518           }
519         }
520       }
521     }
522
523     /* Find the selected bones and duplicate them as needed */
524     for (ebone_iter = arm->edbo->first; ebone_iter && ebone_iter != ebone_first_dupe;
525          ebone_iter = ebone_iter->next) {
526       if (EBONE_VISIBLE(arm, ebone_iter) && (ebone_iter->flag & BONE_SELECTED)) {
527         EditBone *ebone;
528         char new_bone_name_buff[MAXBONENAME];
529         char *new_bone_name = ebone_iter->name;
530
531         if (do_flip_names) {
532           BLI_string_flip_side_name(
533               new_bone_name_buff, ebone_iter->name, false, sizeof(new_bone_name_buff));
534
535           /* Only use flipped name if not yet in use. Otherwise we'd get again inconsistent namings
536            * (different numbers), better keep default behavior in this case. */
537           if (ED_armature_ebone_find_name(arm->edbo, new_bone_name_buff) == NULL) {
538             new_bone_name = new_bone_name_buff;
539           }
540         }
541
542         ebone = duplicateEditBone(ebone_iter, new_bone_name, arm->edbo, ob);
543
544         if (!ebone_first_dupe) {
545           ebone_first_dupe = ebone;
546         }
547       }
548     }
549
550     /* Run though the list and fix the pointers */
551     for (ebone_iter = arm->edbo->first; ebone_iter && ebone_iter != ebone_first_dupe;
552          ebone_iter = ebone_iter->next) {
553       if (EBONE_VISIBLE(arm, ebone_iter) && (ebone_iter->flag & BONE_SELECTED)) {
554         EditBone *ebone = ebone_iter->temp.ebone;
555
556         if (!ebone_iter->parent) {
557           /* If this bone has no parent,
558            * Set the duplicate->parent to NULL
559            */
560           ebone->parent = NULL;
561         }
562         else if (ebone_iter->parent->temp.ebone) {
563           /* If this bone has a parent that was duplicated,
564            * Set the duplicate->parent to the curBone->parent->temp
565            */
566           ebone->parent = ebone_iter->parent->temp.ebone;
567         }
568         else {
569           /* If this bone has a parent that IS not selected,
570            * Set the duplicate->parent to the curBone->parent
571            */
572           ebone->parent = (EditBone *)ebone_iter->parent;
573           ebone->flag &= ~BONE_CONNECTED;
574         }
575
576         /* Update custom handle links. */
577         if (ebone_iter->bbone_prev && ebone_iter->bbone_prev->temp.ebone) {
578           ebone->bbone_prev = ebone_iter->bbone_prev->temp.ebone;
579         }
580         if (ebone_iter->bbone_next && ebone_iter->bbone_next->temp.ebone) {
581           ebone->bbone_next = ebone_iter->bbone_next->temp.ebone;
582         }
583
584         /* Lets try to fix any constraint subtargets that might
585          * have been duplicated
586          */
587         updateDuplicateSubtarget(ebone, arm->edbo, ob);
588       }
589     }
590
591     /* correct the active bone */
592     if (arm->act_edbone && arm->act_edbone->temp.ebone) {
593       arm->act_edbone = arm->act_edbone->temp.ebone;
594     }
595
596     /* Deselect the old bones and select the new ones */
597     for (ebone_iter = arm->edbo->first; ebone_iter && ebone_iter != ebone_first_dupe;
598          ebone_iter = ebone_iter->next) {
599       if (EBONE_VISIBLE(arm, ebone_iter)) {
600         ebone_iter->flag &= ~(BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
601       }
602     }
603
604     postEditBoneDuplicate(arm->edbo, ob);
605
606     ED_armature_edit_validate_active(arm);
607
608     WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
609   }
610   MEM_freeN(objects);
611
612   return OPERATOR_FINISHED;
613 }
614
615 void ARMATURE_OT_duplicate(wmOperatorType *ot)
616 {
617   /* identifiers */
618   ot->name = "Duplicate Selected Bone(s)";
619   ot->idname = "ARMATURE_OT_duplicate";
620   ot->description = "Make copies of the selected bones within the same armature";
621
622   /* api callbacks */
623   ot->exec = armature_duplicate_selected_exec;
624   ot->poll = ED_operator_editarmature;
625
626   /* flags */
627   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
628
629   RNA_def_boolean(
630       ot->srna,
631       "do_flip_names",
632       false,
633       "Flip Names",
634       "Try to flip names of the bones, if possible, instead of adding a number extension");
635 }
636
637 /* Get the duplicated or existing mirrored copy of the bone. */
638 static EditBone *get_symmetrized_bone(bArmature *arm, EditBone *bone)
639 {
640   if (bone == NULL) {
641     return NULL;
642   }
643   else if (bone->temp.ebone != NULL) {
644     return bone->temp.ebone;
645   }
646   else {
647     EditBone *mirror = ED_armature_ebone_get_mirrored(arm->edbo, bone);
648     return (mirror != NULL) ? mirror : bone;
649   }
650 }
651
652 /**
653  * near duplicate of #armature_duplicate_selected_exec,
654  * except for parenting part (keep in sync)
655  */
656 static int armature_symmetrize_exec(bContext *C, wmOperator *op)
657 {
658   ViewLayer *view_layer = CTX_data_view_layer(C);
659   const int direction = RNA_enum_get(op->ptr, "direction");
660   const int axis = 0;
661
662   /* cancel if nothing selected */
663   if (CTX_DATA_COUNT(C, selected_bones) == 0) {
664     return OPERATOR_CANCELLED;
665   }
666
667   uint objects_len = 0;
668   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
669       view_layer, CTX_wm_view3d(C), &objects_len);
670   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
671     Object *obedit = objects[ob_index];
672     bArmature *arm = obedit->data;
673
674     EditBone *ebone_iter;
675     /* The beginning of the duplicated mirrored bones in the edbo list */
676     EditBone *ebone_first_dupe = NULL;
677
678     ED_armature_edit_sync_selection(arm->edbo);  // XXX why is this needed?
679
680     preEditBoneDuplicate(arm->edbo);
681
682     /* Select mirrored bones */
683     for (ebone_iter = arm->edbo->first; ebone_iter; ebone_iter = ebone_iter->next) {
684       if (EBONE_VISIBLE(arm, ebone_iter) && (ebone_iter->flag & BONE_SELECTED)) {
685         char name_flip[MAXBONENAME];
686
687         BLI_string_flip_side_name(name_flip, ebone_iter->name, false, sizeof(name_flip));
688
689         if (STREQ(name_flip, ebone_iter->name)) {
690           /* if the name matches, we don't have the potential to be mirrored, just skip */
691           ebone_iter->flag &= ~(BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
692         }
693         else {
694           EditBone *ebone = ED_armature_ebone_find_name(arm->edbo, name_flip);
695
696           if (ebone) {
697             if ((ebone->flag & BONE_SELECTED) == 0) {
698               /* simple case, we're selected, the other bone isn't! */
699               ebone_iter->temp.ebone = ebone;
700             }
701             else {
702               /* complicated - choose which direction to copy */
703               float axis_delta;
704
705               axis_delta = ebone->head[axis] - ebone_iter->head[axis];
706               if (axis_delta == 0.0f) {
707                 axis_delta = ebone->tail[axis] - ebone_iter->tail[axis];
708               }
709
710               if (axis_delta == 0.0f) {
711                 /* both mirrored bones exist and point to eachother and overlap exactly.
712                  *
713                  * in this case there's no well defined solution, so de-select both and skip.
714                  */
715                 ebone->flag &= ~(BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
716                 ebone_iter->flag &= ~(BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
717               }
718               else {
719                 EditBone *ebone_src, *ebone_dst;
720                 if (((axis_delta < 0.0f) ? -1 : 1) == direction) {
721                   ebone_src = ebone;
722                   ebone_dst = ebone_iter;
723                 }
724                 else {
725                   ebone_src = ebone_iter;
726                   ebone_dst = ebone;
727                 }
728
729                 ebone_src->temp.ebone = ebone_dst;
730                 ebone_dst->flag &= ~(BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
731               }
732             }
733           }
734         }
735       }
736     }
737
738     /*  Find the selected bones and duplicate them as needed, with mirrored name */
739     for (ebone_iter = arm->edbo->first; ebone_iter && ebone_iter != ebone_first_dupe;
740          ebone_iter = ebone_iter->next) {
741       if (EBONE_VISIBLE(arm, ebone_iter) && (ebone_iter->flag & BONE_SELECTED) &&
742           /* will be set if the mirror bone already exists (no need to make a new one) */
743           (ebone_iter->temp.ebone == NULL)) {
744         char name_flip[MAXBONENAME];
745
746         BLI_string_flip_side_name(name_flip, ebone_iter->name, false, sizeof(name_flip));
747
748         /* bones must have a side-suffix */
749         if (!STREQ(name_flip, ebone_iter->name)) {
750           EditBone *ebone;
751
752           ebone = duplicateEditBone(ebone_iter, name_flip, arm->edbo, obedit);
753
754           if (!ebone_first_dupe) {
755             ebone_first_dupe = ebone;
756           }
757         }
758       }
759     }
760
761     /*  Run through the list and fix the pointers */
762     for (ebone_iter = arm->edbo->first; ebone_iter && ebone_iter != ebone_first_dupe;
763          ebone_iter = ebone_iter->next) {
764       if (ebone_iter->temp.ebone) {
765         /* copy all flags except for ... */
766         const int flag_copy = ((int)~0) & ~(BONE_SELECTED | BONE_ROOTSEL | BONE_TIPSEL);
767
768         EditBone *ebone = ebone_iter->temp.ebone;
769
770         /* copy flags incase bone is pre-existing data */
771         ebone->flag = (ebone->flag & ~flag_copy) | (ebone_iter->flag & flag_copy);
772
773         if (ebone_iter->parent == NULL) {
774           /* If this bone has no parent,
775            * Set the duplicate->parent to NULL
776            */
777           ebone->parent = NULL;
778           ebone->flag &= ~BONE_CONNECTED;
779         }
780         else {
781           /* the parent may have been duplicated, if not lookup the mirror parent */
782           EditBone *ebone_parent = get_symmetrized_bone(arm, ebone_iter->parent);
783
784           if (ebone_parent == ebone_iter->parent) {
785             /* If the mirror lookup failed, (but the current bone has a parent)
786              * then we can assume the parent has no L/R but is a center bone.
787              * So just use the same parent for both.
788              */
789             ebone->flag &= ~BONE_CONNECTED;
790           }
791
792           ebone->parent = ebone_parent;
793         }
794
795         /* Update custom handle links. */
796         ebone->bbone_prev = get_symmetrized_bone(arm, ebone_iter->bbone_prev);
797         ebone->bbone_next = get_symmetrized_bone(arm, ebone_iter->bbone_next);
798
799         /* Lets try to fix any constraint subtargets that might
800          * have been duplicated
801          */
802         updateDuplicateSubtarget(ebone, arm->edbo, obedit);
803       }
804     }
805
806     ED_armature_edit_transform_mirror_update(obedit);
807
808     /* Selected bones now have their 'temp' pointer set,
809      * so we don't need this anymore */
810
811     /* Deselect the old bones and select the new ones */
812     for (ebone_iter = arm->edbo->first; ebone_iter && ebone_iter != ebone_first_dupe;
813          ebone_iter = ebone_iter->next) {
814       if (EBONE_VISIBLE(arm, ebone_iter)) {
815         ebone_iter->flag &= ~(BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
816       }
817     }
818
819     /* New bones will be selected, but some of the bones may already exist */
820     for (ebone_iter = arm->edbo->first; ebone_iter && ebone_iter != ebone_first_dupe;
821          ebone_iter = ebone_iter->next) {
822       EditBone *ebone = ebone_iter->temp.ebone;
823       if (ebone && EBONE_SELECTABLE(arm, ebone)) {
824         ED_armature_ebone_select_set(ebone, true);
825       }
826     }
827
828     /* correct the active bone */
829     if (arm->act_edbone && arm->act_edbone->temp.ebone) {
830       arm->act_edbone = arm->act_edbone->temp.ebone;
831     }
832
833     postEditBoneDuplicate(arm->edbo, obedit);
834
835     ED_armature_edit_validate_active(arm);
836
837     WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);
838   }
839   MEM_freeN(objects);
840
841   return OPERATOR_FINISHED;
842 }
843
844 /* following conventions from #MESH_OT_symmetrize */
845 void ARMATURE_OT_symmetrize(wmOperatorType *ot)
846 {
847   /* subset of 'rna_enum_symmetrize_direction_items' */
848   static const EnumPropertyItem arm_symmetrize_direction_items[] = {
849       {-1, "NEGATIVE_X", 0, "-X to +X", ""},
850       {+1, "POSITIVE_X", 0, "+X to -X", ""},
851       {0, NULL, 0, NULL, NULL},
852   };
853
854   /* identifiers */
855   ot->name = "Symmetrize";
856   ot->idname = "ARMATURE_OT_symmetrize";
857   ot->description = "Enforce symmetry, make copies of the selection or use existing";
858
859   /* api callbacks */
860   ot->exec = armature_symmetrize_exec;
861   ot->poll = ED_operator_editarmature;
862
863   /* flags */
864   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
865
866   ot->prop = RNA_def_enum(ot->srna,
867                           "direction",
868                           arm_symmetrize_direction_items,
869                           -1,
870                           "Direction",
871                           "Which sides to copy from and to (when both are selected)");
872 }
873
874 /* ------------------------------------------ */
875
876 /* previously extrude_armature */
877 /* context; editmode armature */
878 /* if forked && mirror-edit: makes two bones with flipped names */
879 static int armature_extrude_exec(bContext *C, wmOperator *op)
880 {
881   ViewLayer *view_layer = CTX_data_view_layer(C);
882   const bool forked = RNA_boolean_get(op->ptr, "forked");
883   bool changed_multi = false;
884
885   uint objects_len = 0;
886   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
887       view_layer, CTX_wm_view3d(C), &objects_len);
888   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
889     Object *ob = objects[ob_index];
890     bArmature *arm = ob->data;
891     bool forked_iter = forked;
892
893     EditBone *newbone = NULL, *ebone, *flipbone, *first = NULL;
894     int a, totbone = 0, do_extrude;
895
896     /* since we allow root extrude too, we have to make sure selection is OK */
897     for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
898       if (EBONE_VISIBLE(arm, ebone)) {
899         if (ebone->flag & BONE_ROOTSEL) {
900           if (ebone->parent && (ebone->flag & BONE_CONNECTED)) {
901             if (ebone->parent->flag & BONE_TIPSEL) {
902               ebone->flag &= ~BONE_ROOTSEL;
903             }
904           }
905         }
906       }
907     }
908
909     /* Duplicate the necessary bones */
910     for (ebone = arm->edbo->first; ((ebone) && (ebone != first)); ebone = ebone->next) {
911       if (EBONE_VISIBLE(arm, ebone)) {
912         /* we extrude per definition the tip */
913         do_extrude = false;
914         if (ebone->flag & (BONE_TIPSEL | BONE_SELECTED)) {
915           do_extrude = true;
916         }
917         else if (ebone->flag & BONE_ROOTSEL) {
918           /* but, a bone with parent deselected we do the root... */
919           if (ebone->parent && (ebone->parent->flag & BONE_TIPSEL)) {
920             /* pass */
921           }
922           else {
923             do_extrude = 2;
924           }
925         }
926
927         if (do_extrude) {
928           /* we re-use code for mirror editing... */
929           flipbone = NULL;
930           if (arm->flag & ARM_MIRROR_EDIT) {
931             flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
932             if (flipbone) {
933               forked_iter = 0;  // we extrude 2 different bones
934               if (flipbone->flag & (BONE_TIPSEL | BONE_ROOTSEL | BONE_SELECTED)) {
935                 /* don't want this bone to be selected... */
936                 flipbone->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);
937               }
938             }
939             if ((flipbone == NULL) && (forked_iter)) {
940               flipbone = ebone;
941             }
942           }
943
944           for (a = 0; a < 2; a++) {
945             if (a == 1) {
946               if (flipbone == NULL) {
947                 break;
948               }
949               else {
950                 SWAP(EditBone *, flipbone, ebone);
951               }
952             }
953
954             totbone++;
955             newbone = MEM_callocN(sizeof(EditBone), "extrudebone");
956
957             if (do_extrude == true) {
958               copy_v3_v3(newbone->head, ebone->tail);
959               copy_v3_v3(newbone->tail, newbone->head);
960               newbone->parent = ebone;
961
962               /* copies it, in case mirrored bone */
963               newbone->flag = ebone->flag & (BONE_TIPSEL | BONE_RELATIVE_PARENTING);
964
965               if (newbone->parent) {
966                 newbone->flag |= BONE_CONNECTED;
967               }
968             }
969             else {
970               copy_v3_v3(newbone->head, ebone->head);
971               copy_v3_v3(newbone->tail, ebone->head);
972               newbone->parent = ebone->parent;
973
974               newbone->flag = BONE_TIPSEL;
975
976               if (newbone->parent && (ebone->flag & BONE_CONNECTED)) {
977                 newbone->flag |= BONE_CONNECTED;
978               }
979             }
980
981             newbone->weight = ebone->weight;
982             newbone->dist = ebone->dist;
983             newbone->xwidth = ebone->xwidth;
984             newbone->zwidth = ebone->zwidth;
985             newbone->rad_head = ebone->rad_tail;  // don't copy entire bone...
986             newbone->rad_tail = ebone->rad_tail;
987             newbone->segments = 1;
988             newbone->layer = ebone->layer;
989
990             /* Bendy-Bone parameters */
991             newbone->roll1 = ebone->roll1;
992             newbone->roll2 = ebone->roll2;
993             newbone->curveInX = ebone->curveInX;
994             newbone->curveInY = ebone->curveInY;
995             newbone->curveOutX = ebone->curveOutX;
996             newbone->curveOutY = ebone->curveOutY;
997             newbone->ease1 = ebone->ease1;
998             newbone->ease2 = ebone->ease2;
999             newbone->scaleIn = ebone->scaleIn;
1000             newbone->scaleOut = ebone->scaleOut;
1001
1002             BLI_strncpy(newbone->name, ebone->name, sizeof(newbone->name));
1003
1004             if (flipbone && forked_iter) {  // only set if mirror edit
1005               if (strlen(newbone->name) < (MAXBONENAME - 2)) {
1006                 if (a == 0) {
1007                   strcat(newbone->name, "_L");
1008                 }
1009                 else {
1010                   strcat(newbone->name, "_R");
1011                 }
1012               }
1013             }
1014             ED_armature_ebone_unique_name(arm->edbo, newbone->name, NULL);
1015
1016             /* Add the new bone to the list */
1017             BLI_addtail(arm->edbo, newbone);
1018             if (!first) {
1019               first = newbone;
1020             }
1021
1022             /* restore ebone if we were flipping */
1023             if (a == 1 && flipbone) {
1024               SWAP(EditBone *, flipbone, ebone);
1025             }
1026           }
1027         }
1028
1029         /* Deselect the old bone */
1030         ebone->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);
1031       }
1032     }
1033     /* if only one bone, make this one active */
1034     if (totbone == 1 && first) {
1035       arm->act_edbone = first;
1036     }
1037     else {
1038       arm->act_edbone = newbone;
1039     }
1040
1041     if (totbone == 0) {
1042       continue;
1043     }
1044
1045     changed_multi = true;
1046
1047     /* Transform the endpoints */
1048     ED_armature_edit_sync_selection(arm->edbo);
1049
1050     WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
1051   }
1052   MEM_freeN(objects);
1053
1054   return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1055 }
1056
1057 void ARMATURE_OT_extrude(wmOperatorType *ot)
1058 {
1059   /* identifiers */
1060   ot->name = "Extrude";
1061   ot->idname = "ARMATURE_OT_extrude";
1062   ot->description = "Create new bones from the selected joints";
1063
1064   /* api callbacks */
1065   ot->exec = armature_extrude_exec;
1066   ot->poll = ED_operator_editarmature;
1067
1068   /* flags */
1069   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1070
1071   /* props */
1072   RNA_def_boolean(ot->srna, "forked", 0, "Forked", "");
1073 }
1074
1075 /* ********************** Bone Add *************************************/
1076
1077 /*op makes a new bone and returns it with its tip selected */
1078
1079 static int armature_bone_primitive_add_exec(bContext *C, wmOperator *op)
1080 {
1081   RegionView3D *rv3d = CTX_wm_region_view3d(C);
1082   Object *obedit = CTX_data_edit_object(C);
1083   EditBone *bone;
1084   float obmat[3][3], curs[3], viewmat[3][3], totmat[3][3], imat[3][3];
1085   char name[MAXBONENAME];
1086
1087   RNA_string_get(op->ptr, "name", name);
1088
1089   copy_v3_v3(curs, CTX_data_scene(C)->cursor.location);
1090
1091   /* Get inverse point for head and orientation for tail */
1092   invert_m4_m4(obedit->imat, obedit->obmat);
1093   mul_m4_v3(obedit->imat, curs);
1094
1095   if (rv3d && (U.flag & USER_ADD_VIEWALIGNED)) {
1096     copy_m3_m4(obmat, rv3d->viewmat);
1097   }
1098   else {
1099     unit_m3(obmat);
1100   }
1101
1102   copy_m3_m4(viewmat, obedit->obmat);
1103   mul_m3_m3m3(totmat, obmat, viewmat);
1104   invert_m3_m3(imat, totmat);
1105
1106   ED_armature_edit_deselect_all(obedit);
1107
1108   /*  Create a bone */
1109   bone = ED_armature_ebone_add(obedit->data, name);
1110
1111   copy_v3_v3(bone->head, curs);
1112
1113   if (rv3d && (U.flag & USER_ADD_VIEWALIGNED)) {
1114     add_v3_v3v3(bone->tail, bone->head, imat[1]);  // bone with unit length 1
1115   }
1116   else {
1117     add_v3_v3v3(bone->tail, bone->head, imat[2]);  // bone with unit length 1, pointing up Z
1118   }
1119
1120   /* note, notifier might evolve */
1121   WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);
1122
1123   return OPERATOR_FINISHED;
1124 }
1125
1126 void ARMATURE_OT_bone_primitive_add(wmOperatorType *ot)
1127 {
1128   /* identifiers */
1129   ot->name = "Add Bone";
1130   ot->idname = "ARMATURE_OT_bone_primitive_add";
1131   ot->description = "Add a new bone located at the 3D-Cursor";
1132
1133   /* api callbacks */
1134   ot->exec = armature_bone_primitive_add_exec;
1135   ot->poll = ED_operator_editarmature;
1136
1137   /* flags */
1138   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1139
1140   RNA_def_string(ot->srna, "name", "Bone", MAXBONENAME, "Name", "Name of the newly created bone");
1141 }
1142
1143 /* ********************** Subdivide *******************************/
1144
1145 /* Subdivide Operators:
1146  * This group of operators all use the same 'exec' callback, but they are called
1147  * through several different operators - a combined menu (which just calls the exec in the
1148  * appropriate ways), and two separate ones.
1149  */
1150
1151 static int armature_subdivide_exec(bContext *C, wmOperator *op)
1152 {
1153   Object *obedit = CTX_data_edit_object(C);
1154   EditBone *newbone, *tbone;
1155   int cuts, i;
1156
1157   /* there may not be a number_cuts property defined (for 'simple' subdivide) */
1158   cuts = RNA_int_get(op->ptr, "number_cuts");
1159
1160   /* loop over all editable bones */
1161   // XXX the old code did this in reverse order though!
1162   CTX_DATA_BEGIN_WITH_ID (C, EditBone *, ebone, selected_editable_bones, bArmature *, arm) {
1163     for (i = cuts + 1; i > 1; i--) {
1164       /* compute cut ratio first */
1165       float cutratio = 1.0f / (float)i;
1166       float cutratioI = 1.0f - cutratio;
1167
1168       float val1[3];
1169       float val2[3];
1170       float val3[3];
1171
1172       newbone = MEM_mallocN(sizeof(EditBone), "ebone subdiv");
1173       *newbone = *ebone;
1174       BLI_addtail(arm->edbo, newbone);
1175
1176       /* calculate location of newbone->head */
1177       copy_v3_v3(val1, ebone->head);
1178       copy_v3_v3(val2, ebone->tail);
1179       copy_v3_v3(val3, newbone->head);
1180
1181       val3[0] = val1[0] * cutratio + val2[0] * cutratioI;
1182       val3[1] = val1[1] * cutratio + val2[1] * cutratioI;
1183       val3[2] = val1[2] * cutratio + val2[2] * cutratioI;
1184
1185       copy_v3_v3(newbone->head, val3);
1186       copy_v3_v3(newbone->tail, ebone->tail);
1187       copy_v3_v3(ebone->tail, newbone->head);
1188
1189       newbone->rad_head = ((ebone->rad_head * cutratio) + (ebone->rad_tail * cutratioI));
1190       ebone->rad_tail = newbone->rad_head;
1191
1192       newbone->flag |= BONE_CONNECTED;
1193
1194       newbone->prop = NULL;
1195
1196       ED_armature_ebone_unique_name(arm->edbo, newbone->name, NULL);
1197
1198       /* correct parent bones */
1199       for (tbone = arm->edbo->first; tbone; tbone = tbone->next) {
1200         if (tbone->parent == ebone) {
1201           tbone->parent = newbone;
1202         }
1203       }
1204       newbone->parent = ebone;
1205     }
1206   }
1207   CTX_DATA_END;
1208
1209   /* note, notifier might evolve */
1210   WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, obedit);
1211
1212   return OPERATOR_FINISHED;
1213 }
1214
1215 void ARMATURE_OT_subdivide(wmOperatorType *ot)
1216 {
1217   PropertyRNA *prop;
1218
1219   /* identifiers */
1220   ot->name = "Subdivide Multi";
1221   ot->idname = "ARMATURE_OT_subdivide";
1222   ot->description = "Break selected bones into chains of smaller bones";
1223
1224   /* api callbacks */
1225   ot->exec = armature_subdivide_exec;
1226   ot->poll = ED_operator_editarmature;
1227
1228   /* flags */
1229   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1230
1231   /* Properties */
1232   prop = RNA_def_int(ot->srna, "number_cuts", 1, 1, 1000, "Number of Cuts", "", 1, 10);
1233   /* Avoid re-using last var because it can cause
1234    * _very_ high poly meshes and annoy users (or worse crash) */
1235   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1236 }