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