Cleanup: add missing macros to clang-format
[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     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     pchan->rotmode = mode;
663
664     if (prev_ob != ob) {
665       /* Notifiers and updates. */
666       DEG_id_tag_update((ID *)ob, ID_RECALC_GEOMETRY);
667       WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, ob);
668       WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob);
669       prev_ob = ob;
670     }
671   }
672   CTX_DATA_END;
673
674   return OPERATOR_FINISHED;
675 }
676
677 void POSE_OT_rotation_mode_set(wmOperatorType *ot)
678 {
679   /* identifiers */
680   ot->name = "Set Rotation Mode";
681   ot->idname = "POSE_OT_rotation_mode_set";
682   ot->description = "Set the rotation representation used by selected bones";
683
684   /* callbacks */
685   ot->invoke = WM_menu_invoke;
686   ot->exec = pose_bone_rotmode_exec;
687   ot->poll = ED_operator_posemode;
688
689   /* flags */
690   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
691
692   /* properties */
693   ot->prop = RNA_def_enum(
694       ot->srna, "type", rna_enum_object_rotation_mode_items, 0, "Rotation Mode", "");
695 }
696
697 /* ********************************************** */
698
699 static bool armature_layers_poll(bContext *C)
700 {
701   /* Armature layers operators can be used in posemode OR editmode for armatures */
702   return ED_operator_posemode(C) || ED_operator_editarmature(C);
703 }
704
705 static bArmature *armature_layers_get_data(Object **ob)
706 {
707   bArmature *arm = NULL;
708
709   /* Sanity checking and handling of posemode. */
710   if (*ob) {
711     Object *tob = BKE_object_pose_armature_get(*ob);
712     if (tob) {
713       *ob = tob;
714       arm = (*ob)->data;
715     }
716     else if ((*ob)->type == OB_ARMATURE) {
717       arm = (*ob)->data;
718     }
719   }
720
721   return arm;
722 }
723
724 /* Show all armature layers */
725
726 static int pose_armature_layers_showall_exec(bContext *C, wmOperator *op)
727 {
728   Object *ob = CTX_data_active_object(C);
729   bArmature *arm = armature_layers_get_data(&ob);
730   PointerRNA ptr;
731   int maxLayers = (RNA_boolean_get(op->ptr, "all")) ? 32 : 16;
732   /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
733   bool layers[32] = {false};
734   int i;
735
736   /* sanity checking */
737   if (arm == NULL)
738     return OPERATOR_CANCELLED;
739
740   /* use RNA to set the layers
741    * although it would be faster to just set directly using bitflags, we still
742    * need to setup a RNA pointer so that we get the "update" callbacks for free...
743    */
744   RNA_id_pointer_create(&arm->id, &ptr);
745
746   for (i = 0; i < maxLayers; i++)
747     layers[i] = 1;
748
749   RNA_boolean_set_array(&ptr, "layers", layers);
750
751   /* note, notifier might evolve */
752   WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
753   DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
754
755   /* done */
756   return OPERATOR_FINISHED;
757 }
758
759 void ARMATURE_OT_layers_show_all(wmOperatorType *ot)
760 {
761   /* identifiers */
762   ot->name = "Show All Layers";
763   ot->idname = "ARMATURE_OT_layers_show_all";
764   ot->description = "Make all armature layers visible";
765
766   /* callbacks */
767   ot->exec = pose_armature_layers_showall_exec;
768   ot->poll = armature_layers_poll;
769
770   /* flags */
771   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
772
773   /* properties */
774   ot->prop = RNA_def_boolean(
775       ot->srna, "all", 1, "All Layers", "Enable all layers or just the first 16 (top row)");
776 }
777
778 /* ------------------- */
779
780 /* Present a popup to get the layers that should be used */
781 static int armature_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
782 {
783   Object *ob = CTX_data_active_object(C);
784   bArmature *arm = armature_layers_get_data(&ob);
785   PointerRNA ptr;
786   /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
787   bool layers[32];
788
789   /* sanity checking */
790   if (arm == NULL)
791     return OPERATOR_CANCELLED;
792
793   /* get RNA pointer to armature data to use that to retrieve the layers as ints to init the operator */
794   RNA_id_pointer_create((ID *)arm, &ptr);
795   RNA_boolean_get_array(&ptr, "layers", layers);
796   RNA_boolean_set_array(op->ptr, "layers", layers);
797
798   /* part to sync with other similar operators... */
799   return WM_operator_props_popup(C, op, event);
800 }
801
802 /* Set the visible layers for the active armature (edit and pose modes) */
803 static int armature_layers_exec(bContext *C, wmOperator *op)
804 {
805   Object *ob = CTX_data_active_object(C);
806   bArmature *arm = armature_layers_get_data(&ob);
807   PointerRNA ptr;
808   /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
809   bool layers[32];
810
811   if (arm == NULL) {
812     return OPERATOR_CANCELLED;
813   }
814
815   /* get the values set in the operator properties */
816   RNA_boolean_get_array(op->ptr, "layers", layers);
817
818   /* get pointer for armature, and write data there... */
819   RNA_id_pointer_create((ID *)arm, &ptr);
820   RNA_boolean_set_array(&ptr, "layers", layers);
821
822   /* note, notifier might evolve */
823   WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
824   DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
825
826   return OPERATOR_FINISHED;
827 }
828
829 void ARMATURE_OT_armature_layers(wmOperatorType *ot)
830 {
831   /* identifiers */
832   ot->name = "Change Armature Layers";
833   ot->idname = "ARMATURE_OT_armature_layers";
834   ot->description = "Change the visible armature layers";
835
836   /* callbacks */
837   ot->invoke = armature_layers_invoke;
838   ot->exec = armature_layers_exec;
839   ot->poll = armature_layers_poll;
840
841   /* flags */
842   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
843
844   /* properties */
845   RNA_def_boolean_layer_member(
846       ot->srna, "layers", 32, NULL, "Layer", "Armature layers to make visible");
847 }
848
849 /* ------------------- */
850
851 /* Present a popup to get the layers that should be used */
852 static int pose_bone_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
853 {
854   /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
855   bool layers[32] = {0};
856
857   /* get layers that are active already */
858   CTX_DATA_BEGIN (C, bPoseChannel *, pchan, selected_pose_bones) {
859     short bit;
860
861     /* loop over the bits for this pchan's layers, adding layers where they're needed */
862     for (bit = 0; bit < 32; bit++) {
863       layers[bit] = (pchan->bone->layer & (1u << bit)) != 0;
864     }
865   }
866   CTX_DATA_END;
867
868   /* copy layers to operator */
869   RNA_boolean_set_array(op->ptr, "layers", layers);
870
871   /* part to sync with other similar operators... */
872   return WM_operator_props_popup(C, op, event);
873 }
874
875 /* Set the visible layers for the active armature (edit and pose modes) */
876 static int pose_bone_layers_exec(bContext *C, wmOperator *op)
877 {
878   PointerRNA ptr;
879   /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
880   bool layers[32];
881
882   /* get the values set in the operator properties */
883   RNA_boolean_get_array(op->ptr, "layers", layers);
884
885   Object *prev_ob = NULL;
886
887   /* set layers of pchans based on the values set in the operator props */
888   CTX_DATA_BEGIN_WITH_ID (C, bPoseChannel *, pchan, selected_pose_bones, Object *, ob) {
889     /* get pointer for pchan, and write flags this way */
890     RNA_pointer_create((ID *)ob->data, &RNA_Bone, pchan->bone, &ptr);
891     RNA_boolean_set_array(&ptr, "layers", layers);
892
893     if (prev_ob != ob) {
894       /* Note, notifier might evolve. */
895       WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
896       DEG_id_tag_update((ID *)ob->data, ID_RECALC_COPY_ON_WRITE);
897       prev_ob = ob;
898     }
899   }
900   CTX_DATA_END;
901   return OPERATOR_FINISHED;
902 }
903
904 void POSE_OT_bone_layers(wmOperatorType *ot)
905 {
906   /* identifiers */
907   ot->name = "Change Bone Layers";
908   ot->idname = "POSE_OT_bone_layers";
909   ot->description = "Change the layers that the selected bones belong to";
910
911   /* callbacks */
912   ot->invoke = pose_bone_layers_invoke;
913   ot->exec = pose_bone_layers_exec;
914   ot->poll = ED_operator_posemode_exclusive;
915
916   /* flags */
917   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
918
919   /* properties */
920   RNA_def_boolean_layer_member(
921       ot->srna, "layers", 32, NULL, "Layer", "Armature layers that bone belongs to");
922 }
923
924 /* ------------------- */
925
926 /* Present a popup to get the layers that should be used */
927 static int armature_bone_layers_invoke(bContext *C, wmOperator *op, const wmEvent *event)
928 {
929   /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
930   bool layers[32] = {0};
931
932   /* get layers that are active already */
933   CTX_DATA_BEGIN (C, EditBone *, ebone, selected_editable_bones) {
934     short bit;
935
936     /* loop over the bits for this pchan's layers, adding layers where they're needed */
937     for (bit = 0; bit < 32; bit++) {
938       if (ebone->layer & (1u << bit)) {
939         layers[bit] = 1;
940       }
941     }
942   }
943   CTX_DATA_END;
944
945   /* copy layers to operator */
946   RNA_boolean_set_array(op->ptr, "layers", layers);
947
948   /* part to sync with other similar operators... */
949   return WM_operator_props_popup(C, op, event);
950 }
951
952 /* Set the visible layers for the active armature (edit and pose modes) */
953 static int armature_bone_layers_exec(bContext *C, wmOperator *op)
954 {
955   Object *ob = CTX_data_edit_object(C);
956   PointerRNA ptr;
957   /* hardcoded for now - we can only have 32 armature layers, so this should be fine... */
958   bool layers[32];
959
960   /* get the values set in the operator properties */
961   RNA_boolean_get_array(op->ptr, "layers", layers);
962
963   /* set layers of pchans based on the values set in the operator props */
964   CTX_DATA_BEGIN_WITH_ID (C, EditBone *, ebone, selected_editable_bones, bArmature *, arm) {
965     /* get pointer for pchan, and write flags this way */
966     RNA_pointer_create((ID *)arm, &RNA_EditBone, ebone, &ptr);
967     RNA_boolean_set_array(&ptr, "layers", layers);
968   }
969   CTX_DATA_END;
970
971   /* note, notifier might evolve */
972   WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
973
974   return OPERATOR_FINISHED;
975 }
976
977 void ARMATURE_OT_bone_layers(wmOperatorType *ot)
978 {
979   /* identifiers */
980   ot->name = "Change Bone Layers";
981   ot->idname = "ARMATURE_OT_bone_layers";
982   ot->description = "Change the layers that the selected bones belong to";
983
984   /* callbacks */
985   ot->invoke = armature_bone_layers_invoke;
986   ot->exec = armature_bone_layers_exec;
987   ot->poll = ED_operator_editarmature;
988
989   /* flags */
990   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
991
992   /* properties */
993   RNA_def_boolean_layer_member(
994       ot->srna, "layers", 32, NULL, "Layer", "Armature layers that bone belongs to");
995 }
996
997 /* ********************************************** */
998 /* Show/Hide Bones */
999
1000 static int hide_pose_bone_fn(Object *ob, Bone *bone, void *ptr)
1001 {
1002   bArmature *arm = ob->data;
1003   const bool hide_select = (bool)POINTER_AS_INT(ptr);
1004   int count = 0;
1005   if (arm->layer & bone->layer) {
1006     if (((bone->flag & BONE_SELECTED) != 0) == hide_select) {
1007       bone->flag |= BONE_HIDDEN_P;
1008       /* only needed when 'hide_select' is true, but harmless. */
1009       bone->flag &= ~BONE_SELECTED;
1010       if (arm->act_bone == bone) {
1011         arm->act_bone = NULL;
1012       }
1013       count += 1;
1014     }
1015   }
1016   return count;
1017 }
1018
1019 /* active object is armature in posemode, poll checked */
1020 static int pose_hide_exec(bContext *C, wmOperator *op)
1021 {
1022   ViewLayer *view_layer = CTX_data_view_layer(C);
1023   uint objects_len;
1024   Object **objects = BKE_object_pose_array_get_unique(view_layer, CTX_wm_view3d(C), &objects_len);
1025   bool changed_multi = false;
1026
1027   const int hide_select = !RNA_boolean_get(op->ptr, "unselected");
1028   void *hide_select_p = POINTER_FROM_INT(hide_select);
1029
1030   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
1031     Object *ob_iter = objects[ob_index];
1032     bArmature *arm = ob_iter->data;
1033
1034     if (ob_iter->proxy != NULL) {
1035       BKE_report(op->reports, RPT_INFO, "Undo of hiding can only be done with Reveal Selected");
1036     }
1037
1038     bool changed = bone_looper(ob_iter, arm->bonebase.first, hide_select_p, hide_pose_bone_fn) !=
1039                    0;
1040     if (changed) {
1041       changed_multi = true;
1042       WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob_iter);
1043       DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
1044     }
1045   }
1046   MEM_freeN(objects);
1047
1048   return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1049 }
1050
1051 void POSE_OT_hide(wmOperatorType *ot)
1052 {
1053   /* identifiers */
1054   ot->name = "Hide Selected";
1055   ot->idname = "POSE_OT_hide";
1056   ot->description = "Tag selected bones to not be visible in Pose Mode";
1057
1058   /* api callbacks */
1059   ot->exec = pose_hide_exec;
1060   ot->poll = ED_operator_posemode;
1061
1062   /* flags */
1063   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1064
1065   /* props */
1066   RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "");
1067 }
1068
1069 static int show_pose_bone_cb(Object *ob, Bone *bone, void *data)
1070 {
1071   const bool select = POINTER_AS_INT(data);
1072
1073   bArmature *arm = ob->data;
1074   int count = 0;
1075   if (arm->layer & bone->layer) {
1076     if (bone->flag & BONE_HIDDEN_P) {
1077       if (!(bone->flag & BONE_UNSELECTABLE)) {
1078         SET_FLAG_FROM_TEST(bone->flag, select, BONE_SELECTED);
1079       }
1080       bone->flag &= ~BONE_HIDDEN_P;
1081       count += 1;
1082     }
1083   }
1084
1085   return count;
1086 }
1087
1088 /* active object is armature in posemode, poll checked */
1089 static int pose_reveal_exec(bContext *C, wmOperator *op)
1090 {
1091   ViewLayer *view_layer = CTX_data_view_layer(C);
1092   uint objects_len;
1093   Object **objects = BKE_object_pose_array_get_unique(view_layer, CTX_wm_view3d(C), &objects_len);
1094   bool changed_multi = false;
1095   const bool select = RNA_boolean_get(op->ptr, "select");
1096   void *select_p = POINTER_FROM_INT(select);
1097
1098   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
1099     Object *ob_iter = objects[ob_index];
1100     bArmature *arm = ob_iter->data;
1101
1102     bool changed = bone_looper(ob_iter, arm->bonebase.first, select_p, show_pose_bone_cb);
1103     if (changed) {
1104       changed_multi = true;
1105       WM_event_add_notifier(C, NC_OBJECT | ND_BONE_SELECT, ob_iter);
1106       DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
1107     }
1108   }
1109   MEM_freeN(objects);
1110
1111   return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1112 }
1113
1114 void POSE_OT_reveal(wmOperatorType *ot)
1115 {
1116   /* identifiers */
1117   ot->name = "Reveal Selected";
1118   ot->idname = "POSE_OT_reveal";
1119   ot->description = "Reveal all bones hidden in Pose Mode";
1120
1121   /* api callbacks */
1122   ot->exec = pose_reveal_exec;
1123   ot->poll = ED_operator_posemode;
1124
1125   /* flags */
1126   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1127
1128   RNA_def_boolean(ot->srna, "select", true, "Select", "");
1129 }
1130
1131 /* ********************************************** */
1132 /* Flip Quats */
1133
1134 static int pose_flip_quats_exec(bContext *C, wmOperator *UNUSED(op))
1135 {
1136   Scene *scene = CTX_data_scene(C);
1137   KeyingSet *ks = ANIM_builtin_keyingset_get_named(NULL, ANIM_KS_LOC_ROT_SCALE_ID);
1138
1139   bool changed_multi = false;
1140
1141   ViewLayer *view_layer = CTX_data_view_layer(C);
1142   View3D *v3d = CTX_wm_view3d(C);
1143   FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter) {
1144     bool changed = false;
1145     /* loop through all selected pchans, flipping and keying (as needed) */
1146     FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (ob_iter, pchan) {
1147       /* only if bone is using quaternion rotation */
1148       if (pchan->rotmode == ROT_MODE_QUAT) {
1149         changed = true;
1150         /* quaternions have 720 degree range */
1151         negate_v4(pchan->quat);
1152
1153         ED_autokeyframe_pchan(C, scene, ob_iter, pchan, ks);
1154       }
1155     }
1156     FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
1157
1158     if (changed) {
1159       changed_multi = true;
1160       /* notifiers and updates */
1161       DEG_id_tag_update(&ob_iter->id, ID_RECALC_GEOMETRY);
1162       WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, ob_iter);
1163     }
1164   }
1165   FOREACH_OBJECT_IN_MODE_END;
1166
1167   return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
1168 }
1169
1170 void POSE_OT_quaternions_flip(wmOperatorType *ot)
1171 {
1172   /* identifiers */
1173   ot->name = "Flip Quats";
1174   ot->idname = "POSE_OT_quaternions_flip";
1175   ot->description =
1176       "Flip quaternion values to achieve desired rotations, while maintaining the same "
1177       "orientations";
1178
1179   /* callbacks */
1180   ot->exec = pose_flip_quats_exec;
1181   ot->poll = ED_operator_posemode;
1182
1183   /* flags */
1184   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1185 }