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