Merge branch 'blender2.7'
[blender.git] / source / blender / editors / armature / pose_edit.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): Ton Roosendaal, Blender Foundation '05, full recode.
22  *                 Joshua Leung
23  *                 Reevan McKay (original NaN code)
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  * Pose Mode API's and Operators for Pose Mode armatures
28  */
29
30 /** \file blender/editors/armature/pose_edit.c
31  *  \ingroup edarmature
32  */
33
34 #include "MEM_guardedalloc.h"
35
36 #include "BLI_math.h"
37 #include "BLI_blenlib.h"
38
39 #include "DNA_anim_types.h"
40 #include "DNA_armature_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_object_types.h"
43
44 #include "BKE_action.h"
45 #include "BKE_anim.h"
46 #include "BKE_armature.h"
47 #include "BKE_context.h"
48 #include "BKE_deform.h"
49 #include "BKE_global.h"
50 #include "BKE_main.h"
51 #include "BKE_object.h"
52 #include "BKE_report.h"
53 #include "BKE_layer.h"
54 #include "BKE_scene.h"
55
56 #include "DEG_depsgraph.h"
57 #include "DEG_depsgraph_query.h"
58
59 #include "RNA_access.h"
60 #include "RNA_define.h"
61 #include "RNA_enum_types.h"
62
63 #include "WM_api.h"
64 #include "WM_types.h"
65
66 #include "ED_armature.h"
67 #include "ED_keyframing.h"
68 #include "ED_screen.h"
69 #include "ED_object.h"
70 #include "ED_view3d.h"
71
72 #include "UI_interface.h"
73
74 #include "armature_intern.h"
75
76
77 #define DEBUG_TIME
78
79 #include "PIL_time.h"
80 #ifdef DEBUG_TIME
81 #  include "PIL_time_utildefines.h"
82 #endif
83
84
85 /* matches logic with ED_operator_posemode_context() */
86 Object *ED_pose_object_from_context(bContext *C)
87 {
88         ScrArea *sa = CTX_wm_area(C);
89         Object *ob;
90
91         /* since this call may also be used from the buttons window, we need to check for where to get the object */
92         if (sa && sa->spacetype == SPACE_BUTS) {
93                 ob = ED_object_context(C);
94         }
95         else {
96                 ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
97         }
98
99         return ob;
100 }
101
102 /* This function is used to process the necessary updates for */
103 bool ED_object_posemode_enter_ex(struct Main *bmain, Object *ob)
104 {
105         BLI_assert(!ID_IS_LINKED(ob));
106         bool ok = false;
107
108         switch (ob->type) {
109                 case OB_ARMATURE:
110                         ob->restore_mode = ob->mode;
111                         ob->mode |= OB_MODE_POSE;
112                         /* Inform all CoW versions that we changed the mode. */
113                         DEG_id_tag_update_ex(bmain, &ob->id, ID_RECALC_COPY_ON_WRITE);
114                         ok = true;
115
116                         break;
117                 default:
118                         break;
119         }
120
121         return ok;
122 }
123 bool ED_object_posemode_enter(bContext *C, Object *ob)
124 {
125         ReportList *reports = CTX_wm_reports(C);
126         if (ID_IS_LINKED(ob)) {
127                 BKE_report(reports, RPT_WARNING, "Cannot pose libdata");
128                 return false;
129         }
130         struct Main *bmain = CTX_data_main(C);
131         bool ok = ED_object_posemode_enter_ex(bmain, ob);
132         if (ok) {
133                 WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_POSE, NULL);
134         }
135         return ok;
136 }
137
138 bool ED_object_posemode_exit_ex(struct Main *bmain, Object *ob)
139 {
140         bool ok = false;
141         if (ob) {
142                 ob->restore_mode = ob->mode;
143                 ob->mode &= ~OB_MODE_POSE;
144
145                 /* Inform all CoW versions that we changed the mode. */
146                 DEG_id_tag_update_ex(bmain, &ob->id, ID_RECALC_COPY_ON_WRITE);
147                 ok = true;
148         }
149         return ok;
150 }
151 bool ED_object_posemode_exit(bContext *C, Object *ob)
152 {
153         struct Main *bmain = CTX_data_main(C);
154         bool ok = ED_object_posemode_exit_ex(bmain, ob);
155         if (ok) {
156                 WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_OBJECT, NULL);
157         }
158         return ok;
159 }
160
161 /* if a selected or active bone is protected, throw error (oonly if warn == 1) and return 1 */
162 /* only_selected == 1: the active bone is allowed to be protected */
163 #if 0 /* UNUSED 2.5 */
164 static bool pose_has_protected_selected(Object *ob, short warn)
165 {
166         /* check protection */
167         if (ob->proxy) {
168                 bPoseChannel *pchan;
169                 bArmature *arm = ob->data;
170
171                 for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
172                         if (pchan->bone && (pchan->bone->layer & arm->layer)) {
173                                 if (pchan->bone->layer & arm->layer_protected) {
174                                         if (pchan->bone->flag & BONE_SELECTED)
175                                                 break;
176                                 }
177                         }
178                 }
179                 if (pchan) {
180                         if (warn) error("Cannot change Proxy protected bones");
181                         return 1;
182                 }
183         }
184         return 0;
185 }
186 #endif
187
188 /* ********************************************** */
189 /* Motion Paths */
190
191 /* For the object with pose/action: update paths for those that have got them
192  * This should selectively update paths that exist...
193  *
194  * To be called from various tools that do incremental updates
195  */
196 void ED_pose_recalculate_paths(bContext *C, Scene *scene, Object *ob, bool current_frame_only)
197 {
198         /* Transform doesn't always have context available to do update. */
199         if (C == NULL) {
200                 return;
201         }
202
203         Main *bmain = CTX_data_main(C);
204         Depsgraph *depsgraph = CTX_data_depsgraph(C);
205         ListBase targets = {NULL, NULL};
206         bool free_depsgraph = false;
207
208         /* Override depsgraph with a filtered, simpler copy */
209         if (!current_frame_only && G.debug_value != -1) {
210                 DEG_FilterQuery query = {{0}};
211
212                 DEG_FilterTarget *dft_ob = MEM_callocN(sizeof(DEG_FilterTarget), "DEG_FilterTarget");
213                 dft_ob->id = &ob->id;
214                 BLI_addtail(&query.targets, dft_ob);
215
216 #ifdef DEBUG_TIME
217                 TIMEIT_START(filter_pose_depsgraph);
218 #endif
219
220                 depsgraph = DEG_graph_filter(depsgraph, bmain, &query);
221
222 #ifdef DEBUG_TIME
223                 TIMEIT_END(filter_pose_depsgraph);
224 #endif
225
226                 free_depsgraph = true;
227                 MEM_freeN(dft_ob);
228
229 #ifdef DEBUG_TIME
230                 TIMEIT_START(filter_pose_update);
231 #endif
232
233                 BKE_scene_graph_update_tagged(depsgraph, bmain);
234
235 #ifdef DEBUG_TIME
236                 TIMEIT_END(filter_pose_update);
237 #endif
238         }
239
240         /* set flag to force recalc, then grab the relevant bones to target */
241         ob->pose->avs.recalc |= ANIMVIZ_RECALC_PATHS;
242         animviz_get_object_motionpaths(ob, &targets);
243
244         /* recalculate paths, then free */
245 #ifdef DEBUG_TIME
246         TIMEIT_START(pose_path_calc);
247 #endif
248
249         animviz_calc_motionpaths(depsgraph, bmain, scene, &targets, !free_depsgraph, current_frame_only);
250
251 #ifdef DEBUG_TIME
252         TIMEIT_END(pose_path_calc);
253 #endif
254
255         BLI_freelistN(&targets);
256
257         if (!current_frame_only) {
258                 /* Tag armature object for copy on write - so paths will draw/redraw.
259                  * For currently frame only we update evaluated object directly. */
260                 DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
261         }
262
263         /* Free temporary depsgraph instance */
264         if (free_depsgraph) {
265                 DEG_graph_free(depsgraph);
266         }
267 }
268
269
270 /* show popup to determine settings */
271 static int pose_calculate_paths_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
272 {
273         Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
274
275         if (ELEM(NULL, ob, ob->pose))
276                 return OPERATOR_CANCELLED;
277
278         /* set default settings from existing/stored settings */
279         {
280                 bAnimVizSettings *avs = &ob->pose->avs;
281                 PointerRNA avs_ptr;
282
283                 RNA_int_set(op->ptr, "start_frame", avs->path_sf);
284                 RNA_int_set(op->ptr, "end_frame", avs->path_ef);
285
286                 RNA_pointer_create(NULL, &RNA_AnimVizMotionPaths, avs, &avs_ptr);
287                 RNA_enum_set(op->ptr, "bake_location", RNA_enum_get(&avs_ptr, "bake_location"));
288         }
289
290         /* show popup dialog to allow editing of range... */
291         // FIXME: hardcoded dimensions here are just arbitrary
292         return WM_operator_props_dialog_popup(C, op, 200, 200);
293 }
294
295 /* For the object with pose/action: create path curves for selected bones
296  * This recalculates the WHOLE path within the pchan->pathsf and pchan->pathef range
297  */
298 static int pose_calculate_paths_exec(bContext *C, wmOperator *op)
299 {
300         Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
301         Scene *scene = CTX_data_scene(C);
302
303         if (ELEM(NULL, ob, ob->pose))
304                 return OPERATOR_CANCELLED;
305
306         /* grab baking settings from operator settings */
307         {
308                 bAnimVizSettings *avs = &ob->pose->avs;
309                 PointerRNA avs_ptr;
310
311                 avs->path_sf = RNA_int_get(op->ptr, "start_frame");
312                 avs->path_ef = RNA_int_get(op->ptr, "end_frame");
313
314                 RNA_pointer_create(NULL, &RNA_AnimVizMotionPaths, avs, &avs_ptr);
315                 RNA_enum_set(&avs_ptr, "bake_location", RNA_enum_get(op->ptr, "bake_location"));
316         }
317
318         /* set up path data for bones being calculated */
319         CTX_DATA_BEGIN (C, bPoseChannel *, pchan, selected_pose_bones_from_active_object)
320         {
321                 /* verify makes sure that the selected bone has a bone with the appropriate settings */
322                 animviz_verify_motionpaths(op->reports, scene, ob, pchan);
323         }
324         CTX_DATA_END;
325
326 #ifdef DEBUG_TIME
327         TIMEIT_START(recalc_pose_paths);
328 #endif
329
330         /* calculate the bones that now have motionpaths... */
331         /* TODO: only make for the selected bones? */
332         ED_pose_recalculate_paths(C, scene, ob, false);
333
334 #ifdef DEBUG_TIME
335         TIMEIT_END(recalc_pose_paths);
336 #endif
337
338         /* notifiers for updates */
339         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
340
341         return OPERATOR_FINISHED;
342 }
343
344 void POSE_OT_paths_calculate(wmOperatorType *ot)
345 {
346         /* identifiers */
347         ot->name = "Calculate Bone Paths";
348         ot->idname = "POSE_OT_paths_calculate";
349         ot->description = "Calculate paths for the selected bones";
350
351         /* api callbacks */
352         ot->invoke = pose_calculate_paths_invoke;
353         ot->exec = pose_calculate_paths_exec;
354         ot->poll = ED_operator_posemode_exclusive;
355
356         /* flags */
357         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
358
359         /* properties */
360         RNA_def_int(ot->srna, "start_frame", 1, MINAFRAME, MAXFRAME, "Start",
361                     "First frame to calculate bone paths on", MINFRAME, MAXFRAME / 2.0);
362         RNA_def_int(ot->srna, "end_frame", 250, MINAFRAME, MAXFRAME, "End",
363                     "Last frame to calculate bone paths on", MINFRAME, MAXFRAME / 2.0);
364
365         RNA_def_enum(ot->srna, "bake_location", rna_enum_motionpath_bake_location_items,
366                      MOTIONPATH_BAKE_HEADS,
367                      "Bake Location",
368                      "Which point on the bones is used when calculating paths");
369 }
370
371 /* --------- */
372
373 static bool pose_update_paths_poll(bContext *C)
374 {
375         if (ED_operator_posemode_exclusive(C)) {
376                 Object *ob = CTX_data_active_object(C);
377                 return (ob->pose->avs.path_bakeflag & MOTIONPATH_BAKE_HAS_PATHS) != 0;
378         }
379
380         return false;
381 }
382
383 static int pose_update_paths_exec(bContext *C, wmOperator *UNUSED(op))
384 {
385         Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
386         Scene *scene = CTX_data_scene(C);
387
388         if (ELEM(NULL, ob, scene))
389                 return OPERATOR_CANCELLED;
390
391         /* calculate the bones that now have motionpaths... */
392         /* TODO: only make for the selected bones? */
393         ED_pose_recalculate_paths(C, scene, ob, false);
394
395         /* notifiers for updates */
396         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
397
398         return OPERATOR_FINISHED;
399 }
400
401 void POSE_OT_paths_update(wmOperatorType *ot)
402 {
403         /* identifiers */
404         ot->name = "Update Bone Paths";
405         ot->idname = "POSE_OT_paths_update";
406         ot->description = "Recalculate paths for bones that already have them";
407
408         /* api callbakcs */
409         ot->exec = pose_update_paths_exec;
410         ot->poll = pose_update_paths_poll;
411
412         /* flags */
413         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
414 }
415
416 /* --------- */
417
418 /* for the object with pose/action: clear path curves for selected bones only */
419 static void ED_pose_clear_paths(Object *ob, bool only_selected)
420 {
421         bPoseChannel *pchan;
422         bool skipped = false;
423
424         if (ELEM(NULL, ob, ob->pose))
425                 return;
426
427         /* free the motionpath blocks for all bones - This is easier for users to quickly clear all */
428         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
429                 if (pchan->mpath) {
430                         if ((only_selected == false) || ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED))) {
431                                 animviz_free_motionpath(pchan->mpath);
432                                 pchan->mpath = NULL;
433                         }
434                         else {
435                                 skipped = true;
436                         }
437                 }
438         }
439
440         /* if nothing was skipped, there should be no paths left! */
441         if (skipped == false)
442                 ob->pose->avs.path_bakeflag &= ~MOTIONPATH_BAKE_HAS_PATHS;
443
444         /* tag armature object for copy on write - so removed paths don't still show */
445         DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
446 }
447
448 /* operator callback - wrapper for the backend function  */
449 static int pose_clear_paths_exec(bContext *C, wmOperator *op)
450 {
451         Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
452         bool only_selected = RNA_boolean_get(op->ptr, "only_selected");
453
454         /* only continue if there's an object */
455         if (ELEM(NULL, ob, ob->pose))
456                 return OPERATOR_CANCELLED;
457
458         /* use the backend function for this */
459         ED_pose_clear_paths(ob, only_selected);
460
461         /* notifiers for updates */
462         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
463
464         return OPERATOR_FINISHED;
465 }
466
467 /* operator callback/wrapper */
468 static int pose_clear_paths_invoke(bContext *C, wmOperator *op, const wmEvent *evt)
469 {
470         if ((evt->shift) && !RNA_struct_property_is_set(op->ptr, "only_selected")) {
471                 RNA_boolean_set(op->ptr, "only_selected", true);
472         }
473         return pose_clear_paths_exec(C, op);
474 }
475
476 void POSE_OT_paths_clear(wmOperatorType *ot)
477 {
478         /* identifiers */
479         ot->name = "Clear Bone Paths";
480         ot->idname = "POSE_OT_paths_clear";
481         ot->description = "Clear path caches for all bones, hold Shift key for selected bones only";
482
483         /* api callbacks */
484         ot->invoke = pose_clear_paths_invoke;
485         ot->exec = pose_clear_paths_exec;
486         ot->poll = ED_operator_posemode_exclusive;
487
488         /* flags */
489         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
490
491         /* properties */
492         ot->prop = RNA_def_boolean(ot->srna, "only_selected", false, "Only Selected",
493                                    "Only clear paths from selected bones");
494         RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
495 }
496
497 /* --------- */
498
499 static int pose_update_paths_range_exec(bContext *C, wmOperator *UNUSED(op))
500 {
501         Scene *scene = CTX_data_scene(C);
502         Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
503
504         if (ELEM(NULL, scene, ob, ob->pose)) {
505                 return OPERATOR_CANCELLED;
506         }
507
508         /* use Preview Range or Full Frame Range - whichever is in use */
509         ob->pose->avs.path_sf = PSFRA;
510         ob->pose->avs.path_ef = PEFRA;
511
512         /* tag for updates */
513         DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
514         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
515
516         return OPERATOR_FINISHED;
517 }
518
519 void POSE_OT_paths_range_update(wmOperatorType *ot)
520 {
521         /* identifiers */
522         ot->name = "Update Range from Scene";
523         ot->idname = "POSE_OT_paths_range_update";
524         ot->description = "Update frame range for motion paths from the Scene's current frame range";
525
526         /* callbacks */
527         ot->exec = pose_update_paths_range_exec;
528         ot->poll = ED_operator_posemode_exclusive;
529
530         /* flags */
531         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
532 }
533
534 /* ********************************************** */
535
536 static int pose_flip_names_exec(bContext *C, wmOperator *op)
537 {
538         Main *bmain = CTX_data_main(C);
539         ViewLayer *view_layer = CTX_data_view_layer(C);
540         View3D *v3d = CTX_wm_view3d(C);
541         const bool do_strip_numbers = RNA_boolean_get(op->ptr, "do_strip_numbers");
542
543         FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob)
544         {
545                 bArmature *arm = ob->data;
546                 ListBase bones_names = {NULL};
547
548                 FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (ob, pchan)
549                 {
550                         BLI_addtail(&bones_names, BLI_genericNodeN(pchan->name));
551                 }
552                 FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
553
554                 ED_armature_bones_flip_names(bmain, arm, &bones_names, do_strip_numbers);
555
556                 BLI_freelistN(&bones_names);
557
558                 /* since we renamed stuff... */
559                 DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
560
561                 /* note, notifier might evolve */
562                 WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
563         }
564         FOREACH_OBJECT_IN_MODE_END;
565
566         return OPERATOR_FINISHED;
567 }
568
569 void POSE_OT_flip_names(wmOperatorType *ot)
570 {
571         /* identifiers */
572         ot->name = "Flip Names";
573         ot->idname = "POSE_OT_flip_names";
574         ot->description = "Flips (and corrects) the axis suffixes of the names of selected bones";
575
576         /* api callbacks */
577         ot->exec = pose_flip_names_exec;
578         ot->poll = ED_operator_posemode_local;
579
580         /* flags */
581         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
582
583         RNA_def_boolean(ot->srna, "do_strip_numbers", false, "Strip Numbers",
584                         "Try to remove right-most dot-number from flipped names "
585                         "(WARNING: may result in incoherent naming in some cases)");
586 }
587
588 /* ------------------ */
589
590 static int pose_autoside_names_exec(bContext *C, wmOperator *op)
591 {
592         Main *bmain = CTX_data_main(C);
593         char newname[MAXBONENAME];
594         short axis = RNA_enum_get(op->ptr, "axis");
595         Object *ob_prev = NULL;
596
597         /* loop through selected bones, auto-naming them */
598         CTX_DATA_BEGIN_WITH_ID(C, bPoseChannel *, pchan, selected_pose_bones, Object *, ob)
599         {
600                 bArmature *arm = ob->data;
601                 BLI_strncpy(newname, pchan->name, sizeof(newname));
602                 if (bone_autoside_name(newname, 1, axis, pchan->bone->head[axis], pchan->bone->tail[axis])) {
603                         ED_armature_bone_rename(bmain, arm, pchan->name, newname);
604                 }
605
606                 if (ob_prev != ob) {
607                         /* since we renamed stuff... */
608                         DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
609
610                         /* note, notifier might evolve */
611                         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
612                         ob_prev = ob;
613                 }
614         }
615         CTX_DATA_END;
616
617         return OPERATOR_FINISHED;
618 }
619
620 void POSE_OT_autoside_names(wmOperatorType *ot)
621 {
622         static const EnumPropertyItem axis_items[] = {
623                 {0, "XAXIS", 0, "X-Axis", "Left/Right"},
624                 {1, "YAXIS", 0, "Y-Axis", "Front/Back"},
625                 {2, "ZAXIS", 0, "Z-Axis", "Top/Bottom"},
626                 {0, NULL, 0, NULL, NULL}
627         };
628
629         /* identifiers */
630         ot->name = "AutoName by Axis";
631         ot->idname = "POSE_OT_autoside_names";
632         ot->description = "Automatically renames the selected bones according to which side of the target axis they fall on";
633
634         /* api callbacks */
635         ot->invoke = WM_menu_invoke;
636         ot->exec = pose_autoside_names_exec;
637         ot->poll = ED_operator_posemode;
638
639         /* flags */
640         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
641
642         /* settings */
643         ot->prop = RNA_def_enum(ot->srna, "axis", axis_items, 0, "Axis", "Axis tag names with");
644 }
645
646 /* ********************************************** */
647
648 static int pose_bone_rotmode_exec(bContext *C, wmOperator *op)
649 {
650         const int mode = RNA_enum_get(op->ptr, "type");
651         Object *prev_ob = NULL;
652
653         /* set rotation mode of selected bones  */
654         CTX_DATA_BEGIN_WITH_ID (C, bPoseChannel *, pchan, selected_pose_bones, Object *, ob)
655         {
656                 pchan->rotmode = mode;
657
658                 if (prev_ob != ob) {
659                         /* Notifiers and updates. */
660                         DEG_id_tag_update((ID *)ob, ID_RECALC_GEOMETRY);
661                         WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, ob);
662                         WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
663                         prev_ob = ob;
664                 }
665         }
666         CTX_DATA_END;
667
668         return OPERATOR_FINISHED;
669 }
670
671 void POSE_OT_rotation_mode_set(wmOperatorType *ot)
672 {
673         /* identifiers */
674         ot->name = "Set Rotation Mode";
675         ot->idname = "POSE_OT_rotation_mode_set";
676         ot->description = "Set the rotation representation used by selected bones";
677
678         /* callbacks */
679         ot->invoke = WM_menu_invoke;
680         ot->exec = pose_bone_rotmode_exec;
681         ot->poll = ED_operator_posemode;
682
683         /* flags */
684         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
685
686         /* properties */
687         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_posebone_rotmode_items, 0, "Rotation Mode", "");
688 }
689
690 /* ********************************************** */
691
692 static bool armature_layers_poll(bContext *C)
693 {
694         /* Armature layers operators can be used in posemode OR editmode for armatures */
695         return ED_operator_posemode(C) || ED_operator_editarmature(C);
696 }
697
698 static bArmature *armature_layers_get_data(Object **ob)
699 {
700         bArmature *arm = NULL;
701
702         /* Sanity checking and handling of posemode. */
703         if (*ob) {
704                 Object *tob = BKE_object_pose_armature_get(*ob);
705                 if (tob) {
706                         *ob = tob;
707                         arm = (*ob)->data;
708                 }
709                 else if ((*ob)->type == OB_ARMATURE) {
710                         arm = (*ob)->data;
711                 }
712         }
713
714         return arm;
715 }
716
717 /* Show all armature layers */
718
719 static int pose_armature_layers_showall_exec(bContext *C, wmOperator *op)
720 {
721         Object *ob = CTX_data_active_object(C);
722         bArmature *arm = armature_layers_get_data(&ob);
723         PointerRNA ptr;
724         int maxLayers = (RNA_boolean_get(op->ptr, "all")) ? 32 : 16;
725         /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
726         bool layers[32] = {false};
727         int i;
728
729         /* sanity checking */
730         if (arm == NULL)
731                 return OPERATOR_CANCELLED;
732
733         /* use RNA to set the layers
734          * although it would be faster to just set directly using bitflags, we still
735          * need to setup a RNA pointer so that we get the "update" callbacks for free...
736          */
737         RNA_id_pointer_create(&arm->id, &ptr);
738
739         for (i = 0; i < maxLayers; i++)
740                 layers[i] = 1;
741
742         RNA_boolean_set_array(&ptr, "layers", layers);
743
744         /* note, notifier might evolve */
745         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
746         DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
747
748         /* done */
749         return OPERATOR_FINISHED;
750 }
751
752 void ARMATURE_OT_layers_show_all(wmOperatorType *ot)
753 {
754         /* identifiers */
755         ot->name = "Show All Layers";
756         ot->idname = "ARMATURE_OT_layers_show_all";
757         ot->description = "Make all armature layers visible";
758
759         /* callbacks */
760         ot->exec = pose_armature_layers_showall_exec;
761         ot->poll = armature_layers_poll;
762
763         /* flags */
764         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
765
766         /* properties */
767         ot->prop = RNA_def_boolean(ot->srna, "all", 1, "All Layers", "Enable all layers or just the first 16 (top row)");
768 }
769
770 /* ------------------- */
771
772 /* Present a popup to get the layers that should be used */
773 static int armature_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
774 {
775         Object *ob = CTX_data_active_object(C);
776         bArmature *arm = armature_layers_get_data(&ob);
777         PointerRNA ptr;
778         /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
779         bool layers[32];
780
781         /* sanity checking */
782         if (arm == NULL)
783                 return OPERATOR_CANCELLED;
784
785         /* get RNA pointer to armature data to use that to retrieve the layers as ints to init the operator */
786         RNA_id_pointer_create((ID *)arm, &ptr);
787         RNA_boolean_get_array(&ptr, "layers", layers);
788         RNA_boolean_set_array(op->ptr, "layers", layers);
789
790         /* part to sync with other similar operators... */
791         return WM_operator_props_popup(C, op, event);
792 }
793
794 /* Set the visible layers for the active armature (edit and pose modes) */
795 static int armature_layers_exec(bContext *C, wmOperator *op)
796 {
797         Object *ob = CTX_data_active_object(C);
798         bArmature *arm = armature_layers_get_data(&ob);
799         PointerRNA ptr;
800         /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
801         bool layers[32];
802
803         if (arm == NULL) {
804                 return OPERATOR_CANCELLED;
805         }
806
807         /* get the values set in the operator properties */
808         RNA_boolean_get_array(op->ptr, "layers", layers);
809
810         /* get pointer for armature, and write data there... */
811         RNA_id_pointer_create((ID *)arm, &ptr);
812         RNA_boolean_set_array(&ptr, "layers", layers);
813
814         /* note, notifier might evolve */
815         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
816         DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
817
818         return OPERATOR_FINISHED;
819 }
820
821 void ARMATURE_OT_armature_layers(wmOperatorType *ot)
822 {
823         /* identifiers */
824         ot->name = "Change Armature Layers";
825         ot->idname = "ARMATURE_OT_armature_layers";
826         ot->description = "Change the visible armature layers";
827
828         /* callbacks */
829         ot->invoke = armature_layers_invoke;
830         ot->exec = armature_layers_exec;
831         ot->poll = armature_layers_poll;
832
833         /* flags */
834         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
835
836         /* properties */
837         RNA_def_boolean_layer_member(ot->srna, "layers", 32, NULL, "Layer", "Armature layers to make visible");
838 }
839
840 /* ------------------- */
841
842 /* Present a popup to get the layers that should be used */
843 static int pose_bone_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
844 {
845         /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
846         bool layers[32] = {0};
847
848         /* get layers that are active already */
849         CTX_DATA_BEGIN (C, bPoseChannel *, pchan, selected_pose_bones)
850         {
851                 short bit;
852
853                 /* loop over the bits for this pchan's layers, adding layers where they're needed */
854                 for (bit = 0; bit < 32; bit++) {
855                         layers[bit] = (pchan->bone->layer & (1u << bit)) != 0;
856                 }
857         }
858         CTX_DATA_END;
859
860         /* copy layers to operator */
861         RNA_boolean_set_array(op->ptr, "layers", layers);
862
863         /* part to sync with other similar operators... */
864         return WM_operator_props_popup(C, op, event);
865 }
866
867 /* Set the visible layers for the active armature (edit and pose modes) */
868 static int pose_bone_layers_exec(bContext *C, wmOperator *op)
869 {
870         PointerRNA ptr;
871         /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
872         bool layers[32];
873
874         /* get the values set in the operator properties */
875         RNA_boolean_get_array(op->ptr, "layers", layers);
876
877         Object *prev_ob = NULL;
878
879         /* set layers of pchans based on the values set in the operator props */
880         CTX_DATA_BEGIN_WITH_ID (C, bPoseChannel *, pchan, selected_pose_bones, Object *, ob)
881         {
882                 /* get pointer for pchan, and write flags this way */
883                 RNA_pointer_create((ID *)ob->data, &RNA_Bone, pchan->bone, &ptr);
884                 RNA_boolean_set_array(&ptr, "layers", layers);
885
886                 if (prev_ob != ob) {
887                         /* Note, notifier might evolve. */
888                         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
889                         DEG_id_tag_update((ID *)ob->data, ID_RECALC_COPY_ON_WRITE);
890                         prev_ob = ob;
891                 }
892         }
893         CTX_DATA_END;
894         return OPERATOR_FINISHED;
895 }
896
897 void POSE_OT_bone_layers(wmOperatorType *ot)
898 {
899         /* identifiers */
900         ot->name = "Change Bone Layers";
901         ot->idname = "POSE_OT_bone_layers";
902         ot->description = "Change the layers that the selected bones belong to";
903
904         /* callbacks */
905         ot->invoke = pose_bone_layers_invoke;
906         ot->exec = pose_bone_layers_exec;
907         ot->poll = ED_operator_posemode_exclusive;
908
909         /* flags */
910         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
911
912         /* properties */
913         RNA_def_boolean_layer_member(ot->srna, "layers", 32, NULL, "Layer", "Armature layers that bone belongs to");
914 }
915
916 /* ------------------- */
917
918 /* Present a popup to get the layers that should be used */
919 static int armature_bone_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
920 {
921         /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
922         bool layers[32] = {0};
923
924         /* get layers that are active already */
925         CTX_DATA_BEGIN (C, EditBone *, ebone, selected_editable_bones)
926         {
927                 short bit;
928
929                 /* loop over the bits for this pchan's layers, adding layers where they're needed */
930                 for (bit = 0; bit < 32; bit++) {
931                         if (ebone->layer & (1u << bit)) {
932                                 layers[bit] = 1;
933                         }
934                 }
935         }
936         CTX_DATA_END;
937
938         /* copy layers to operator */
939         RNA_boolean_set_array(op->ptr, "layers", layers);
940
941         /* part to sync with other similar operators... */
942         return WM_operator_props_popup(C, op, event);
943 }
944
945 /* Set the visible layers for the active armature (edit and pose modes) */
946 static int armature_bone_layers_exec(bContext *C, wmOperator *op)
947 {
948         Object *ob = CTX_data_edit_object(C);
949         PointerRNA ptr;
950         /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
951         bool layers[32];
952
953         /* get the values set in the operator properties */
954         RNA_boolean_get_array(op->ptr, "layers", layers);
955
956         /* set layers of pchans based on the values set in the operator props */
957         CTX_DATA_BEGIN_WITH_ID (C, EditBone *, ebone, selected_editable_bones, bArmature *, arm)
958         {
959                 /* get pointer for pchan, and write flags this way */
960                 RNA_pointer_create((ID *)arm, &RNA_EditBone, ebone, &ptr);
961                 RNA_boolean_set_array(&ptr, "layers", layers);
962         }
963         CTX_DATA_END;
964
965         /* note, notifier might evolve */
966         WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
967
968         return OPERATOR_FINISHED;
969 }
970
971 void ARMATURE_OT_bone_layers(wmOperatorType *ot)
972 {
973         /* identifiers */
974         ot->name = "Change Bone Layers";
975         ot->idname = "ARMATURE_OT_bone_layers";
976         ot->description = "Change the layers that the selected bones belong to";
977
978         /* callbacks */
979         ot->invoke = armature_bone_layers_invoke;
980         ot->exec = armature_bone_layers_exec;
981         ot->poll = ED_operator_editarmature;
982
983         /* flags */
984         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
985
986         /* properties */
987         RNA_def_boolean_layer_member(ot->srna, "layers", 32, NULL, "Layer", "Armature layers that bone belongs to");
988 }
989
990 /* ********************************************** */
991 /* Show/Hide Bones */
992
993 static int hide_pose_bone_fn(Object *ob, Bone *bone, void *ptr)
994 {
995         bArmature *arm = ob->data;
996         const bool hide_select = (bool)POINTER_AS_INT(ptr);
997         int count = 0;
998         if (arm->layer & bone->layer) {
999                 if (((bone->flag & BONE_SELECTED) != 0) == hide_select) {
1000                         bone->flag |= BONE_HIDDEN_P;
1001                         /* only needed when 'hide_select' is true, but harmless. */
1002                         bone->flag &= ~BONE_SELECTED;
1003                         if (arm->act_bone == bone) {
1004                                 arm->act_bone = NULL;
1005                         }
1006                         count += 1;
1007                 }
1008         }
1009         return count;
1010 }
1011
1012 /* active object is armature in posemode, poll checked */
1013 static int pose_hide_exec(bContext *C, wmOperator *op)
1014 {
1015         ViewLayer *view_layer = CTX_data_view_layer(C);
1016         uint objects_len;
1017         Object **objects = BKE_object_pose_array_get_unique(view_layer, CTX_wm_view3d(C), &objects_len);
1018         bool changed_multi = false;
1019
1020         const int hide_select = !RNA_boolean_get(op->ptr, "unselected");
1021         void     *hide_select_p = POINTER_FROM_INT(hide_select);
1022
1023         for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
1024                 Object *ob_iter = objects[ob_index];
1025                 bArmature *arm = ob_iter->data;
1026
1027                 if (ob_iter->proxy != NULL) {
1028                         BKE_report(op->reports, RPT_INFO, "Undo of hiding can only be done with Reveal Selected");
1029                 }
1030
1031                 bool changed = bone_looper(ob_iter, arm->bonebase.first, hide_select_p, hide_pose_bone_fn) != 0;
1032                 if (changed) {
1033                         changed_multi = true;
1034                         WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob_iter);
1035                         DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
1036                 }
1037         }
1038         MEM_freeN(objects);
1039
1040         return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1041 }
1042
1043 void POSE_OT_hide(wmOperatorType *ot)
1044 {
1045         /* identifiers */
1046         ot->name = "Hide Selected";
1047         ot->idname = "POSE_OT_hide";
1048         ot->description = "Tag selected bones to not be visible in Pose Mode";
1049
1050         /* api callbacks */
1051         ot->exec = pose_hide_exec;
1052         ot->poll = ED_operator_posemode;
1053
1054         /* flags */
1055         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1056
1057         /* props */
1058         RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "");
1059 }
1060
1061 static int show_pose_bone_cb(Object *ob, Bone *bone, void *data)
1062 {
1063         const bool select = POINTER_AS_INT(data);
1064
1065         bArmature *arm = ob->data;
1066         int count = 0;
1067         if (arm->layer & bone->layer) {
1068                 if (bone->flag & BONE_HIDDEN_P) {
1069                         if (!(bone->flag & BONE_UNSELECTABLE)) {
1070                                 SET_FLAG_FROM_TEST(bone->flag, select, BONE_SELECTED);
1071                         }
1072                         bone->flag &= ~BONE_HIDDEN_P;
1073                         count += 1;
1074                 }
1075         }
1076
1077         return count;
1078 }
1079
1080 /* active object is armature in posemode, poll checked */
1081 static int pose_reveal_exec(bContext *C, wmOperator *op)
1082 {
1083         ViewLayer *view_layer = CTX_data_view_layer(C);
1084         uint objects_len;
1085         Object **objects = BKE_object_pose_array_get_unique(view_layer, CTX_wm_view3d(C), &objects_len);
1086         bool changed_multi = false;
1087         const bool select = RNA_boolean_get(op->ptr, "select");
1088         void *select_p = POINTER_FROM_INT(select);
1089
1090         for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
1091                 Object *ob_iter = objects[ob_index];
1092                 bArmature *arm = ob_iter->data;
1093
1094                 bool changed = bone_looper(ob_iter, arm->bonebase.first, select_p, show_pose_bone_cb);
1095                 if (changed) {
1096                         changed_multi = true;
1097                         WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob_iter);
1098                         DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
1099                 }
1100         }
1101         MEM_freeN(objects);
1102
1103         return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1104 }
1105
1106 void POSE_OT_reveal(wmOperatorType *ot)
1107 {
1108         /* identifiers */
1109         ot->name = "Reveal Selected";
1110         ot->idname = "POSE_OT_reveal";
1111         ot->description = "Reveal all bones hidden in Pose Mode";
1112
1113         /* api callbacks */
1114         ot->exec = pose_reveal_exec;
1115         ot->poll = ED_operator_posemode;
1116
1117         /* flags */
1118         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1119
1120         RNA_def_boolean(ot->srna, "select", true, "Select", "");
1121 }
1122
1123 /* ********************************************** */
1124 /* Flip Quats */
1125
1126 static int pose_flip_quats_exec(bContext *C, wmOperator *UNUSED(op))
1127 {
1128         Scene *scene = CTX_data_scene(C);
1129         KeyingSet *ks = ANIM_builtin_keyingset_get_named(NULL, ANIM_KS_LOC_ROT_SCALE_ID);
1130
1131         bool changed_multi = false;
1132
1133         ViewLayer *view_layer = CTX_data_view_layer(C);
1134         View3D *v3d = CTX_wm_view3d(C);
1135         FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter) {
1136                 bool changed = false;
1137                 /* loop through all selected pchans, flipping and keying (as needed) */
1138                 FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (ob_iter, pchan) {
1139                         /* only if bone is using quaternion rotation */
1140                         if (pchan->rotmode == ROT_MODE_QUAT) {
1141                                 changed = true;
1142                                 /* quaternions have 720 degree range */
1143                                 negate_v4(pchan->quat);
1144
1145                                 ED_autokeyframe_pchan(C, scene, ob_iter, pchan, ks);
1146                         }
1147                 } FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
1148
1149                 if (changed) {
1150                         changed_multi = true;
1151                         /* notifiers and updates */
1152                         DEG_id_tag_update(&ob_iter->id, ID_RECALC_GEOMETRY);
1153                         WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, ob_iter);
1154                 }
1155         } FOREACH_OBJECT_IN_MODE_END;
1156
1157         return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1158 }
1159
1160 void POSE_OT_quaternions_flip(wmOperatorType *ot)
1161 {
1162         /* identifiers */
1163         ot->name = "Flip Quats";
1164         ot->idname = "POSE_OT_quaternions_flip";
1165         ot->description = "Flip quaternion values to achieve desired rotations, while maintaining the same orientations";
1166
1167         /* callbacks */
1168         ot->exec = pose_flip_quats_exec;
1169         ot->poll = ED_operator_posemode;
1170
1171         /* flags */
1172         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1173 }