Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / armature / armature_relations.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 for relations between bones and for transferring bones between armature objects
19  */
20
21 /** \file
22  * \ingroup edarmature
23  */
24
25 #include "MEM_guardedalloc.h"
26
27 #include "DNA_anim_types.h"
28 #include "DNA_armature_types.h"
29 #include "DNA_constraint_types.h"
30 #include "DNA_object_types.h"
31 #include "DNA_scene_types.h"
32
33 #include "BLI_blenlib.h"
34 #include "BLI_ghash.h"
35 #include "BLI_math.h"
36
37 #include "BLT_translation.h"
38
39 #include "BKE_action.h"
40 #include "BKE_animsys.h"
41 #include "BKE_constraint.h"
42 #include "BKE_context.h"
43 #include "BKE_fcurve.h"
44 #include "BKE_layer.h"
45 #include "BKE_main.h"
46 #include "BKE_report.h"
47
48 #include "DEG_depsgraph.h"
49 #include "DEG_depsgraph_build.h"
50
51 #include "RNA_access.h"
52 #include "RNA_define.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "ED_armature.h"
58 #include "ED_object.h"
59 #include "ED_screen.h"
60
61 #include "UI_interface.h"
62 #include "UI_resources.h"
63
64 #include "armature_intern.h"
65
66 /* *************************************** Join *************************************** */
67 /* NOTE: no operator define here as this is exported to the Object-level operator */
68
69 static void joined_armature_fix_links_constraints(
70     Object *tarArm, Object *srcArm, bPoseChannel *pchan, EditBone *curbone, ListBase *lb)
71 {
72   bConstraint *con;
73
74   for (con = lb->first; con; con = con->next) {
75     const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
76     ListBase targets = {NULL, NULL};
77     bConstraintTarget *ct;
78
79     /* constraint targets */
80     if (cti && cti->get_constraint_targets) {
81       cti->get_constraint_targets(con, &targets);
82
83       for (ct = targets.first; ct; ct = ct->next) {
84         if (ct->tar == srcArm) {
85           if (ct->subtarget[0] == '\0') {
86             ct->tar = tarArm;
87           }
88           else if (STREQ(ct->subtarget, pchan->name)) {
89             ct->tar = tarArm;
90             BLI_strncpy(ct->subtarget, curbone->name, sizeof(ct->subtarget));
91           }
92         }
93       }
94
95       if (cti->flush_constraint_targets) {
96         cti->flush_constraint_targets(con, &targets, 0);
97       }
98     }
99
100     /* action constraint? (pose constraints only) */
101     if (con->type == CONSTRAINT_TYPE_ACTION) {
102       bActionConstraint *data = con->data;
103
104       if (data->act) {
105         BKE_action_fix_paths_rename(
106             &tarArm->id, data->act, "pose.bones[", pchan->name, curbone->name, 0, 0, false);
107       }
108     }
109   }
110 }
111
112 /* userdata for joined_armature_fix_animdata_cb() */
113 typedef struct tJoinArmature_AdtFixData {
114   Object *srcArm;
115   Object *tarArm;
116
117   GHash *names_map;
118 } tJoinArmature_AdtFixData;
119
120 /* Callback to pass to BKE_animdata_main_cb() for fixing driver ID's to point to the new ID. */
121 /* FIXME: For now, we only care about drivers here.
122  *        When editing rigs, it's very rare to have animation on the rigs being edited already,
123  *        so it should be safe to skip these.
124  */
125 static void joined_armature_fix_animdata_cb(ID *id, FCurve *fcu, void *user_data)
126 {
127   tJoinArmature_AdtFixData *afd = (tJoinArmature_AdtFixData *)user_data;
128   ID *src_id = &afd->srcArm->id;
129   ID *dst_id = &afd->tarArm->id;
130
131   GHashIterator gh_iter;
132
133   /* Fix paths - If this is the target object, it will have some "dirty" paths */
134   if ((id == src_id) && strstr(fcu->rna_path, "pose.bones[")) {
135     GHASH_ITER (gh_iter, afd->names_map) {
136       const char *old_name = BLI_ghashIterator_getKey(&gh_iter);
137       const char *new_name = BLI_ghashIterator_getValue(&gh_iter);
138
139       /* only remap if changed; this still means there will be some
140        * waste if there aren't many drivers/keys */
141       if (!STREQ(old_name, new_name) && strstr(fcu->rna_path, old_name)) {
142         fcu->rna_path = BKE_animsys_fix_rna_path_rename(
143             id, fcu->rna_path, "pose.bones", old_name, new_name, 0, 0, false);
144
145         /* we don't want to apply a second remapping on this driver now,
146          * so stop trying names, but keep fixing drivers
147          */
148         break;
149       }
150     }
151   }
152
153   /* Driver targets */
154   if (fcu->driver) {
155     ChannelDriver *driver = fcu->driver;
156     DriverVar *dvar;
157
158     /* Fix driver references to invalid ID's */
159     for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
160       /* only change the used targets, since the others will need fixing manually anyway */
161       DRIVER_TARGETS_USED_LOOPER_BEGIN (dvar) {
162         /* change the ID's used... */
163         if (dtar->id == src_id) {
164           dtar->id = dst_id;
165
166           /* also check on the subtarget...
167            * XXX: We duplicate the logic from drivers_path_rename_fix() here, with our own
168            *      little twists so that we know that it isn't going to clobber the wrong data
169            */
170           if ((dtar->rna_path && strstr(dtar->rna_path, "pose.bones[")) || (dtar->pchan_name[0])) {
171             GHASH_ITER (gh_iter, afd->names_map) {
172               const char *old_name = BLI_ghashIterator_getKey(&gh_iter);
173               const char *new_name = BLI_ghashIterator_getValue(&gh_iter);
174
175               /* only remap if changed */
176               if (!STREQ(old_name, new_name)) {
177                 if ((dtar->rna_path) && strstr(dtar->rna_path, old_name)) {
178                   /* Fix up path */
179                   dtar->rna_path = BKE_animsys_fix_rna_path_rename(
180                       id, dtar->rna_path, "pose.bones", old_name, new_name, 0, 0, false);
181                   break; /* no need to try any more names for bone path */
182                 }
183                 else if (STREQ(dtar->pchan_name, old_name)) {
184                   /* Change target bone name */
185                   BLI_strncpy(dtar->pchan_name, new_name, sizeof(dtar->pchan_name));
186                   break; /* no need to try any more names for bone subtarget */
187                 }
188               }
189             }
190           }
191         }
192       }
193       DRIVER_TARGETS_LOOPER_END;
194     }
195   }
196 }
197
198 /* Helper function for armature joining - link fixing */
199 static void joined_armature_fix_links(
200     Main *bmain, Object *tarArm, Object *srcArm, bPoseChannel *pchan, EditBone *curbone)
201 {
202   Object *ob;
203   bPose *pose;
204   bPoseChannel *pchant;
205
206   /* let's go through all objects in database */
207   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
208     /* do some object-type specific things */
209     if (ob->type == OB_ARMATURE) {
210       pose = ob->pose;
211       for (pchant = pose->chanbase.first; pchant; pchant = pchant->next) {
212         joined_armature_fix_links_constraints(
213             tarArm, srcArm, pchan, curbone, &pchant->constraints);
214       }
215     }
216
217     /* fix object-level constraints */
218     if (ob != srcArm) {
219       joined_armature_fix_links_constraints(tarArm, srcArm, pchan, curbone, &ob->constraints);
220     }
221
222     /* See if an object is parented to this armature */
223     if (ob->parent && (ob->parent == srcArm)) {
224       /* Is object parented to a bone of this src armature? */
225       if (ob->partype == PARBONE) {
226         /* bone name in object */
227         if (STREQ(ob->parsubstr, pchan->name)) {
228           BLI_strncpy(ob->parsubstr, curbone->name, sizeof(ob->parsubstr));
229         }
230       }
231
232       /* make tar armature be new parent */
233       ob->parent = tarArm;
234     }
235   }
236 }
237
238 /* join armature exec is exported for use in object->join objects operator... */
239 int join_armature_exec(bContext *C, wmOperator *op)
240 {
241   Main *bmain = CTX_data_main(C);
242   Scene *scene = CTX_data_scene(C);
243   Object *ob_active = CTX_data_active_object(C);
244   bArmature *arm = (ob_active) ? ob_active->data : NULL;
245   bPose *pose, *opose;
246   bPoseChannel *pchan, *pchann;
247   EditBone *curbone;
248   float mat[4][4], oimat[4][4];
249   bool ok = false;
250
251   /*  Ensure we're not in editmode and that the active object is an armature*/
252   if (!ob_active || ob_active->type != OB_ARMATURE) {
253     return OPERATOR_CANCELLED;
254   }
255   if (!arm || arm->edbo) {
256     return OPERATOR_CANCELLED;
257   }
258
259   CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects) {
260     if (ob_iter == ob_active) {
261       ok = true;
262       break;
263     }
264   }
265   CTX_DATA_END;
266
267   /* that way the active object is always selected */
268   if (ok == false) {
269     BKE_report(op->reports, RPT_WARNING, "Active object is not a selected armature");
270     return OPERATOR_CANCELLED;
271   }
272
273   /* Get editbones of active armature to add editbones to */
274   ED_armature_to_edit(arm);
275
276   /* get pose of active object and move it out of posemode */
277   pose = ob_active->pose;
278   ob_active->mode &= ~OB_MODE_POSE;
279
280   CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects) {
281     if ((ob_iter->type == OB_ARMATURE) && (ob_iter != ob_active)) {
282       tJoinArmature_AdtFixData afd = {NULL};
283       bArmature *curarm = ob_iter->data;
284
285       /* we assume that each armature datablock is only used in a single place */
286       BLI_assert(ob_active->data != ob_iter->data);
287
288       /* init callback data for fixing up AnimData links later */
289       afd.srcArm = ob_iter;
290       afd.tarArm = ob_active;
291       afd.names_map = BLI_ghash_str_new("join_armature_adt_fix");
292
293       /* Make a list of editbones in current armature */
294       ED_armature_to_edit(ob_iter->data);
295
296       /* Get Pose of current armature */
297       opose = ob_iter->pose;
298       ob_iter->mode &= ~OB_MODE_POSE;
299       //BASACT->flag &= ~OB_MODE_POSE;
300
301       /* Find the difference matrix */
302       invert_m4_m4(oimat, ob_active->obmat);
303       mul_m4_m4m4(mat, oimat, ob_iter->obmat);
304
305       /* Copy bones and posechannels from the object to the edit armature */
306       for (pchan = opose->chanbase.first; pchan; pchan = pchann) {
307         pchann = pchan->next;
308         curbone = ED_armature_ebone_find_name(curarm->edbo, pchan->name);
309
310         /* Get new name */
311         ED_armature_ebone_unique_name(arm->edbo, curbone->name, NULL);
312         BLI_ghash_insert(afd.names_map, BLI_strdup(pchan->name), curbone->name);
313
314         /* Transform the bone */
315         {
316           float premat[4][4];
317           float postmat[4][4];
318           float difmat[4][4];
319           float imat[4][4];
320           float temp[3][3];
321
322           /* Get the premat */
323           ED_armature_ebone_to_mat3(curbone, temp);
324
325           unit_m4(premat); /* mul_m4_m3m4 only sets 3x3 part */
326           mul_m4_m3m4(premat, temp, mat);
327
328           mul_m4_v3(mat, curbone->head);
329           mul_m4_v3(mat, curbone->tail);
330
331           /* Get the postmat */
332           ED_armature_ebone_to_mat3(curbone, temp);
333           copy_m4_m3(postmat, temp);
334
335           /* Find the roll */
336           invert_m4_m4(imat, premat);
337           mul_m4_m4m4(difmat, imat, postmat);
338
339           curbone->roll -= atan2f(difmat[2][0], difmat[2][2]);
340         }
341
342         /* Fix Constraints and Other Links to this Bone and Armature */
343         joined_armature_fix_links(bmain, ob_active, ob_iter, pchan, curbone);
344
345         /* Rename pchan */
346         BLI_strncpy(pchan->name, curbone->name, sizeof(pchan->name));
347
348         /* Jump Ship! */
349         BLI_remlink(curarm->edbo, curbone);
350         BLI_addtail(arm->edbo, curbone);
351
352         BLI_remlink(&opose->chanbase, pchan);
353         BLI_addtail(&pose->chanbase, pchan);
354         BKE_pose_channels_hash_free(opose);
355         BKE_pose_channels_hash_free(pose);
356       }
357
358       /* Fix all the drivers (and animation data) */
359       BKE_fcurves_main_cb(bmain, joined_armature_fix_animdata_cb, &afd);
360       BLI_ghash_free(afd.names_map, MEM_freeN, NULL);
361
362       /* Only copy over animdata now, after all the remapping has been done,
363        * so that we don't have to worry about ambiguities re which armature
364        * a bone came from!
365        */
366       if (ob_iter->adt) {
367         if (ob_active->adt == NULL) {
368           /* no animdata, so just use a copy of the whole thing */
369           ob_active->adt = BKE_animdata_copy(bmain, ob_iter->adt, 0);
370         }
371         else {
372           /* merge in data - we'll fix the drivers manually */
373           BKE_animdata_merge_copy(
374               bmain, &ob_active->id, &ob_iter->id, ADT_MERGECOPY_KEEP_DST, false);
375         }
376       }
377
378       if (curarm->adt) {
379         if (arm->adt == NULL) {
380           /* no animdata, so just use a copy of the whole thing */
381           arm->adt = BKE_animdata_copy(bmain, curarm->adt, 0);
382         }
383         else {
384           /* merge in data - we'll fix the drivers manually */
385           BKE_animdata_merge_copy(bmain, &arm->id, &curarm->id, ADT_MERGECOPY_KEEP_DST, false);
386         }
387       }
388
389       /* Free the old object data */
390       ED_object_base_free_and_unlink(bmain, scene, ob_iter);
391     }
392   }
393   CTX_DATA_END;
394
395   DEG_relations_tag_update(bmain); /* because we removed object(s) */
396
397   ED_armature_from_edit(bmain, arm);
398   ED_armature_edit_free(arm);
399
400   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
401   WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
402
403   return OPERATOR_FINISHED;
404 }
405
406 /* *********************************** Separate *********************************************** */
407
408 /* Helper function for armature separating - link fixing */
409 static void separated_armature_fix_links(Main *bmain, Object *origArm, Object *newArm)
410 {
411   Object *ob;
412   bPoseChannel *pchan;
413   bConstraint *con;
414   ListBase *opchans, *npchans;
415
416   /* get reference to list of bones in original and new armatures  */
417   opchans = &origArm->pose->chanbase;
418   npchans = &newArm->pose->chanbase;
419
420   /* let's go through all objects in database */
421   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
422     /* do some object-type specific things */
423     if (ob->type == OB_ARMATURE) {
424       for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
425         for (con = pchan->constraints.first; con; con = con->next) {
426           const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
427           ListBase targets = {NULL, NULL};
428           bConstraintTarget *ct;
429
430           /* constraint targets */
431           if (cti && cti->get_constraint_targets) {
432             cti->get_constraint_targets(con, &targets);
433
434             for (ct = targets.first; ct; ct = ct->next) {
435               /* any targets which point to original armature are redirected to the new one only if:
436                * - the target isn't origArm/newArm itself
437                * - the target is one that can be found in newArm/origArm
438                */
439               if (ct->subtarget[0] != 0) {
440                 if (ct->tar == origArm) {
441                   if (BLI_findstring(npchans, ct->subtarget, offsetof(bPoseChannel, name))) {
442                     ct->tar = newArm;
443                   }
444                 }
445                 else if (ct->tar == newArm) {
446                   if (BLI_findstring(opchans, ct->subtarget, offsetof(bPoseChannel, name))) {
447                     ct->tar = origArm;
448                   }
449                 }
450               }
451             }
452
453             if (cti->flush_constraint_targets) {
454               cti->flush_constraint_targets(con, &targets, 0);
455             }
456           }
457         }
458       }
459     }
460
461     /* fix object-level constraints */
462     if (ob != origArm) {
463       for (con = ob->constraints.first; con; con = con->next) {
464         const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
465         ListBase targets = {NULL, NULL};
466         bConstraintTarget *ct;
467
468         /* constraint targets */
469         if (cti && cti->get_constraint_targets) {
470           cti->get_constraint_targets(con, &targets);
471
472           for (ct = targets.first; ct; ct = ct->next) {
473             /* any targets which point to original armature are redirected to the new one only if:
474              * - the target isn't origArm/newArm itself
475              * - the target is one that can be found in newArm/origArm
476              */
477             if (ct->subtarget[0] != '\0') {
478               if (ct->tar == origArm) {
479                 if (BLI_findstring(npchans, ct->subtarget, offsetof(bPoseChannel, name))) {
480                   ct->tar = newArm;
481                 }
482               }
483               else if (ct->tar == newArm) {
484                 if (BLI_findstring(opchans, ct->subtarget, offsetof(bPoseChannel, name))) {
485                   ct->tar = origArm;
486                 }
487               }
488             }
489           }
490
491           if (cti->flush_constraint_targets) {
492             cti->flush_constraint_targets(con, &targets, 0);
493           }
494         }
495       }
496     }
497
498     /* See if an object is parented to this armature */
499     if (ob->parent && (ob->parent == origArm)) {
500       /* Is object parented to a bone of this src armature? */
501       if ((ob->partype == PARBONE) && (ob->parsubstr[0] != '\0')) {
502         if (BLI_findstring(npchans, ob->parsubstr, offsetof(bPoseChannel, name))) {
503           ob->parent = newArm;
504         }
505       }
506     }
507   }
508 }
509
510 /* Helper function for armature separating - remove certain bones from the given armature
511  * sel: remove selected bones from the armature, otherwise the unselected bones are removed
512  * (ob is not in editmode)
513  */
514 static void separate_armature_bones(Main *bmain, Object *ob, short sel)
515 {
516   bArmature *arm = (bArmature *)ob->data;
517   bPoseChannel *pchan, *pchann;
518   EditBone *curbone;
519
520   /* make local set of editbones to manipulate here */
521   ED_armature_to_edit(arm);
522
523   /* go through pose-channels, checking if a bone should be removed */
524   for (pchan = ob->pose->chanbase.first; pchan; pchan = pchann) {
525     pchann = pchan->next;
526     curbone = ED_armature_ebone_find_name(arm->edbo, pchan->name);
527
528     /* check if bone needs to be removed */
529     if ((sel && (curbone->flag & BONE_SELECTED)) || (!sel && !(curbone->flag & BONE_SELECTED))) {
530       EditBone *ebo;
531       bPoseChannel *pchn;
532
533       /* clear the bone->parent var of any bone that had this as its parent  */
534       for (ebo = arm->edbo->first; ebo; ebo = ebo->next) {
535         if (ebo->parent == curbone) {
536           ebo->parent = NULL;
537           /* this is needed to prevent random crashes with in ED_armature_from_edit */
538           ebo->temp.p = NULL;
539           ebo->flag &= ~BONE_CONNECTED;
540         }
541       }
542
543       /* clear the pchan->parent var of any pchan that had this as its parent */
544       for (pchn = ob->pose->chanbase.first; pchn; pchn = pchn->next) {
545         if (pchn->parent == pchan) {
546           pchn->parent = NULL;
547         }
548         if (pchn->bbone_next == pchan) {
549           pchn->bbone_next = NULL;
550         }
551         if (pchn->bbone_prev == pchan) {
552           pchn->bbone_prev = NULL;
553         }
554       }
555
556       /* free any of the extra-data this pchan might have */
557       BKE_pose_channel_free(pchan);
558       BKE_pose_channels_hash_free(ob->pose);
559
560       /* get rid of unneeded bone */
561       bone_free(arm, curbone);
562       BLI_freelinkN(&ob->pose->chanbase, pchan);
563     }
564   }
565
566   /* exit editmode (recalculates pchans too) */
567   ED_armature_from_edit(bmain, ob->data);
568   ED_armature_edit_free(ob->data);
569 }
570
571 /* separate selected bones into their armature */
572 static int separate_armature_exec(bContext *C, wmOperator *op)
573 {
574   Main *bmain = CTX_data_main(C);
575   Scene *scene = CTX_data_scene(C);
576   ViewLayer *view_layer = CTX_data_view_layer(C);
577   bool ok = false;
578
579   /* set wait cursor in case this takes a while */
580   WM_cursor_wait(1);
581
582   uint bases_len = 0;
583   Base **bases = BKE_view_layer_array_from_bases_in_edit_mode_unique_data(
584       view_layer, CTX_wm_view3d(C), &bases_len);
585
586   CTX_DATA_BEGIN (C, Base *, base, visible_bases) {
587     ED_object_base_select(base, BA_DESELECT);
588   }
589   CTX_DATA_END;
590
591   for (uint base_index = 0; base_index < bases_len; base_index++) {
592     Base *base_iter = bases[base_index];
593     Object *obedit = base_iter->object;
594
595     Object *oldob, *newob;
596     Base *oldbase, *newbase;
597
598     /* We are going to do this as follows (unlike every other instance of separate):
599      * 1. Exit editmode +posemode for active armature/base. Take note of what this is.
600      * 2. Duplicate base - BASACT is the new one now
601      * 3. For each of the two armatures,
602      *    enter editmode -> remove appropriate bones -> exit editmode + recalc.
603      * 4. Fix constraint links
604      * 5. Make original armature active and enter editmode
605      */
606
607     /* 1) only edit-base selected */
608     ED_object_base_select(base_iter, BA_SELECT);
609
610     /* 1) store starting settings and exit editmode */
611     oldob = obedit;
612     oldbase = base_iter;
613     oldob->mode &= ~OB_MODE_POSE;
614     //oldbase->flag &= ~OB_POSEMODE;
615
616     ED_armature_from_edit(bmain, obedit->data);
617     ED_armature_edit_free(obedit->data);
618
619     /* 2) duplicate base */
620
621     /* only duplicate linked armature */
622     newbase = ED_object_add_duplicate(bmain, scene, view_layer, oldbase, USER_DUP_ARM);
623
624     DEG_relations_tag_update(bmain);
625
626     newob = newbase->object;
627     newbase->flag &= ~BASE_SELECTED;
628
629     /* 3) remove bones that shouldn't still be around on both armatures */
630     separate_armature_bones(bmain, oldob, 1);
631     separate_armature_bones(bmain, newob, 0);
632
633     /* 4) fix links before depsgraph flushes */  // err... or after?
634     separated_armature_fix_links(bmain, oldob, newob);
635
636     DEG_id_tag_update(&oldob->id, ID_RECALC_GEOMETRY); /* this is the original one */
637     DEG_id_tag_update(&newob->id, ID_RECALC_GEOMETRY); /* this is the separated one */
638
639     /* 5) restore original conditions */
640     obedit = oldob;
641
642     ED_armature_to_edit(obedit->data);
643
644     /* parents tips remain selected when connected children are removed. */
645     ED_armature_edit_deselect_all(obedit);
646
647     ok = true;
648
649     /* note, notifier might evolve */
650     WM_event_add_notifier(C, NC_OBJECT | ND_POSE, obedit);
651   }
652   MEM_freeN(bases);
653
654   /* recalc/redraw + cleanup */
655   WM_cursor_wait(0);
656
657   if (ok) {
658     BKE_report(op->reports, RPT_INFO, "Separated bones");
659   }
660
661   return OPERATOR_FINISHED;
662 }
663
664 void ARMATURE_OT_separate(wmOperatorType *ot)
665 {
666   /* identifiers */
667   ot->name = "Separate Bones";
668   ot->idname = "ARMATURE_OT_separate";
669   ot->description = "Isolate selected bones into a separate armature";
670
671   /* callbacks */
672   ot->invoke = WM_operator_confirm;
673   ot->exec = separate_armature_exec;
674   ot->poll = ED_operator_editarmature;
675
676   /* flags */
677   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
678 }
679
680 /* ********************************* Parenting ************************************************* */
681
682 /* armature parenting options */
683 #define ARM_PAR_CONNECT 1
684 #define ARM_PAR_OFFSET 2
685
686 /* check for null, before calling! */
687 static void bone_connect_to_existing_parent(EditBone *bone)
688 {
689   bone->flag |= BONE_CONNECTED;
690   copy_v3_v3(bone->head, bone->parent->tail);
691   bone->rad_head = bone->parent->rad_tail;
692 }
693
694 static void bone_connect_to_new_parent(ListBase *edbo,
695                                        EditBone *selbone,
696                                        EditBone *actbone,
697                                        short mode)
698 {
699   EditBone *ebone;
700   float offset[3];
701
702   if ((selbone->parent) && (selbone->flag & BONE_CONNECTED)) {
703     selbone->parent->flag &= ~(BONE_TIPSEL);
704   }
705
706   /* make actbone the parent of selbone */
707   selbone->parent = actbone;
708
709   /* in actbone tree we cannot have a loop */
710   for (ebone = actbone->parent; ebone; ebone = ebone->parent) {
711     if (ebone->parent == selbone) {
712       ebone->parent = NULL;
713       ebone->flag &= ~BONE_CONNECTED;
714     }
715   }
716
717   if (mode == ARM_PAR_CONNECT) {
718     /* Connected: Child bones will be moved to the parent tip */
719     selbone->flag |= BONE_CONNECTED;
720     sub_v3_v3v3(offset, actbone->tail, selbone->head);
721
722     copy_v3_v3(selbone->head, actbone->tail);
723     selbone->rad_head = actbone->rad_tail;
724
725     add_v3_v3(selbone->tail, offset);
726
727     /* offset for all its children */
728     for (ebone = edbo->first; ebone; ebone = ebone->next) {
729       EditBone *par;
730
731       for (par = ebone->parent; par; par = par->parent) {
732         if (par == selbone) {
733           add_v3_v3(ebone->head, offset);
734           add_v3_v3(ebone->tail, offset);
735           break;
736         }
737       }
738     }
739   }
740   else {
741     /* Offset: Child bones will retain their distance from the parent tip */
742     selbone->flag &= ~BONE_CONNECTED;
743   }
744 }
745
746 static const EnumPropertyItem prop_editarm_make_parent_types[] = {
747     {ARM_PAR_CONNECT, "CONNECTED", 0, "Connected", ""},
748     {ARM_PAR_OFFSET, "OFFSET", 0, "Keep Offset", ""},
749     {0, NULL, 0, NULL, NULL},
750 };
751
752 static int armature_parent_set_exec(bContext *C, wmOperator *op)
753 {
754   Object *ob = CTX_data_edit_object(C);
755   bArmature *arm = (bArmature *)ob->data;
756   EditBone *actbone = CTX_data_active_bone(C);
757   EditBone *actmirb = NULL;
758   short val = RNA_enum_get(op->ptr, "type");
759
760   /* there must be an active bone */
761   if (actbone == NULL) {
762     BKE_report(op->reports, RPT_ERROR, "Operation requires an active bone");
763     return OPERATOR_CANCELLED;
764   }
765   else if (arm->flag & ARM_MIRROR_EDIT) {
766     /* For X-Axis Mirror Editing option, we may need a mirror copy of actbone
767      * - if there's a mirrored copy of selbone, try to find a mirrored copy of actbone
768      *   (i.e.  selbone="child.L" and actbone="parent.L", find "child.R" and "parent.R").
769      * This is useful for arm-chains, for example parenting lower arm to upper arm
770      * - if there's no mirrored copy of actbone (i.e. actbone = "parent.C" or "parent")
771      *   then just use actbone. Useful when doing upper arm to spine.
772      */
773     actmirb = ED_armature_ebone_get_mirrored(arm->edbo, actbone);
774     if (actmirb == NULL) {
775       actmirb = actbone;
776     }
777   }
778
779   /* if there is only 1 selected bone, we assume that that is the active bone,
780    * since a user will need to have clicked on a bone (thus selecting it) to make it active
781    */
782   if (CTX_DATA_COUNT(C, selected_editable_bones) <= 1) {
783     /* When only the active bone is selected, and it has a parent,
784      * connect it to the parent, as that is the only possible outcome.
785      */
786     if (actbone->parent) {
787       bone_connect_to_existing_parent(actbone);
788
789       if ((arm->flag & ARM_MIRROR_EDIT) && (actmirb->parent)) {
790         bone_connect_to_existing_parent(actmirb);
791       }
792     }
793   }
794   else {
795     /* Parent 'selected' bones to the active one
796      * - the context iterator contains both selected bones and their mirrored copies,
797      *   so we assume that unselected bones are mirrored copies of some selected bone
798      * - since the active one (and/or its mirror) will also be selected, we also need
799      *   to check that we are not trying to operate on them, since such an operation
800      *   would cause errors
801      */
802
803     /* parent selected bones to the active one */
804     CTX_DATA_BEGIN (C, EditBone *, ebone, selected_editable_bones) {
805       if (ELEM(ebone, actbone, actmirb) == 0) {
806         if (ebone->flag & BONE_SELECTED) {
807           bone_connect_to_new_parent(arm->edbo, ebone, actbone, val);
808         }
809         else {
810           bone_connect_to_new_parent(arm->edbo, ebone, actmirb, val);
811         }
812       }
813     }
814     CTX_DATA_END;
815   }
816
817   /* note, notifier might evolve */
818   WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
819
820   return OPERATOR_FINISHED;
821 }
822
823 static int armature_parent_set_invoke(bContext *C,
824                                       wmOperator *UNUSED(op),
825                                       const wmEvent *UNUSED(event))
826 {
827   EditBone *actbone = CTX_data_active_bone(C);
828   uiPopupMenu *pup = UI_popup_menu_begin(
829       C, CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Make Parent"), ICON_NONE);
830   uiLayout *layout = UI_popup_menu_layout(pup);
831   int allchildbones = 0;
832
833   CTX_DATA_BEGIN (C, EditBone *, ebone, selected_editable_bones) {
834     if (ebone != actbone) {
835       if (ebone->parent != actbone) {
836         allchildbones = 1;
837       }
838     }
839   }
840   CTX_DATA_END;
841
842   uiItemEnumO(layout, "ARMATURE_OT_parent_set", NULL, 0, "type", ARM_PAR_CONNECT);
843
844   /* ob becomes parent, make the associated menus */
845   if (allchildbones) {
846     uiItemEnumO(layout, "ARMATURE_OT_parent_set", NULL, 0, "type", ARM_PAR_OFFSET);
847   }
848
849   UI_popup_menu_end(C, pup);
850
851   return OPERATOR_INTERFACE;
852 }
853
854 void ARMATURE_OT_parent_set(wmOperatorType *ot)
855 {
856   /* identifiers */
857   ot->name = "Make Parent";
858   ot->idname = "ARMATURE_OT_parent_set";
859   ot->description = "Set the active bone as the parent of the selected bones";
860
861   /* api callbacks */
862   ot->invoke = armature_parent_set_invoke;
863   ot->exec = armature_parent_set_exec;
864   ot->poll = ED_operator_editarmature;
865
866   /* flags */
867   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
868
869   RNA_def_enum(
870       ot->srna, "type", prop_editarm_make_parent_types, 0, "ParentType", "Type of parenting");
871 }
872
873 static const EnumPropertyItem prop_editarm_clear_parent_types[] = {
874     {1, "CLEAR", 0, "Clear Parent", ""},
875     {2, "DISCONNECT", 0, "Disconnect Bone", ""},
876     {0, NULL, 0, NULL, NULL},
877 };
878
879 static void editbone_clear_parent(EditBone *ebone, int mode)
880 {
881   if (ebone->parent) {
882     /* for nice selection */
883     ebone->parent->flag &= ~(BONE_TIPSEL);
884   }
885
886   if (mode == 1) {
887     ebone->parent = NULL;
888   }
889   ebone->flag &= ~BONE_CONNECTED;
890 }
891
892 static int armature_parent_clear_exec(bContext *C, wmOperator *op)
893 {
894   ViewLayer *view_layer = CTX_data_view_layer(C);
895   const int val = RNA_enum_get(op->ptr, "type");
896
897   CTX_DATA_BEGIN (C, EditBone *, ebone, selected_editable_bones) {
898     editbone_clear_parent(ebone, val);
899   }
900   CTX_DATA_END;
901
902   uint objects_len = 0;
903   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
904       view_layer, CTX_wm_view3d(C), &objects_len);
905   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
906     Object *ob = objects[ob_index];
907     bArmature *arm = ob->data;
908     bool changed = false;
909
910     for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
911       if (EBONE_EDITABLE(ebone)) {
912         changed = true;
913         break;
914       }
915     }
916
917     if (!changed) {
918       continue;
919     }
920
921     ED_armature_edit_sync_selection(arm->edbo);
922
923     /* Note, notifier might evolve. */
924     WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
925   }
926   MEM_freeN(objects);
927
928   return OPERATOR_FINISHED;
929 }
930
931 void ARMATURE_OT_parent_clear(wmOperatorType *ot)
932 {
933   /* identifiers */
934   ot->name = "Clear Parent";
935   ot->idname = "ARMATURE_OT_parent_clear";
936   ot->description =
937       "Remove the parent-child relationship between selected bones and their parents";
938
939   /* api callbacks */
940   ot->invoke = WM_menu_invoke;
941   ot->exec = armature_parent_clear_exec;
942   ot->poll = ED_operator_editarmature;
943
944   /* flags */
945   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
946
947   ot->prop = RNA_def_enum(ot->srna,
948                           "type",
949                           prop_editarm_clear_parent_types,
950                           0,
951                           "ClearType",
952                           "What way to clear parenting");
953 }