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