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