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