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