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