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