diff options
Diffstat (limited to 'source/blender/editors/armature/pose_lib.c')
| -rw-r--r-- | source/blender/editors/armature/pose_lib.c | 1658 |
1 files changed, 1658 insertions, 0 deletions
diff --git a/source/blender/editors/armature/pose_lib.c b/source/blender/editors/armature/pose_lib.c new file mode 100644 index 00000000000..09c0f7e9647 --- /dev/null +++ b/source/blender/editors/armature/pose_lib.c @@ -0,0 +1,1658 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * The Original Code is Copyright (C) 2007, Blender Foundation + * This is a new part of Blender + * + * Contributor(s): Joshua Leung + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/editors/armature/pose_lib.c + * \ingroup edarmature + */ + +#include <string.h> +#include <math.h> + +#include "MEM_guardedalloc.h" + +#include "BLI_blenlib.h" +#include "BLI_dlrbTree.h" + +#include "BLF_translation.h" + +#include "DNA_anim_types.h" +#include "DNA_armature_types.h" +#include "DNA_object_types.h" +#include "DNA_scene_types.h" + +#include "BKE_animsys.h" +#include "BKE_action.h" +#include "BKE_armature.h" +#include "BKE_depsgraph.h" +#include "BKE_global.h" +#include "BKE_idprop.h" +#include "BKE_library.h" +#include "BKE_object.h" + +#include "BKE_context.h" +#include "BKE_report.h" + +#include "RNA_access.h" +#include "RNA_define.h" +#include "RNA_enum_types.h" + +#include "WM_api.h" +#include "WM_types.h" + +#include "UI_interface.h" +#include "UI_resources.h" + +#include "ED_anim_api.h" +#include "ED_armature.h" +#include "ED_keyframes_draw.h" +#include "ED_keyframing.h" +#include "ED_keyframes_edit.h" +#include "ED_screen.h" +#include "ED_object.h" + +#include "armature_intern.h" + +/* ******* XXX ********** */ + +static void action_set_activemarker(void *UNUSED(a), void *UNUSED(b), void *UNUSED(c)) {} + +/* ************************************************************* */ +/* == POSE-LIBRARY TOOL FOR BLENDER == + * + * Overview: + * This tool allows animators to store a set of frequently used poses to dump into + * the active action to help in "budget" productions to quickly block out new actions. + * It acts as a kind of "glorified clipboard for poses", allowing for naming of poses. + * + * Features: + * - PoseLibs are simply normal Actions + * - Each "pose" is simply a set of keyframes that occur on a particular frame + * -> a set of TimeMarkers that belong to each Action, help 'label' where a 'pose' can be + * found in the Action + * - The Scrollwheel or PageUp/Down buttons when used in a special mode or after pressing/holding + * [a modifier] key, cycles through the poses available for the active pose's poselib, allowing the + * animator to preview what action best suits that pose + */ +/* ************************************************************* */ + + +/* gets the first available frame in poselib to store a pose on + * - frames start from 1, and a pose should occur on every frame... 0 is error! + */ +static int poselib_get_free_index(bAction *act) +{ + TimeMarker *marker; + int low = 0, high = 0; + short changed = 0; + + /* sanity checks */ + if (ELEM(NULL, act, act->markers.first)) return 1; + + /* As poses are not stored in chronological order, we must iterate over this list + * a few times until we don't make any new discoveries (mostly about the lower bound). + * Prevents problems with deleting then trying to add new poses [#27412] + */ + do { + changed = 0; + + for (marker = act->markers.first; marker; marker = marker->next) { + /* only increase low if value is 1 greater than low, to find "gaps" where + * poses were removed from the poselib + */ + if (marker->frame == (low + 1)) { + low++; + changed = 1; + } + + /* value replaces high if it is the highest value encountered yet */ + if (marker->frame > high) { + high = marker->frame; + changed = 1; + } + } + } while (changed != 0); + + /* - if low is not equal to high, then low+1 is a gap + * - if low is equal to high, then high+1 is the next index (add at end) + */ + if (low < high) + return (low + 1); + else + return (high + 1); +} + +/* returns the active pose for a poselib */ +static TimeMarker *poselib_get_active_pose(bAction *act) +{ + if ((act) && (act->active_marker)) + return BLI_findlink(&act->markers, act->active_marker - 1); + else + return NULL; +} + +/* Get object that Pose Lib should be found on */ +/* XXX C can be zero */ +static Object *get_poselib_object(bContext *C) +{ + ScrArea *sa; + + /* sanity check */ + if (C == NULL) + return NULL; + + sa = CTX_wm_area(C); + + if (sa && (sa->spacetype == SPACE_BUTS)) + return ED_object_context(C); + else + return BKE_object_pose_armature_get(CTX_data_active_object(C)); +} + +/* Poll callback for operators that require existing PoseLib data (with poses) to work */ +static int has_poselib_pose_data_poll(bContext *C) +{ + Object *ob = get_poselib_object(C); + return (ob && ob->poselib); +} + +/* ----------------------------------- */ + +/* Initialize a new poselib (whether it is needed or not) */ +static bAction *poselib_init_new(Object *ob) +{ + /* sanity checks - only for armatures */ + if (ELEM(NULL, ob, ob->pose)) + return NULL; + + /* init object's poselib action (unlink old one if there) */ + if (ob->poselib) + id_us_min(&ob->poselib->id); + ob->poselib = add_empty_action(G.main, "PoseLib"); + + return ob->poselib; +} + +/* Initialize a new poselib (checks if that needs to happen) */ +static bAction *poselib_validate(Object *ob) +{ + if (ELEM(NULL, ob, ob->pose)) + return NULL; + else if (ob->poselib == NULL) + return poselib_init_new(ob); + else + return ob->poselib; +} + +/* ************************************************************* */ +/* Pose Lib UI Operators */ + +static int poselib_new_exec(bContext *C, wmOperator *UNUSED(op)) +{ + Object *ob = get_poselib_object(C); + + /* sanity checks */ + if (ob == NULL) + return OPERATOR_CANCELLED; + + /* new method here deals with the rest... */ + poselib_init_new(ob); + + /* notifier here might evolve? */ + WM_event_add_notifier(C, NC_OBJECT | ND_POSE, NULL); + + return OPERATOR_FINISHED; +} + +void POSELIB_OT_new(wmOperatorType *ot) +{ + /* identifiers */ + ot->name = "New Pose Library"; + ot->idname = "POSELIB_OT_new"; + ot->description = "Add New Pose Library to active Object"; + + /* callbacks */ + ot->exec = poselib_new_exec; + ot->poll = ED_operator_posemode; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; +} + +/* ------------------------------------------------ */ + +static int poselib_unlink_exec(bContext *C, wmOperator *UNUSED(op)) +{ + Object *ob = get_poselib_object(C); + + /* sanity checks */ + if (ELEM(NULL, ob, ob->poselib)) + return OPERATOR_CANCELLED; + + /* there should be a poselib (we just checked above!), so just lower its user count and remove */ + id_us_min(&ob->poselib->id); + ob->poselib = NULL; + + /* notifier here might evolve? */ + WM_event_add_notifier(C, NC_OBJECT | ND_POSE, NULL); + + return OPERATOR_FINISHED; +} + +void POSELIB_OT_unlink(wmOperatorType *ot) +{ + /* identifiers */ + ot->name = "Unlink Pose Library"; + ot->idname = "POSELIB_OT_unlink"; + ot->description = "Remove Pose Library from active Object"; + + /* callbacks */ + ot->exec = poselib_unlink_exec; + ot->poll = has_poselib_pose_data_poll; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; +} + +/* ************************************************************* */ +/* Pose Editing Operators */ + +/* This tool automagically generates/validates poselib data so that it corresponds to the data + * in the action. This is for use in making existing actions usable as poselibs. + */ +static int poselib_sanitize_exec(bContext *C, wmOperator *op) +{ + Object *ob = get_poselib_object(C); + bAction *act = (ob) ? ob->poselib : NULL; + DLRBT_Tree keys; + ActKeyColumn *ak; + TimeMarker *marker, *markern; + + /* validate action */ + if (act == NULL) { + BKE_report(op->reports, RPT_WARNING, "No action to validate"); + return OPERATOR_CANCELLED; + } + + /* determine which frames have keys */ + BLI_dlrbTree_init(&keys); + action_to_keylist(NULL, act, &keys, NULL); + BLI_dlrbTree_linkedlist_sync(&keys); + + /* for each key, make sure there is a corresponding pose */ + for (ak = keys.first; ak; ak = ak->next) { + /* check if any pose matches this */ + /* TODO: don't go looking through the list like this every time... */ + for (marker = act->markers.first; marker; marker = marker->next) { + if (IS_EQ(marker->frame, (double)ak->cfra)) { + marker->flag = -1; + break; + } + } + + /* add new if none found */ + if (marker == NULL) { + /* add pose to poselib */ + marker = MEM_callocN(sizeof(TimeMarker), "ActionMarker"); + + BLI_strncpy(marker->name, "Pose", sizeof(marker->name)); + + marker->frame = (int)ak->cfra; + marker->flag = -1; + + BLI_addtail(&act->markers, marker); + } + } + + /* remove all untagged poses (unused), and remove all tags */ + for (marker = act->markers.first; marker; marker = markern) { + markern = marker->next; + + if (marker->flag != -1) + BLI_freelinkN(&act->markers, marker); + else + marker->flag = 0; + } + + /* free temp memory */ + BLI_dlrbTree_free(&keys); + + /* send notifiers for this - using keyframe editing notifiers, since action + * may be being shown in anim editors as active action + */ + WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL); + + return OPERATOR_FINISHED; +} + +void POSELIB_OT_action_sanitize(wmOperatorType *ot) +{ + /* identifiers */ + ot->name = "Sanitize Pose Library Action"; + ot->idname = "POSELIB_OT_action_sanitize"; + ot->description = "Make action suitable for use as a Pose Library"; + + /* callbacks */ + ot->exec = poselib_sanitize_exec; + ot->poll = has_poselib_pose_data_poll; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; +} + +/* ------------------------------------------ */ + +static void poselib_add_menu_invoke__replacemenu(bContext *C, uiLayout *layout, void *UNUSED(arg)) +{ + Object *ob = get_poselib_object(C); + bAction *act = ob->poselib; /* never NULL */ + TimeMarker *marker; + + wmOperatorType *ot = WM_operatortype_find("POSELIB_OT_pose_add", 1); + + BLI_assert(ot != NULL); + + /* set the operator execution context correctly */ + uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT); + + /* add each marker to this menu */ + for (marker = act->markers.first; marker; marker = marker->next) { + PointerRNA props_ptr; + + props_ptr = uiItemFullO_ptr(layout, ot, + marker->name, ICON_ARMATURE_DATA, NULL, + WM_OP_EXEC_DEFAULT, UI_ITEM_O_RETURN_PROPS); + + RNA_int_set(&props_ptr, "frame", marker->frame); + RNA_string_set(&props_ptr, "name", marker->name); + } +} + +static int poselib_add_menu_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)) +{ + Scene *scene = CTX_data_scene(C); + Object *ob = get_poselib_object(C); + bPose *pose = (ob) ? ob->pose : NULL; + uiPopupMenu *pup; + uiLayout *layout; + + /* sanity check */ + if (ELEM(NULL, ob, pose)) + return OPERATOR_CANCELLED; + + /* start building */ + pup = uiPupMenuBegin(C, op->type->name, ICON_NONE); + layout = uiPupMenuLayout(pup); + uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT); + + /* add new (adds to the first unoccupied frame) */ + uiItemIntO(layout, IFACE_("Add New"), ICON_NONE, "POSELIB_OT_pose_add", "frame", poselib_get_free_index(ob->poselib)); + + /* check if we have any choices to add a new pose in any other way */ + if ((ob->poselib) && (ob->poselib->markers.first)) { + /* add new (on current frame) */ + uiItemIntO(layout, IFACE_("Add New (Current Frame)"), ICON_NONE, "POSELIB_OT_pose_add", "frame", CFRA); + + /* replace existing - submenu */ + uiItemMenuF(layout, IFACE_("Replace Existing..."), 0, poselib_add_menu_invoke__replacemenu, NULL); + } + + uiPupMenuEnd(C, pup); + + /* this operator is only for a menu, not used further */ + return OPERATOR_CANCELLED; +} + + +static int poselib_add_exec(bContext *C, wmOperator *op) +{ + Object *ob = get_poselib_object(C); + bAction *act = poselib_validate(ob); + bPose *pose = (ob) ? ob->pose : NULL; + TimeMarker *marker; + KeyingSet *ks = ANIM_builtin_keyingset_get_named(NULL, ANIM_KS_WHOLE_CHARACTER_ID); /* this includes custom props :)*/ + int frame = RNA_int_get(op->ptr, "frame"); + char name[64]; + + /* sanity check (invoke should have checked this anyway) */ + if (ELEM(NULL, ob, pose)) + return OPERATOR_CANCELLED; + + /* get name to give to pose */ + RNA_string_get(op->ptr, "name", name); + + /* add pose to poselib - replaces any existing pose there + * - for the 'replace' option, this should end up finding the appropriate marker, + * so no new one will be added + */ + for (marker = act->markers.first; marker; marker = marker->next) { + if (marker->frame == frame) { + BLI_strncpy(marker->name, name, sizeof(marker->name)); + break; + } + } + if (marker == NULL) { + marker = MEM_callocN(sizeof(TimeMarker), "ActionMarker"); + + BLI_strncpy(marker->name, name, sizeof(marker->name)); + marker->frame = frame; + + BLI_addtail(&act->markers, marker); + } + + /* validate name */ + BLI_uniquename(&act->markers, marker, "Pose", '.', offsetof(TimeMarker, name), sizeof(marker->name)); + + /* use Keying Set to determine what to store for the pose */ + /* FIXME: in the past, the Keying Set respected selections (LocRotScale), but the current one doesn't + * (WholeCharacter) so perhaps we need either a new Keying Set, or just to add overrides here... */ + ANIM_apply_keyingset(C, NULL, act, ks, MODIFYKEY_MODE_INSERT, (float)frame); + + /* store new 'active' pose number */ + act->active_marker = BLI_countlist(&act->markers); + + /* done */ + return OPERATOR_FINISHED; +} + +void POSELIB_OT_pose_add(wmOperatorType *ot) +{ + /* identifiers */ + ot->name = "PoseLib Add Pose"; + ot->idname = "POSELIB_OT_pose_add"; + ot->description = "Add the current Pose to the active Pose Library"; + + /* api callbacks */ + ot->invoke = poselib_add_menu_invoke; + ot->exec = poselib_add_exec; + ot->poll = ED_operator_posemode; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + /* properties */ + RNA_def_int(ot->srna, "frame", 1, 0, INT_MAX, "Frame", "Frame to store pose on", 0, INT_MAX); + RNA_def_string(ot->srna, "name", "Pose", 64, "Pose Name", "Name of newly added Pose"); +} + +/* ----- */ + +/* can be called with C == NULL */ +static EnumPropertyItem *poselib_stored_pose_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free) +{ + Object *ob = get_poselib_object(C); + bAction *act = (ob) ? ob->poselib : NULL; + TimeMarker *marker; + EnumPropertyItem *item = NULL, item_tmp = {0}; + int totitem = 0; + int i = 0; + + if (C == NULL) { + return DummyRNA_NULL_items; + } + + /* check that the action exists */ + if (act) { + /* add each marker to the list */ + for (marker = act->markers.first, i = 0; marker; marker = marker->next, i++) { + item_tmp.identifier = item_tmp.name = marker->name; + item_tmp.icon = ICON_ARMATURE_DATA; + item_tmp.value = i; + RNA_enum_item_add(&item, &totitem, &item_tmp); + } + } + + RNA_enum_item_end(&item, &totitem); + *free = 1; + + return item; +} + +static int poselib_remove_exec(bContext *C, wmOperator *op) +{ + Object *ob = get_poselib_object(C); + bAction *act = (ob) ? ob->poselib : NULL; + TimeMarker *marker; + int marker_index; + FCurve *fcu; + PropertyRNA *prop; + + /* check if valid poselib */ + if (act == NULL) { + BKE_report(op->reports, RPT_ERROR, "Object does not have pose lib data"); + return OPERATOR_CANCELLED; + } + + prop = RNA_struct_find_property(op->ptr, "pose"); + if (RNA_property_is_set(op->ptr, prop)) { + marker_index = RNA_property_enum_get(op->ptr, prop); + } + else { + marker_index = act->active_marker - 1; + } + + /* get index (and pointer) of pose to remove */ + marker = BLI_findlink(&act->markers, marker_index); + if (marker == NULL) { + BKE_reportf(op->reports, RPT_ERROR, "Invalid pose specified %d", marker_index); + return OPERATOR_CANCELLED; + } + + /* remove relevant keyframes */ + for (fcu = act->curves.first; fcu; fcu = fcu->next) { + BezTriple *bezt; + unsigned int i; + + if (fcu->bezt) { + for (i = 0, bezt = fcu->bezt; i < fcu->totvert; i++, bezt++) { + /* check if remove */ + if (IS_EQ(bezt->vec[1][0], marker->frame)) { + delete_fcurve_key(fcu, i, 1); + break; + } + } + } + } + + /* remove poselib from list */ + BLI_freelinkN(&act->markers, marker); + + /* fix active pose number */ + act->active_marker = 0; + + /* send notifiers for this - using keyframe editing notifiers, since action + * may be being shown in anim editors as active action + */ + WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL); + + /* done */ + return OPERATOR_FINISHED; +} + +void POSELIB_OT_pose_remove(wmOperatorType *ot) +{ + PropertyRNA *prop; + + /* identifiers */ + ot->name = "PoseLib Remove Pose"; + ot->idname = "POSELIB_OT_pose_remove"; + ot->description = "Remove nth pose from the active Pose Library"; + + /* api callbacks */ + ot->invoke = WM_menu_invoke; + ot->exec = poselib_remove_exec; + ot->poll = has_poselib_pose_data_poll; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + /* properties */ + prop = RNA_def_enum(ot->srna, "pose", DummyRNA_NULL_items, 0, "Pose", "The pose to remove"); + RNA_def_enum_funcs(prop, poselib_stored_pose_itemf); + ot->prop = prop; +} + +static int poselib_rename_invoke(bContext *C, wmOperator *op, const wmEvent *event) +{ + Object *ob = get_poselib_object(C); + bAction *act = (ob) ? ob->poselib : NULL; + TimeMarker *marker; + + /* check if valid poselib */ + if (act == NULL) { + BKE_report(op->reports, RPT_ERROR, "Object does not have pose lib data"); + return OPERATOR_CANCELLED; + } + + /* get index (and pointer) of pose to remove */ + marker = BLI_findlink(&act->markers, act->active_marker - 1); + if (marker == NULL) { + BKE_report(op->reports, RPT_ERROR, "Invalid index for pose"); + return OPERATOR_CANCELLED; + } + else { + /* use the existing name of the marker as the name, and use the active marker as the one to rename */ + RNA_enum_set(op->ptr, "pose", act->active_marker - 1); + RNA_string_set(op->ptr, "name", marker->name); + } + + /* part to sync with other similar operators... */ + return WM_operator_props_popup(C, op, event); +} + +static int poselib_rename_exec(bContext *C, wmOperator *op) +{ + Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C)); + bAction *act = (ob) ? ob->poselib : NULL; + TimeMarker *marker; + char newname[64]; + + /* check if valid poselib */ + if (act == NULL) { + BKE_report(op->reports, RPT_ERROR, "Object does not have pose lib data"); + return OPERATOR_CANCELLED; + } + + /* get index (and pointer) of pose to remove */ + marker = BLI_findlink(&act->markers, RNA_enum_get(op->ptr, "pose")); + if (marker == NULL) { + BKE_report(op->reports, RPT_ERROR, "Invalid index for pose"); + return OPERATOR_CANCELLED; + } + + /* get new name */ + RNA_string_get(op->ptr, "name", newname); + + /* copy name and validate it */ + BLI_strncpy(marker->name, newname, sizeof(marker->name)); + BLI_uniquename(&act->markers, marker, "Pose", '.', offsetof(TimeMarker, name), sizeof(marker->name)); + + /* send notifiers for this - using keyframe editing notifiers, since action + * may be being shown in anim editors as active action + */ + WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL); + + /* done */ + return OPERATOR_FINISHED; +} + +void POSELIB_OT_pose_rename(wmOperatorType *ot) +{ + PropertyRNA *prop; + + /* identifiers */ + ot->name = "PoseLib Rename Pose"; + ot->idname = "POSELIB_OT_pose_rename"; + ot->description = "Rename specified pose from the active Pose Library"; + + /* api callbacks */ + ot->invoke = poselib_rename_invoke; + ot->exec = poselib_rename_exec; + ot->poll = has_poselib_pose_data_poll; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + /* properties */ + /* NOTE: name not pose is the operator's "main" property, so that it will get activated in the popup for easy renaming */ + ot->prop = RNA_def_string(ot->srna, "name", "RenamedPose", 64, "New Pose Name", "New name for pose"); + prop = RNA_def_enum(ot->srna, "pose", DummyRNA_NULL_items, 0, "Pose", "The pose to rename"); + RNA_def_enum_funcs(prop, poselib_stored_pose_itemf); +} + +/* ************************************************************* */ +/* Pose-Lib Browsing/Previewing Operator */ + +/* Simple struct for storing settings/data for use during PoseLib preview */ +typedef struct tPoseLib_PreviewData { + ListBase backups; /* tPoseLib_Backup structs for restoring poses */ + ListBase searchp; /* LinkData structs storing list of poses which match the current search-string */ + + Scene *scene; /* active scene */ + ScrArea *sa; /* active area */ + + PointerRNA rna_ptr; /* RNA-Pointer to Object 'ob' */ + Object *ob; /* object to work on */ + bArmature *arm; /* object's armature data */ + bPose *pose; /* object's pose */ + bAction *act; /* poselib to use */ + TimeMarker *marker; /* 'active' pose */ + + int selcount; /* number of selected elements to work on */ + int totcount; /* total number of elements to work on */ + + short state; /* state of main loop */ + short redraw; /* redraw/update settings during main loop */ + short flag; /* flags for various settings */ + + short search_cursor; /* position of cursor in searchstr (cursor occurs before the item at the nominated index) */ + char searchstr[64]; /* (Part of) Name to search for to filter poses that get shown */ + char searchold[64]; /* Previously set searchstr (from last loop run), so that we can detected when to rebuild searchp */ + + char headerstr[200]; /* Info-text to print in header */ +} tPoseLib_PreviewData; + +/* defines for tPoseLib_PreviewData->state values */ +enum { + PL_PREVIEW_ERROR = -1, + PL_PREVIEW_RUNNING, + PL_PREVIEW_CONFIRM, + PL_PREVIEW_CANCEL, + PL_PREVIEW_RUNONCE +}; + +/* defines for tPoseLib_PreviewData->redraw values */ +enum { + PL_PREVIEW_NOREDRAW = 0, + PL_PREVIEW_REDRAWALL, + PL_PREVIEW_REDRAWHEADER, +}; + +/* defines for tPoseLib_PreviewData->flag values */ +enum { + PL_PREVIEW_FIRSTTIME = (1 << 0), + PL_PREVIEW_SHOWORIGINAL = (1 << 1) +}; + +/* ---------------------------- */ + +/* simple struct for storing backup info */ +typedef struct tPoseLib_Backup { + struct tPoseLib_Backup *next, *prev; + + bPoseChannel *pchan; /* pose channel backups are for */ + + bPoseChannel olddata; /* copy of pose channel's old data (at start) */ + IDProperty *oldprops; /* copy (needs freeing) of pose channel's properties (at start) */ +} tPoseLib_Backup; + +/* Makes a copy of the current pose for restoration purposes - doesn't do constraints currently */ +static void poselib_backup_posecopy(tPoseLib_PreviewData *pld) +{ + bActionGroup *agrp; + bPoseChannel *pchan; + + /* for each posechannel that has an actionchannel in */ + for (agrp = pld->act->groups.first; agrp; agrp = agrp->next) { + /* try to find posechannel */ + pchan = BKE_pose_channel_find_name(pld->pose, agrp->name); + + /* backup data if available */ + if (pchan) { + tPoseLib_Backup *plb; + + /* store backup */ + plb = MEM_callocN(sizeof(tPoseLib_Backup), "tPoseLib_Backup"); + + plb->pchan = pchan; + memcpy(&plb->olddata, plb->pchan, sizeof(bPoseChannel)); + + if (pchan->prop) + plb->oldprops = IDP_CopyProperty(pchan->prop); + + BLI_addtail(&pld->backups, plb); + + /* mark as being affected */ + if ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED)) + pld->selcount++; + pld->totcount++; + } + } +} + +/* Restores original pose */ +static void poselib_backup_restore(tPoseLib_PreviewData *pld) +{ + tPoseLib_Backup *plb; + + for (plb = pld->backups.first; plb; plb = plb->next) { + /* copy most of data straight back */ + memcpy(plb->pchan, &plb->olddata, sizeof(bPoseChannel)); + + /* just overwrite values of properties from the stored copies (there should be some) */ + if (plb->oldprops) + IDP_SyncGroupValues(plb->pchan->prop, plb->oldprops); + + /* TODO: constraints settings aren't restored yet, even though these could change (though not that likely) */ + } +} + +/* Free list of backups, including any side data it may use */ +static void poselib_backup_free_data(tPoseLib_PreviewData *pld) +{ + tPoseLib_Backup *plb, *plbn; + + for (plb = pld->backups.first; plb; plb = plbn) { + plbn = plb->next; + + /* free custom data */ + if (plb->oldprops) { + IDP_FreeProperty(plb->oldprops); + MEM_freeN(plb->oldprops); + } + + /* free backup element now */ + BLI_freelinkN(&pld->backups, plb); + } +} + +/* ---------------------------- */ + +/* Applies the appropriate stored pose from the pose-library to the current pose + * - assumes that a valid object, with a poselib has been supplied + * - gets the string to print in the header + * - this code is based on the code for extract_pose_from_action in blenkernel/action.c + */ +static void poselib_apply_pose(tPoseLib_PreviewData *pld) +{ + PointerRNA *ptr = &pld->rna_ptr; + bArmature *arm = pld->arm; + bPose *pose = pld->pose; + bPoseChannel *pchan; + bAction *act = pld->act; + bActionGroup *agrp; + + KeyframeEditData ked = {{NULL}}; + KeyframeEditFunc group_ok_cb; + int frame = 1; + + /* get the frame */ + if (pld->marker) + frame = pld->marker->frame; + else + return; + + + /* init settings for testing groups for keyframes */ + group_ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAMERANGE); + ked.f1 = ((float)frame) - 0.5f; + ked.f2 = ((float)frame) + 0.5f; + + + /* start applying - only those channels which have a key at this point in time! */ + for (agrp = act->groups.first; agrp; agrp = agrp->next) { + /* check if group has any keyframes */ + if (ANIM_animchanneldata_keyframes_loop(&ked, NULL, agrp, ALE_GROUP, NULL, group_ok_cb, NULL)) { + /* has keyframe on this frame, so try to get a PoseChannel with this name */ + pchan = BKE_pose_channel_find_name(pose, agrp->name); + + if (pchan) { + short ok = 0; + + /* check if this bone should get any animation applied */ + if (pld->selcount == 0) { + /* if no bones are selected, then any bone is ok */ + ok = 1; + } + else if (pchan->bone) { + /* only ok if bone is visible and selected */ + if ((pchan->bone->flag & BONE_SELECTED) && + (pchan->bone->flag & BONE_HIDDEN_P) == 0 && + (pchan->bone->layer & arm->layer)) + { + ok = 1; + } + } + + if (ok) + animsys_evaluate_action_group(ptr, act, agrp, NULL, (float)frame); + } + } + } +} + +/* Auto-keys/tags bones affected by the pose used from the poselib */ +static void poselib_keytag_pose(bContext *C, Scene *scene, tPoseLib_PreviewData *pld) +{ + bPose *pose = pld->pose; + bPoseChannel *pchan; + bAction *act = pld->act; + bActionGroup *agrp; + + KeyingSet *ks = ANIM_get_keyingset_for_autokeying(scene, ANIM_KS_WHOLE_CHARACTER_ID); + ListBase dsources = {NULL, NULL}; + short autokey = autokeyframe_cfra_can_key(scene, &pld->ob->id); + + /* start tagging/keying */ + for (agrp = act->groups.first; agrp; agrp = agrp->next) { + /* only for selected bones unless there aren't any selected, in which case all are included */ + pchan = BKE_pose_channel_find_name(pose, agrp->name); + + if (pchan) { + if ( (pld->selcount == 0) || ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED)) ) { + if (autokey) { + /* add datasource override for the PoseChannel, to be used later */ + ANIM_relative_keyingset_add_source(&dsources, &pld->ob->id, &RNA_PoseBone, pchan); + + /* clear any unkeyed tags */ + if (pchan->bone) + pchan->bone->flag &= ~BONE_UNKEYED; + } + else { + /* add unkeyed tags */ + if (pchan->bone) + pchan->bone->flag |= BONE_UNKEYED; + } + } + } + } + + /* perform actual auto-keying now */ + if (autokey) { + /* insert keyframes for all relevant bones in one go */ + ANIM_apply_keyingset(C, &dsources, NULL, ks, MODIFYKEY_MODE_INSERT, (float)CFRA); + BLI_freelistN(&dsources); + } + + /* send notifiers for this */ + WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL); +} + +/* Apply the relevant changes to the pose */ +static void poselib_preview_apply(bContext *C, wmOperator *op) +{ + tPoseLib_PreviewData *pld = (tPoseLib_PreviewData *)op->customdata; + + /* only recalc pose (and its dependencies) if pose has changed */ + if (pld->redraw == PL_PREVIEW_REDRAWALL) { + /* don't clear pose if firsttime */ + if ((pld->flag & PL_PREVIEW_FIRSTTIME) == 0) + poselib_backup_restore(pld); + else + pld->flag &= ~PL_PREVIEW_FIRSTTIME; + + /* pose should be the right one to draw (unless we're temporarily not showing it) */ + if ((pld->flag & PL_PREVIEW_SHOWORIGINAL) == 0) { + RNA_int_set(op->ptr, "pose_index", BLI_findindex(&pld->act->markers, pld->marker)); + poselib_apply_pose(pld); + } + else + RNA_int_set(op->ptr, "pose_index", -2); /* -2 means don't apply any pose */ + + /* old optimize trick... this enforces to bypass the depgraph + * - note: code copied from transform_generics.c -> recalcData() + */ + // FIXME: shouldn't this use the builtin stuff? + if ((pld->arm->flag & ARM_DELAYDEFORM) == 0) + DAG_id_tag_update(&pld->ob->id, OB_RECALC_DATA); /* sets recalc flags */ + else + BKE_pose_where_is(pld->scene, pld->ob); + } + + /* do header print - if interactively previewing */ + if (pld->state == PL_PREVIEW_RUNNING) { + if (pld->flag & PL_PREVIEW_SHOWORIGINAL) { + BLI_strncpy(pld->headerstr, + "PoseLib Previewing Pose: [Showing Original Pose] | Use Tab to start previewing poses again", + sizeof(pld->headerstr)); + ED_area_headerprint(pld->sa, pld->headerstr); + } + else if (pld->searchstr[0]) { + char tempstr[65]; + char markern[64]; + short index; + + /* get search-string */ + index = pld->search_cursor; + + if (index >= 0 && index < sizeof(tempstr) - 1) { + memcpy(&tempstr[0], &pld->searchstr[0], index); + tempstr[index] = '|'; + memcpy(&tempstr[index + 1], &pld->searchstr[index], (sizeof(tempstr) - 1) - index); + } + else { + BLI_strncpy(tempstr, pld->searchstr, sizeof(tempstr)); + } + + /* get marker name */ + BLI_strncpy(markern, pld->marker ? pld->marker->name : "No Matches", sizeof(markern)); + + BLI_snprintf(pld->headerstr, sizeof(pld->headerstr), + "PoseLib Previewing Pose: Filter - [%s] | " + "Current Pose - \"%s\" | " + "Use ScrollWheel or PageUp/Down to change", + tempstr, markern); + ED_area_headerprint(pld->sa, pld->headerstr); + } + else { + BLI_snprintf(pld->headerstr, sizeof(pld->headerstr), + "PoseLib Previewing Pose: \"%s\" | " + "Use ScrollWheel or PageUp/Down to change", + pld->marker->name); + ED_area_headerprint(pld->sa, pld->headerstr); + } + } + + /* request drawing of view + clear redraw flag */ + WM_event_add_notifier(C, NC_OBJECT | ND_POSE, pld->ob); + pld->redraw = PL_PREVIEW_NOREDRAW; +} + +/* ---------------------------- */ + +/* This helper function is called during poselib_preview_poses to find the + * pose to preview next (after a change event) + */ +static void poselib_preview_get_next(tPoseLib_PreviewData *pld, int step) +{ + /* stop if not going anywhere, as we assume that there is a direction to move in */ + if (step == 0) + return; + + /* search-string dictates a special approach */ + if (pld->searchstr[0]) { + TimeMarker *marker; + LinkData *ld, *ldn, *ldc; + + /* free and rebuild if needed (i.e. if search-str changed) */ + if (strcmp(pld->searchstr, pld->searchold)) { + /* free list of temporary search matches */ + BLI_freelistN(&pld->searchp); + + /* generate a new list of search matches */ + for (marker = pld->act->markers.first; marker; marker = marker->next) { + /* does the name partially match? + * - don't worry about case, to make it easier for users to quickly input a name (or + * part of one), which is the whole point of this feature + */ + if (BLI_strcasestr(marker->name, pld->searchstr)) { + /* make link-data to store reference to it */ + ld = MEM_callocN(sizeof(LinkData), "PoseMatch"); + ld->data = marker; + BLI_addtail(&pld->searchp, ld); + } + } + + /* set current marker to NULL (so that we start from first) */ + pld->marker = NULL; + } + + /* check if any matches */ + if (pld->searchp.first == NULL) { + pld->marker = NULL; + return; + } + + /* find first match */ + for (ldc = pld->searchp.first; ldc; ldc = ldc->next) { + if (ldc->data == pld->marker) + break; + } + if (ldc == NULL) + ldc = pld->searchp.first; + + /* Loop through the matches in a cyclic fashion, incrementing/decrementing step as appropriate + * until step == 0. At this point, marker should be the correct marker. + */ + if (step > 0) { + for (ld = ldc; ld && step; ld = ldn, step--) + ldn = (ld->next) ? ld->next : pld->searchp.first; + } + else { + for (ld = ldc; ld && step; ld = ldn, step++) + ldn = (ld->prev) ? ld->prev : pld->searchp.last; + } + + /* set marker */ + if (ld) + pld->marker = ld->data; + } + else { + TimeMarker *marker, *next; + + /* if no marker, because we just ended searching, then set that to the start of the list */ + if (pld->marker == NULL) + pld->marker = pld->act->markers.first; + + /* Loop through the markers in a cyclic fashion, incrementing/decrementing step as appropriate + * until step == 0. At this point, marker should be the correct marker. + */ + if (step > 0) { + for (marker = pld->marker; marker && step; marker = next, step--) + next = (marker->next) ? marker->next : pld->act->markers.first; + } + else { + for (marker = pld->marker; marker && step; marker = next, step++) + next = (marker->prev) ? marker->prev : pld->act->markers.last; + } + + /* it should be fairly impossible for marker to be NULL */ + if (marker) + pld->marker = marker; + } +} + +/* specially handle events for searching */ +static void poselib_preview_handle_search(tPoseLib_PreviewData *pld, unsigned short event, char ascii) +{ + /* try doing some form of string manipulation first */ + switch (event) { + case BACKSPACEKEY: + if (pld->searchstr[0] && pld->search_cursor) { + short len = strlen(pld->searchstr); + short index = pld->search_cursor; + short i; + + for (i = index; i <= len; i++) + pld->searchstr[i - 1] = pld->searchstr[i]; + + pld->search_cursor--; + + poselib_preview_get_next(pld, 1); + pld->redraw = PL_PREVIEW_REDRAWALL; + return; + } + break; + + case DELKEY: + if (pld->searchstr[0] && pld->searchstr[1]) { + short len = strlen(pld->searchstr); + short index = pld->search_cursor; + int i; + + if (index < len) { + for (i = index; i < len; i++) + pld->searchstr[i] = pld->searchstr[i + 1]; + + poselib_preview_get_next(pld, 1); + pld->redraw = PL_PREVIEW_REDRAWALL; + return; + } + } + break; + } + + if (ascii) { + /* character to add to the string */ + short index = pld->search_cursor; + short len = (pld->searchstr[0]) ? strlen(pld->searchstr) : 0; + short i; + + if (len) { + for (i = len; i > index; i--) + pld->searchstr[i] = pld->searchstr[i - 1]; + } + else + pld->searchstr[1] = 0; + + pld->searchstr[index] = ascii; + pld->search_cursor++; + + poselib_preview_get_next(pld, 1); + pld->redraw = PL_PREVIEW_REDRAWALL; + } +} + +/* handle events for poselib_preview_poses */ +static int poselib_preview_handle_event(bContext *UNUSED(C), wmOperator *op, const wmEvent *event) +{ + tPoseLib_PreviewData *pld = op->customdata; + int ret = OPERATOR_RUNNING_MODAL; + + /* only accept 'press' event, and ignore 'release', so that we don't get double actions */ + if (ELEM(event->val, KM_PRESS, KM_NOTHING) == 0) { + //printf("PoseLib: skipping event with type '%s' and val %d\n", WM_key_event_string(event->type), event->val); + return ret; + } + + /* backup stuff that needs to occur before every operation + * - make a copy of searchstr, so that we know if cache needs to be rebuilt + */ + BLI_strncpy(pld->searchold, pld->searchstr, sizeof(pld->searchold)); + + /* if we're currently showing the original pose, only certain events are handled */ + if (pld->flag & PL_PREVIEW_SHOWORIGINAL) { + switch (event->type) { + /* exit - cancel */ + case ESCKEY: + case RIGHTMOUSE: + pld->state = PL_PREVIEW_CANCEL; + break; + + /* exit - confirm */ + case LEFTMOUSE: + case RETKEY: + case PADENTER: + case SPACEKEY: + pld->state = PL_PREVIEW_CONFIRM; + break; + + /* view manipulation */ + /* we add pass through here, so that the operators responsible for these can still run, + * even though we still maintain control (as RUNNING_MODAL flag is still set too) + */ + case PAD0: case PAD1: case PAD2: case PAD3: case PAD4: + case PAD5: case PAD6: case PAD7: case PAD8: case PAD9: + case PADPLUSKEY: case PADMINUS: + case MIDDLEMOUSE: case MOUSEMOVE: + //pld->redraw = PL_PREVIEW_REDRAWHEADER; + ret = OPERATOR_PASS_THROUGH; + break; + + /* quicky compare to original */ + case TABKEY: + pld->flag &= ~PL_PREVIEW_SHOWORIGINAL; + pld->redraw = PL_PREVIEW_REDRAWALL; + break; + } + + /* EXITS HERE... */ + return ret; + } + + /* NORMAL EVENT HANDLING... */ + /* searching takes priority over normal activity */ + switch (event->type) { + /* exit - cancel */ + case ESCKEY: + case RIGHTMOUSE: + pld->state = PL_PREVIEW_CANCEL; + break; + + /* exit - confirm */ + case LEFTMOUSE: + case RETKEY: + case PADENTER: + case SPACEKEY: + pld->state = PL_PREVIEW_CONFIRM; + break; + + /* toggle between original pose and poselib pose*/ + case TABKEY: + pld->flag |= PL_PREVIEW_SHOWORIGINAL; + pld->redraw = PL_PREVIEW_REDRAWALL; + break; + + /* change to previous pose (cyclic) */ + case PAGEUPKEY: + case WHEELUPMOUSE: + poselib_preview_get_next(pld, -1); + pld->redraw = PL_PREVIEW_REDRAWALL; + break; + + /* change to next pose (cyclic) */ + case PAGEDOWNKEY: + case WHEELDOWNMOUSE: + poselib_preview_get_next(pld, 1); + pld->redraw = PL_PREVIEW_REDRAWALL; + break; + + /* jump 5 poses (cyclic, back) */ + case DOWNARROWKEY: + poselib_preview_get_next(pld, -5); + pld->redraw = PL_PREVIEW_REDRAWALL; + break; + + /* jump 5 poses (cyclic, forward) */ + case UPARROWKEY: + poselib_preview_get_next(pld, 5); + pld->redraw = PL_PREVIEW_REDRAWALL; + break; + + /* change to next pose or searching cursor control */ + case RIGHTARROWKEY: + if (pld->searchstr[0]) { + /* move text-cursor to the right */ + if (pld->search_cursor < strlen(pld->searchstr)) + pld->search_cursor++; + pld->redraw = PL_PREVIEW_REDRAWHEADER; + } + else { + /* change to next pose (cyclic) */ + poselib_preview_get_next(pld, 1); + pld->redraw = PL_PREVIEW_REDRAWALL; + } + break; + + /* change to next pose or searching cursor control */ + case LEFTARROWKEY: + if (pld->searchstr[0]) { + /* move text-cursor to the left */ + if (pld->search_cursor) + pld->search_cursor--; + pld->redraw = PL_PREVIEW_REDRAWHEADER; + } + else { + /* change to previous pose (cyclic) */ + poselib_preview_get_next(pld, -1); + pld->redraw = PL_PREVIEW_REDRAWALL; + } + break; + + /* change to first pose or start of searching string */ + case HOMEKEY: + if (pld->searchstr[0]) { + pld->search_cursor = 0; + pld->redraw = PL_PREVIEW_REDRAWHEADER; + } + else { + /* change to first pose */ + pld->marker = pld->act->markers.first; + pld->act->active_marker = 1; + + pld->redraw = PL_PREVIEW_REDRAWALL; + } + break; + + /* change to last pose or start of searching string */ + case ENDKEY: + if (pld->searchstr[0]) { + pld->search_cursor = strlen(pld->searchstr); + pld->redraw = PL_PREVIEW_REDRAWHEADER; + } + else { + /* change to last pose */ + pld->marker = pld->act->markers.last; + pld->act->active_marker = BLI_countlist(&pld->act->markers); + + pld->redraw = PL_PREVIEW_REDRAWALL; + } + break; + + /* view manipulation */ + /* we add pass through here, so that the operators responsible for these can still run, + * even though we still maintain control (as RUNNING_MODAL flag is still set too) + */ + case MIDDLEMOUSE: case MOUSEMOVE: + //pld->redraw = PL_PREVIEW_REDRAWHEADER; + ret = OPERATOR_PASS_THROUGH; + break; + + /* view manipulation, or searching */ + case PAD0: case PAD1: case PAD2: case PAD3: case PAD4: + case PAD5: case PAD6: case PAD7: case PAD8: case PAD9: + case PADPLUSKEY: case PADMINUS: + if (pld->searchstr[0]) { + /* searching... */ + poselib_preview_handle_search(pld, event->type, event->ascii); + } + else { + /* view manipulation (see above) */ + //pld->redraw = PL_PREVIEW_REDRAWHEADER; + ret = OPERATOR_PASS_THROUGH; + } + break; + + /* otherwise, assume that searching might be able to handle it */ + default: + poselib_preview_handle_search(pld, event->type, event->ascii); + break; + } + + return ret; +} + +/* ---------------------------- */ + +/* Init PoseLib Previewing data */ +static void poselib_preview_init_data(bContext *C, wmOperator *op) +{ + tPoseLib_PreviewData *pld; + Object *ob = get_poselib_object(C); + int pose_index = RNA_int_get(op->ptr, "pose_index"); + + /* set up preview state info */ + op->customdata = pld = MEM_callocN(sizeof(tPoseLib_PreviewData), "PoseLib Preview Data"); + + /* get basic data */ + pld->ob = ob; + pld->arm = (ob) ? (ob->data) : NULL; + pld->pose = (ob) ? (ob->pose) : NULL; + pld->act = (ob) ? (ob->poselib) : NULL; + + pld->scene = CTX_data_scene(C); + pld->sa = CTX_wm_area(C); + + /* get starting pose based on RNA-props for this operator */ + if (pose_index == -1) + pld->marker = poselib_get_active_pose(pld->act); + else if (pose_index == -2) + pld->flag |= PL_PREVIEW_SHOWORIGINAL; + else + pld->marker = (pld->act) ? BLI_findlink(&pld->act->markers, pose_index) : NULL; + + /* check if valid poselib */ + if (ELEM3(NULL, pld->ob, pld->pose, pld->arm)) { + BKE_report(op->reports, RPT_ERROR, "Pose lib is only for armatures in pose mode"); + pld->state = PL_PREVIEW_ERROR; + return; + } + if (pld->act == NULL) { + BKE_report(op->reports, RPT_ERROR, "Object does not have a valid pose lib"); + pld->state = PL_PREVIEW_ERROR; + return; + } + if (pld->marker == NULL) { + if (pld->act->markers.first) { + /* just use first one then... */ + pld->marker = pld->act->markers.first; + if (pose_index > -2) + BKE_report(op->reports, RPT_WARNING, "Pose lib had no active pose"); + } + else { + BKE_report(op->reports, RPT_ERROR, "Pose lib has no poses to preview/apply"); + pld->state = PL_PREVIEW_ERROR; + return; + } + } + + /* get ID pointer for applying poses */ + RNA_id_pointer_create(&ob->id, &pld->rna_ptr); + + /* make backups for restoring pose */ + poselib_backup_posecopy(pld); + + /* set flags for running */ + pld->state = PL_PREVIEW_RUNNING; + pld->redraw = PL_PREVIEW_REDRAWALL; + pld->flag |= PL_PREVIEW_FIRSTTIME; + + /* set depsgraph flags */ + /* make sure the lock is set OK, unlock can be accidentally saved? */ + pld->pose->flag |= POSE_LOCKED; + pld->pose->flag &= ~POSE_DO_UNLOCK; + + /* clear strings + search */ + pld->headerstr[0] = pld->searchstr[0] = pld->searchold[0] = '\0'; + pld->search_cursor = 0; +} + +/* After previewing poses */ +static void poselib_preview_cleanup(bContext *C, wmOperator *op) +{ + tPoseLib_PreviewData *pld = (tPoseLib_PreviewData *)op->customdata; + Scene *scene = pld->scene; + Object *ob = pld->ob; + bPose *pose = pld->pose; + bArmature *arm = pld->arm; + bAction *act = pld->act; + TimeMarker *marker = pld->marker; + + /* redraw the header so that it doesn't show any of our stuff anymore */ + ED_area_headerprint(pld->sa, NULL); + + /* this signal does one recalc on pose, then unlocks, so ESC or edit will work */ + pose->flag |= POSE_DO_UNLOCK; + + /* clear pose if canceled */ + if (pld->state == PL_PREVIEW_CANCEL) { + poselib_backup_restore(pld); + + /* old optimize trick... this enforces to bypass the depgraph + * - note: code copied from transform_generics.c -> recalcData() + */ + if ((arm->flag & ARM_DELAYDEFORM) == 0) + DAG_id_tag_update(&ob->id, OB_RECALC_DATA); /* sets recalc flags */ + else + BKE_pose_where_is(scene, ob); + + } + else if (pld->state == PL_PREVIEW_CONFIRM) { + /* tag poses as appropriate */ + poselib_keytag_pose(C, scene, pld); + + /* change active pose setting */ + act->active_marker = BLI_findindex(&act->markers, marker) + 1; + action_set_activemarker(act, marker, NULL); + + /* Update event for pose and deformation children */ + DAG_id_tag_update(&ob->id, OB_RECALC_DATA); + + /* updates */ + if (IS_AUTOKEY_MODE(scene, NORMAL)) { + //remake_action_ipos(ob->action); + } + else + BKE_pose_where_is(scene, ob); + } + + /* free memory used for backups and searching */ + poselib_backup_free_data(pld); + BLI_freelistN(&pld->searchp); + + /* free temp data for operator */ + MEM_freeN(pld); + op->customdata = NULL; +} + +/* End previewing operation */ +static int poselib_preview_exit(bContext *C, wmOperator *op) +{ + tPoseLib_PreviewData *pld = op->customdata; + int exit_state = pld->state; + + /* finish up */ + poselib_preview_cleanup(C, op); + + if (ELEM(exit_state, PL_PREVIEW_CANCEL, PL_PREVIEW_ERROR)) + return OPERATOR_CANCELLED; + else + return OPERATOR_FINISHED; +} + +/* Cancel previewing operation (called when exiting Blender) */ +static int poselib_preview_cancel(bContext *C, wmOperator *op) +{ + poselib_preview_exit(C, op); + return OPERATOR_CANCELLED; +} + +/* main modal status check */ +static int poselib_preview_modal(bContext *C, wmOperator *op, const wmEvent *event) +{ + tPoseLib_PreviewData *pld = op->customdata; + int ret; + + /* 1) check state to see if we're still running */ + if (pld->state != PL_PREVIEW_RUNNING) + return poselib_preview_exit(C, op); + + /* 2) handle events */ + ret = poselib_preview_handle_event(C, op, event); + + /* 3) apply changes and redraw, otherwise, confirming goes wrong */ + if (pld->redraw) + poselib_preview_apply(C, op); + + return ret; +} + +/* Modal Operator init */ +static int poselib_preview_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)) +{ + tPoseLib_PreviewData *pld; + + /* check if everything is ok, and init settings for modal operator */ + poselib_preview_init_data(C, op); + pld = (tPoseLib_PreviewData *)op->customdata; + + if (pld->state == PL_PREVIEW_ERROR) { + /* an error occurred, so free temp mem used */ + poselib_preview_cleanup(C, op); + return OPERATOR_CANCELLED; + } + + /* do initial apply to have something to look at */ + poselib_preview_apply(C, op); + + /* add temp handler if we're running as a modal operator */ + WM_event_add_modal_handler(C, op); + + return OPERATOR_RUNNING_MODAL; +} + +/* Repeat operator */ +static int poselib_preview_exec(bContext *C, wmOperator *op) +{ + tPoseLib_PreviewData *pld; + + /* check if everything is ok, and init settings for modal operator */ + poselib_preview_init_data(C, op); + pld = (tPoseLib_PreviewData *)op->customdata; + + if (pld->state == PL_PREVIEW_ERROR) { + /* an error occurred, so free temp mem used */ + poselib_preview_cleanup(C, op); + return OPERATOR_CANCELLED; + } + + /* the exec() callback is effectively a 'run-once' scenario, so set the state to that + * so that everything draws correctly + */ + pld->state = PL_PREVIEW_RUNONCE; + + /* apply the active pose */ + poselib_preview_apply(C, op); + + /* now, set the status to exit */ + pld->state = PL_PREVIEW_CONFIRM; + + /* cleanup */ + return poselib_preview_exit(C, op); +} + +void POSELIB_OT_browse_interactive(wmOperatorType *ot) +{ + /* identifiers */ + ot->name = "PoseLib Browse Poses"; + ot->idname = "POSELIB_OT_browse_interactive"; + ot->description = "Interactively browse poses in 3D-View"; + + /* callbacks */ + ot->invoke = poselib_preview_invoke; + ot->modal = poselib_preview_modal; + ot->cancel = poselib_preview_cancel; + ot->exec = poselib_preview_exec; + ot->poll = has_poselib_pose_data_poll; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING; + + /* properties */ + // TODO: make the pose_index into a proper enum instead of a cryptic int... + ot->prop = RNA_def_int(ot->srna, "pose_index", -1, -2, INT_MAX, "Pose", "Index of the pose to apply (-2 for no change to pose, -1 for poselib active pose)", 0, INT_MAX); + + // XXX: percentage vs factor? + /* not used yet */ + /* RNA_def_float_factor(ot->srna, "blend_factor", 1.0f, 0.0f, 1.0f, "Blend Factor", "Amount that the pose is applied on top of the existing poses", 0.0f, 1.0f); */ +} + +void POSELIB_OT_apply_pose(wmOperatorType *ot) +{ + /* identifiers */ + ot->name = "Apply Pose Library Pose"; + ot->idname = "POSELIB_OT_apply_pose"; + ot->description = "Apply specified Pose Library pose to the rig"; + + /* callbacks */ + ot->exec = poselib_preview_exec; + ot->poll = has_poselib_pose_data_poll; + + /* flags */ + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; + + /* properties */ + /* TODO: make the pose_index into a proper enum instead of a cryptic int... */ + ot->prop = RNA_def_int(ot->srna, "pose_index", -1, -2, INT_MAX, "Pose", "Index of the pose to apply (-2 for no change to pose, -1 for poselib active pose)", 0, INT_MAX); +} |