Joshua Leung
6f0de59c55
I've gone through all the Animation Editor operators, making sure they send appropriate notifiers, and that these notifiers are handled. * Added a separate category for animation-related notifiers, since the old-style ones attached to specific datatypes only was turning out to be not too feasible. * For now, the focus has been on making sure that all Animation Editors update when there have been any potentially suitable changes at all. Later on, we can filter these more carefully to only take the ones we really need (for optimisation purposes)
1837 lines
49 KiB
C
1837 lines
49 KiB
C
/**
|
|
* $Id$
|
|
*
|
|
* ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* The Original Code is: all of this file.
|
|
*
|
|
* Contributor(s): Joshua Leung
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <float.h>
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "BLI_blenlib.h"
|
|
#include "BLI_arithb.h"
|
|
|
|
#include "DNA_anim_types.h"
|
|
#include "DNA_action_types.h"
|
|
#include "DNA_armature_types.h"
|
|
#include "DNA_camera_types.h"
|
|
#include "DNA_curve_types.h"
|
|
#include "DNA_object_types.h"
|
|
#include "DNA_screen_types.h"
|
|
#include "DNA_scene_types.h"
|
|
#include "DNA_space_types.h"
|
|
#include "DNA_constraint_types.h"
|
|
#include "DNA_key_types.h"
|
|
#include "DNA_lamp_types.h"
|
|
#include "DNA_material_types.h"
|
|
#include "DNA_userdef_types.h"
|
|
#include "DNA_gpencil_types.h"
|
|
#include "DNA_windowmanager_types.h"
|
|
|
|
#include "RNA_access.h"
|
|
#include "RNA_define.h"
|
|
#include "RNA_enum_types.h"
|
|
|
|
#include "BKE_action.h"
|
|
#include "BKE_depsgraph.h"
|
|
#include "BKE_fcurve.h"
|
|
#include "BKE_key.h"
|
|
#include "BKE_material.h"
|
|
#include "BKE_nla.h"
|
|
#include "BKE_object.h"
|
|
#include "BKE_context.h"
|
|
#include "BKE_report.h"
|
|
#include "BKE_utildefines.h"
|
|
|
|
#include "UI_interface.h"
|
|
#include "UI_view2d.h"
|
|
|
|
#include "ED_anim_api.h"
|
|
#include "ED_keyframing.h"
|
|
#include "ED_keyframes_draw.h"
|
|
#include "ED_keyframes_edit.h"
|
|
#include "ED_screen.h"
|
|
#include "ED_space_api.h"
|
|
#include "ED_transform.h"
|
|
|
|
#include "WM_api.h"
|
|
#include "WM_types.h"
|
|
|
|
#include "graph_intern.h"
|
|
|
|
/* ************************************************************************** */
|
|
/* KEYFRAME-RANGE STUFF */
|
|
|
|
/* *************************** Calculate Range ************************** */
|
|
|
|
/* Get the min/max keyframes*/
|
|
/* note: it should return total boundbox, filter for selection only can be argument... */
|
|
void get_graph_keyframe_extents (bAnimContext *ac, float *xmin, float *xmax, float *ymin, float *ymax)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* get data to filter, from Dopesheet */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* set large values to try to override */
|
|
if (xmin) *xmin= 999999999.0f;
|
|
if (xmax) *xmax= -999999999.0f;
|
|
if (ymin) *ymin= 999999999.0f;
|
|
if (ymax) *ymax= -999999999.0f;
|
|
|
|
/* check if any channels to set range with */
|
|
if (anim_data.first) {
|
|
/* go through channels, finding max extents */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
AnimData *adt= ANIM_nla_mapping_get(ac, ale);
|
|
FCurve *fcu= (FCurve *)ale->key_data;
|
|
float txmin, txmax, tymin, tymax;
|
|
|
|
/* get range and apply necessary scaling before */
|
|
calc_fcurve_bounds(fcu, &txmin, &txmax, &tymin, &tymax);
|
|
|
|
if (adt) {
|
|
txmin= BKE_nla_tweakedit_remap(adt, txmin, NLATIME_CONVERT_MAP);
|
|
txmax= BKE_nla_tweakedit_remap(adt, txmax, NLATIME_CONVERT_MAP);
|
|
}
|
|
|
|
/* try to set cur using these values, if they're more extreme than previously set values */
|
|
if ((xmin) && (txmin < *xmin)) *xmin= txmin;
|
|
if ((xmax) && (txmax > *xmax)) *xmax= txmax;
|
|
if ((ymin) && (tymin < *ymin)) *ymin= tymin;
|
|
if ((ymax) && (tymax > *ymax)) *ymax= tymax;
|
|
}
|
|
|
|
/* free memory */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
else {
|
|
/* set default range */
|
|
if (ac->scene) {
|
|
if (xmin) *xmin= (float)ac->scene->r.sfra;
|
|
if (xmax) *xmax= (float)ac->scene->r.efra;
|
|
}
|
|
else {
|
|
if (xmin) *xmin= -5;
|
|
if (xmax) *xmax= 100;
|
|
}
|
|
|
|
if (ymin) *ymin= -5;
|
|
if (ymax) *ymax= 5;
|
|
}
|
|
}
|
|
|
|
/* ****************** Automatic Preview-Range Operator ****************** */
|
|
|
|
static int graphkeys_previewrange_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
Scene *scene;
|
|
float min, max;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
if (ac.scene == NULL)
|
|
return OPERATOR_CANCELLED;
|
|
else
|
|
scene= ac.scene;
|
|
|
|
/* set the range directly */
|
|
get_graph_keyframe_extents(&ac, &min, &max, NULL, NULL);
|
|
scene->r.psfra= (int)floor(min + 0.5f);
|
|
scene->r.pefra= (int)floor(max + 0.5f);
|
|
|
|
/* set notifier that things have changed */
|
|
// XXX err... there's nothing for frame ranges yet, but this should do fine too
|
|
WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_previewrange_set (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Auto-Set Preview Range";
|
|
ot->idname= "GRAPH_OT_previewrange_set";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_previewrange_exec;
|
|
ot->poll= graphop_visible_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
/* ****************** View-All Operator ****************** */
|
|
|
|
static int graphkeys_viewall_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
View2D *v2d;
|
|
float extra;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
v2d= &ac.ar->v2d;
|
|
|
|
/* set the horizontal range, with an extra offset so that the extreme keys will be in view */
|
|
get_graph_keyframe_extents(&ac, &v2d->cur.xmin, &v2d->cur.xmax, &v2d->cur.ymin, &v2d->cur.ymax);
|
|
|
|
extra= 0.1f * (v2d->cur.xmax - v2d->cur.xmin);
|
|
v2d->cur.xmin -= extra;
|
|
v2d->cur.xmax += extra;
|
|
|
|
extra= 0.1f * (v2d->cur.ymax - v2d->cur.ymin);
|
|
v2d->cur.ymin -= extra;
|
|
v2d->cur.ymax += extra;
|
|
|
|
/* do View2D syncing */
|
|
UI_view2d_sync(CTX_wm_screen(C), CTX_wm_area(C), v2d, V2D_LOCK_COPY);
|
|
|
|
/* set notifier that things have changed */
|
|
ED_area_tag_redraw(CTX_wm_area(C));
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_view_all (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "View All";
|
|
ot->idname= "GRAPH_OT_view_all";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_viewall_exec;
|
|
ot->poll= graphop_visible_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
/* ******************** Create Ghost-Curves Operator *********************** */
|
|
/* This operator samples the data of the selected F-Curves to F-Points, storing them
|
|
* as 'ghost curves' in the active Graph Editor
|
|
*/
|
|
|
|
/* Bake each F-Curve into a set of samples, and store as a ghost curve */
|
|
static void create_ghost_curves (bAnimContext *ac, int start, int end)
|
|
{
|
|
SpaceIpo *sipo= (SpaceIpo *)ac->sa->spacedata.first;
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* free existing ghost curves */
|
|
free_fcurves(&sipo->ghostCurves);
|
|
|
|
/* sanity check */
|
|
if (start >= end) {
|
|
printf("Error: Frame range for Ghost F-Curve creation is inappropriate \n");
|
|
return;
|
|
}
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through filtered data and add keys between selected keyframes on every frame */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
FCurve *fcu= (FCurve *)ale->key_data;
|
|
FCurve *gcu= MEM_callocN(sizeof(FCurve), "Ghost FCurve");
|
|
AnimData *adt= ANIM_nla_mapping_get(ac, ale);
|
|
ChannelDriver *driver= fcu->driver;
|
|
FPoint *fpt;
|
|
int cfra;
|
|
|
|
/* disable driver so that it don't muck up the sampling process */
|
|
fcu->driver= NULL;
|
|
|
|
/* create samples, but store them in a new curve
|
|
* - we cannot use fcurve_store_samples() as that will only overwrite the original curve
|
|
*/
|
|
gcu->fpt= fpt= MEM_callocN(sizeof(FPoint)*(end-start+1), "Ghost FPoint Samples");
|
|
gcu->totvert= end - start + 1;
|
|
|
|
/* use the sampling callback at 1-frame intervals from start to end frames */
|
|
for (cfra= start; cfra <= end; cfra++, fpt++) {
|
|
float cfrae= BKE_nla_tweakedit_remap(adt, cfra, NLATIME_CONVERT_UNMAP);
|
|
|
|
fpt->vec[0]= cfrae;
|
|
fpt->vec[1]= fcurve_samplingcb_evalcurve(fcu, NULL, cfrae);
|
|
}
|
|
|
|
/* set color of ghost curve
|
|
* - make the color slightly darker
|
|
*/
|
|
gcu->color[0]= fcu->color[0] - 0.07f;
|
|
gcu->color[1]= fcu->color[1] - 0.07f;
|
|
gcu->color[2]= fcu->color[2] - 0.07f;
|
|
|
|
/* store new ghost curve */
|
|
BLI_addtail(&sipo->ghostCurves, gcu);
|
|
|
|
/* restore driver */
|
|
fcu->driver= driver;
|
|
}
|
|
|
|
/* admin and redraws */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_create_ghostcurves_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
View2D *v2d;
|
|
int start, end;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* ghost curves are snapshots of the visible portions of the curves, so set range to be the visible range */
|
|
v2d= &ac.ar->v2d;
|
|
start= (int)v2d->cur.xmin;
|
|
end= (int)v2d->cur.xmax;
|
|
|
|
/* bake selected curves into a ghost curve */
|
|
create_ghost_curves(&ac, start, end);
|
|
|
|
/* update this editor only */
|
|
ED_area_tag_redraw(CTX_wm_area(C));
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_ghost_curves_create (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Create Ghost Curves";
|
|
ot->idname= "GRAPH_OT_ghost_curves_create";
|
|
ot->description= "Create snapshot (Ghosts) of selected F-Curves as background aid for active Graph Editor.";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_create_ghostcurves_exec;
|
|
ot->poll= graphop_visible_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
// todo: add props for start/end frames
|
|
}
|
|
|
|
/* ******************** Clear Ghost-Curves Operator *********************** */
|
|
/* This operator clears the 'ghost curves' for the active Graph Editor */
|
|
|
|
static int graphkeys_clear_ghostcurves_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
SpaceIpo *sipo;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
sipo= (SpaceIpo *)ac.sa->spacedata.first;
|
|
|
|
/* if no ghost curves, don't do anything */
|
|
if (sipo->ghostCurves.first == NULL)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* free ghost curves */
|
|
free_fcurves(&sipo->ghostCurves);
|
|
|
|
/* update this editor only */
|
|
ED_area_tag_redraw(CTX_wm_area(C));
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_ghost_curves_clear (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Create Ghost Curves";
|
|
ot->idname= "GRAPH_OT_ghost_curves_clear";
|
|
ot->description= "Clear F-Curve snapshots (Ghosts) for active Graph Editor.";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_clear_ghostcurves_exec;
|
|
ot->poll= ED_operator_ipo_active;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
/* ************************************************************************** */
|
|
/* GENERAL STUFF */
|
|
|
|
/* ******************** Insert Keyframes Operator ************************* */
|
|
|
|
/* defines for insert keyframes tool */
|
|
EnumPropertyItem prop_graphkeys_insertkey_types[] = {
|
|
{1, "ALL", 0, "All Channels", ""},
|
|
{2, "SEL", 0, "Only Selected Channels", ""},
|
|
{0, NULL, 0, NULL, NULL}
|
|
};
|
|
|
|
/* this function is responsible for snapping keyframes to frame-times */
|
|
static void insert_graph_keys(bAnimContext *ac, short mode)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
Scene *scene= ac->scene;
|
|
float cfra= (float)CFRA;
|
|
short flag = 0;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
if (mode == 2) filter |= ANIMFILTER_SEL;
|
|
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* init keyframing flag */
|
|
if (IS_AUTOKEY_FLAG(AUTOMATKEY)) flag |= INSERTKEY_MATRIX;
|
|
if (IS_AUTOKEY_FLAG(INSERTNEEDED)) flag |= INSERTKEY_NEEDED;
|
|
// if (IS_AUTOKEY_MODE(EDITKEYS)) flag |= INSERTKEY_REPLACE;
|
|
|
|
/* insert keyframes */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
AnimData *adt= ANIM_nla_mapping_get(ac, ale);
|
|
FCurve *fcu= (FCurve *)ale->key_data;
|
|
|
|
/* adjust current frame for NLA-mapping */
|
|
if (adt)
|
|
cfra= BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);
|
|
else
|
|
cfra= (float)CFRA;
|
|
|
|
/* if there's an id */
|
|
if (ale->id)
|
|
insert_keyframe(ale->id, NULL, ((fcu->grp)?(fcu->grp->name):(NULL)), fcu->rna_path, fcu->array_index, cfra, flag);
|
|
else
|
|
insert_vert_fcurve(fcu, cfra, fcu->curval, 0);
|
|
}
|
|
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_insertkey_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
short mode;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
if (ac.datatype == ANIMCONT_GPENCIL)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* which channels to affect? */
|
|
mode= RNA_enum_get(op->ptr, "type");
|
|
|
|
/* insert keyframes */
|
|
insert_graph_keys(&ac, mode);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_insert_keyframe (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Insert Keyframes";
|
|
ot->idname= "GRAPH_OT_insert_keyframe";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_menu_invoke;
|
|
ot->exec= graphkeys_insertkey_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* id-props */
|
|
RNA_def_enum(ot->srna, "type", prop_graphkeys_insertkey_types, 0, "Type", "");
|
|
}
|
|
|
|
/* ******************** Click-Insert Keyframes Operator ************************* */
|
|
|
|
static int graphkeys_click_insert_exec (bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
bAnimListElem *ale;
|
|
AnimData *adt;
|
|
float frame, val;
|
|
|
|
/* get animation context */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get active F-Curve 'anim-list-element' */
|
|
ale= get_active_fcurve_channel(&ac);
|
|
if (ELEM(NULL, ale, ale->data)) {
|
|
if (ale) MEM_freeN(ale);
|
|
return OPERATOR_CANCELLED;
|
|
}
|
|
|
|
/* get frame and value from props */
|
|
frame= RNA_float_get(op->ptr, "frame");
|
|
val= RNA_float_get(op->ptr, "value");
|
|
|
|
/* apply inverse NLA-mapping to frame to get correct time in un-scaled action */
|
|
adt= ANIM_nla_mapping_get(&ac, ale);
|
|
frame= BKE_nla_tweakedit_remap(adt, frame, NLATIME_CONVERT_UNMAP);
|
|
|
|
/* insert keyframe on the specified frame + value */
|
|
insert_vert_fcurve((FCurve *)ale->data, frame, val, 0);
|
|
|
|
/* free temp data */
|
|
MEM_freeN(ale);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
/* done */
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
static int graphkeys_click_insert_invoke (bContext *C, wmOperator *op, wmEvent *evt)
|
|
{
|
|
bAnimContext ac;
|
|
ARegion *ar;
|
|
View2D *v2d;
|
|
int mval[2];
|
|
float x, y;
|
|
|
|
/* get animation context */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* store mouse coordinates in View2D space, into the operator's properties */
|
|
ar= ac.ar;
|
|
v2d= &ar->v2d;
|
|
|
|
mval[0]= (evt->x - ar->winrct.xmin);
|
|
mval[1]= (evt->y - ar->winrct.ymin);
|
|
|
|
UI_view2d_region_to_view(v2d, mval[0], mval[1], &x, &y);
|
|
|
|
RNA_float_set(op->ptr, "frame", x);
|
|
RNA_float_set(op->ptr, "value", y);
|
|
|
|
/* run exec now */
|
|
return graphkeys_click_insert_exec(C, op);
|
|
}
|
|
|
|
void GRAPH_OT_click_insert (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Click-Insert Keyframes";
|
|
ot->idname= "GRAPH_OT_click_insert";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= graphkeys_click_insert_invoke;
|
|
ot->exec= graphkeys_click_insert_exec;
|
|
ot->poll= graphop_active_fcurve_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* properties */
|
|
RNA_def_float(ot->srna, "frame", 1.0f, -FLT_MAX, FLT_MAX, "Frame Number", "Frame to insert keyframe on", 0, 100);
|
|
RNA_def_float(ot->srna, "value", 1.0f, -FLT_MAX, FLT_MAX, "Value", "Value for keyframe on", 0, 100);
|
|
}
|
|
|
|
/* ******************** Copy/Paste Keyframes Operator ************************* */
|
|
/* NOTE: the backend code for this is shared with the dopesheet editor */
|
|
|
|
static short copy_graph_keys (bAnimContext *ac)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
int filter, ok=0;
|
|
|
|
/* clear buffer first */
|
|
free_anim_copybuf();
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* copy keyframes */
|
|
ok= copy_animedit_keys(ac, &anim_data);
|
|
|
|
/* clean up */
|
|
BLI_freelistN(&anim_data);
|
|
|
|
return ok;
|
|
}
|
|
|
|
static short paste_graph_keys (bAnimContext *ac)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
int filter, ok=0;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* paste keyframes */
|
|
ok= paste_animedit_keys(ac, &anim_data);
|
|
|
|
/* clean up */
|
|
BLI_freelistN(&anim_data);
|
|
|
|
return ok;
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_copy_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* copy keyframes */
|
|
if (copy_graph_keys(&ac)) {
|
|
BKE_report(op->reports, RPT_ERROR, "No keyframes copied to keyframes copy/paste buffer");
|
|
return OPERATOR_CANCELLED;
|
|
}
|
|
|
|
/* just return - no operator needed here (no changes) */
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_copy (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Copy Keyframes";
|
|
ot->idname= "GRAPH_OT_copy";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_copy_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
|
|
|
|
static int graphkeys_paste_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* paste keyframes */
|
|
if (paste_graph_keys(&ac)) {
|
|
BKE_report(op->reports, RPT_ERROR, "No keyframes to paste");
|
|
return OPERATOR_CANCELLED;
|
|
}
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_paste (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Paste Keyframes";
|
|
ot->idname= "GRAPH_OT_paste";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_paste_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
/* ******************** Duplicate Keyframes Operator ************************* */
|
|
|
|
static void duplicate_graph_keys (bAnimContext *ac)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through filtered data and delete selected keys */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
duplicate_fcurve_keys((FCurve *)ale->key_data);
|
|
}
|
|
|
|
/* free filtered list */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_duplicate_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* duplicate keyframes */
|
|
duplicate_graph_keys(&ac);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
static int graphkeys_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *event)
|
|
{
|
|
graphkeys_duplicate_exec(C, op);
|
|
|
|
RNA_int_set(op->ptr, "mode", TFM_TRANSLATION);
|
|
WM_operator_name_call(C, "TFM_OT_transform", WM_OP_INVOKE_REGION_WIN, op->ptr);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_duplicate (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Duplicate Keyframes";
|
|
ot->idname= "GRAPH_OT_duplicate";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= graphkeys_duplicate_invoke;
|
|
ot->exec= graphkeys_duplicate_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* to give to transform */
|
|
RNA_def_int(ot->srna, "mode", TFM_TRANSLATION, 0, INT_MAX, "Mode", "", 0, INT_MAX);
|
|
}
|
|
|
|
/* ******************** Delete Keyframes Operator ************************* */
|
|
|
|
static void delete_graph_keys (bAnimContext *ac)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through filtered data and delete selected keys */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
delete_fcurve_keys((FCurve *)ale->key_data); // XXX... this doesn't delete empty curves anymore
|
|
}
|
|
|
|
/* free filtered list */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_delete_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* delete keyframes */
|
|
delete_graph_keys(&ac);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_delete (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Delete Keyframes";
|
|
ot->idname= "GRAPH_OT_delete";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_operator_confirm;
|
|
ot->exec= graphkeys_delete_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
/* ******************** Clean Keyframes Operator ************************* */
|
|
|
|
static void clean_graph_keys (bAnimContext *ac, float thresh)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_SEL | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through filtered data and clean curves */
|
|
for (ale= anim_data.first; ale; ale= ale->next)
|
|
clean_fcurve((FCurve *)ale->key_data, thresh);
|
|
|
|
/* free temp data */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_clean_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
float thresh;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get cleaning threshold */
|
|
thresh= RNA_float_get(op->ptr, "threshold");
|
|
|
|
/* clean keyframes */
|
|
clean_graph_keys(&ac, thresh);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_clean (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Clean Keyframes";
|
|
ot->idname= "GRAPH_OT_clean";
|
|
|
|
/* api callbacks */
|
|
//ot->invoke= // XXX we need that number popup for this!
|
|
ot->exec= graphkeys_clean_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* properties */
|
|
RNA_def_float(ot->srna, "threshold", 0.001f, 0.0f, FLT_MAX, "Threshold", "", 0.0f, 1000.0f);
|
|
}
|
|
|
|
/* ******************** Bake F-Curve Operator *********************** */
|
|
/* This operator bakes the data of the selected F-Curves to F-Points */
|
|
|
|
/* Bake each F-Curve into a set of samples */
|
|
static void bake_graph_curves (bAnimContext *ac, int start, int end)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_SEL | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through filtered data and add keys between selected keyframes on every frame */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
FCurve *fcu= (FCurve *)ale->key_data;
|
|
ChannelDriver *driver= fcu->driver;
|
|
|
|
/* disable driver so that it don't muck up the sampling process */
|
|
fcu->driver= NULL;
|
|
|
|
/* create samples */
|
|
fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
|
|
|
|
/* restore driver */
|
|
fcu->driver= driver;
|
|
}
|
|
|
|
/* admin and redraws */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_bake_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
Scene *scene= NULL;
|
|
int start, end;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* for now, init start/end from preview-range extents */
|
|
// TODO: add properties for this
|
|
scene= ac.scene;
|
|
start= PSFRA;
|
|
end= PEFRA;
|
|
|
|
/* bake keyframes */
|
|
bake_graph_curves(&ac, start, end);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
// NOTE: some distinction between order/number of keyframes and type should be made?
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_bake (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Bake Curve";
|
|
ot->idname= "GRAPH_OT_bake";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_operator_confirm; // FIXME...
|
|
ot->exec= graphkeys_bake_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
// todo: add props for start/end frames
|
|
}
|
|
|
|
/* ******************** Sample Keyframes Operator *********************** */
|
|
/* This operator 'bakes' the values of the curve into new keyframes between pairs
|
|
* of selected keyframes. It is useful for creating keyframes for tweaking overlap.
|
|
*/
|
|
|
|
// XXX some of the common parts (with DopeSheet) should be unified in animation module...
|
|
|
|
/* little cache for values... */
|
|
typedef struct tempFrameValCache {
|
|
float frame, val;
|
|
} tempFrameValCache;
|
|
|
|
/* Evaluates the curves between each selected keyframe on each frame, and keys the value */
|
|
static void sample_graph_keys (bAnimContext *ac)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through filtered data and add keys between selected keyframes on every frame */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
FCurve *fcu= (FCurve *)ale->key_data;
|
|
BezTriple *bezt, *start=NULL, *end=NULL;
|
|
tempFrameValCache *value_cache, *fp;
|
|
int sfra, range;
|
|
int i, n;
|
|
|
|
/* find selected keyframes... once pair has been found, add keyframes */
|
|
for (i=0, bezt=fcu->bezt; i < fcu->totvert; i++, bezt++) {
|
|
/* check if selected, and which end this is */
|
|
if (BEZSELECTED(bezt)) {
|
|
if (start) {
|
|
/* set end */
|
|
end= bezt;
|
|
|
|
/* cache values then add keyframes using these values, as adding
|
|
* keyframes while sampling will affect the outcome...
|
|
*/
|
|
range= (int)( ceil(end->vec[1][0] - start->vec[1][0]) );
|
|
sfra= (int)( floor(start->vec[1][0]) );
|
|
|
|
if (range) {
|
|
value_cache= MEM_callocN(sizeof(tempFrameValCache)*range, "IcuFrameValCache");
|
|
|
|
/* sample values */
|
|
for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
|
|
fp->frame= (float)(sfra + n);
|
|
fp->val= evaluate_fcurve(fcu, fp->frame);
|
|
}
|
|
|
|
/* add keyframes with these */
|
|
for (n=0, fp=value_cache; n<range && fp; n++, fp++) {
|
|
insert_vert_fcurve(fcu, fp->frame, fp->val, 1);
|
|
}
|
|
|
|
/* free temp cache */
|
|
MEM_freeN(value_cache);
|
|
|
|
/* as we added keyframes, we need to compensate so that bezt is at the right place */
|
|
bezt = fcu->bezt + i + range - 1;
|
|
i += (range - 1);
|
|
}
|
|
|
|
/* bezt was selected, so it now marks the start of a whole new chain to search */
|
|
start= bezt;
|
|
end= NULL;
|
|
}
|
|
else {
|
|
/* just set start keyframe */
|
|
start= bezt;
|
|
end= NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* recalculate channel's handles? */
|
|
calchandles_fcurve(fcu);
|
|
}
|
|
|
|
/* admin and redraws */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_sample_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* sample keyframes */
|
|
sample_graph_keys(&ac);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_sample (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Sample Keyframes";
|
|
ot->idname= "GRAPH_OT_sample";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_sample_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
|
|
/* ************************************************************************** */
|
|
/* SETTINGS STUFF */
|
|
|
|
/* ******************** Set Extrapolation-Type Operator *********************** */
|
|
|
|
/* defines for set extrapolation-type for selected keyframes tool */
|
|
EnumPropertyItem prop_graphkeys_expo_types[] = {
|
|
{FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
|
|
{FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
|
|
{0, NULL, 0, NULL, NULL}
|
|
};
|
|
|
|
/* this function is responsible for setting extrapolation mode for keyframes */
|
|
static void setexpo_graph_keys(bAnimContext *ac, short mode)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through setting mode per F-Curve */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
FCurve *fcu= (FCurve *)ale->data;
|
|
fcu->extend= mode;
|
|
}
|
|
|
|
/* cleanup */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_expo_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
short mode;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get handle setting mode */
|
|
mode= RNA_enum_get(op->ptr, "type");
|
|
|
|
/* set handle type */
|
|
setexpo_graph_keys(&ac, mode);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframe properties have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_extrapolation_type (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Set Keyframe Extrapolation";
|
|
ot->idname= "GRAPH_OT_extrapolation_type";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_menu_invoke;
|
|
ot->exec= graphkeys_expo_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* id-props */
|
|
RNA_def_enum(ot->srna, "type", prop_graphkeys_expo_types, 0, "Type", "");
|
|
}
|
|
|
|
/* ******************** Set Interpolation-Type Operator *********************** */
|
|
|
|
/* this function is responsible for setting interpolation mode for keyframes */
|
|
static void setipo_graph_keys(bAnimContext *ac, short mode)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
BeztEditFunc set_cb= ANIM_editkeyframes_ipo(mode);
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through setting BezTriple interpolation
|
|
* Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
|
|
*/
|
|
for (ale= anim_data.first; ale; ale= ale->next)
|
|
ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
|
|
|
|
/* cleanup */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_ipo_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
short mode;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get handle setting mode */
|
|
mode= RNA_enum_get(op->ptr, "type");
|
|
|
|
/* set handle type */
|
|
setipo_graph_keys(&ac, mode);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframe properties have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_interpolation_type (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Set Keyframe Interpolation";
|
|
ot->idname= "GRAPH_OT_interpolation_type";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_menu_invoke;
|
|
ot->exec= graphkeys_ipo_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* id-props */
|
|
RNA_def_enum(ot->srna, "type", beztriple_interpolation_mode_items, 0, "Type", "");
|
|
}
|
|
|
|
/* ******************** Set Handle-Type Operator *********************** */
|
|
|
|
/* this function is responsible for setting handle-type of selected keyframes */
|
|
static void sethandles_graph_keys(bAnimContext *ac, short mode)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
BeztEditFunc set_cb= ANIM_editkeyframes_handles(mode);
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* loop through setting flags for handles
|
|
* Note: we do not supply BeztEditData to the looper yet. Currently that's not necessary here...
|
|
*/
|
|
// XXX we might need to supply BeztEditData to get it to only affect selected handles
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
if (mode == -1) {
|
|
BeztEditFunc toggle_cb;
|
|
|
|
/* check which type of handle to set (free or aligned)
|
|
* - check here checks for handles with free alignment already
|
|
*/
|
|
if (ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, NULL))
|
|
toggle_cb= ANIM_editkeyframes_handles(HD_FREE);
|
|
else
|
|
toggle_cb= ANIM_editkeyframes_handles(HD_ALIGN);
|
|
|
|
/* set handle-type */
|
|
ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, toggle_cb, calchandles_fcurve);
|
|
}
|
|
else {
|
|
/* directly set handle-type */
|
|
ANIM_fcurve_keys_bezier_loop(NULL, ale->key_data, NULL, set_cb, calchandles_fcurve);
|
|
}
|
|
}
|
|
|
|
/* cleanup */
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_handletype_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
short mode;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get handle setting mode */
|
|
mode= RNA_enum_get(op->ptr, "type");
|
|
|
|
/* set handle type */
|
|
sethandles_graph_keys(&ac, mode);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that things have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_handletype (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Set Keyframe Handle Type";
|
|
ot->idname= "GRAPH_OT_handletype";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_menu_invoke;
|
|
ot->exec= graphkeys_handletype_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* id-props */
|
|
RNA_def_enum(ot->srna, "type", beztriple_handle_type_items, 0, "Type", "");
|
|
}
|
|
|
|
/* ************************************************************************** */
|
|
/* TRANSFORM STUFF */
|
|
|
|
/* ***************** 'Euler Filter' Operator **************************** */
|
|
/* Euler filter tools (as seen in Maya), are necessary for working with 'baked'
|
|
* rotation curves (with Euler rotations). The main purpose of such tools is to
|
|
* resolve any discontinuities that may arise in the curves due to the clamping
|
|
* of values to -180 degrees to 180 degrees.
|
|
*/
|
|
|
|
#if 0 // XXX this is not ready for the primetime yet
|
|
|
|
/* set of three euler-rotation F-Curves */
|
|
typedef struct tEulerFilter {
|
|
ID *id; /* ID-block which owns the channels */
|
|
FCurve *fcu1, *fcu2, *fcu3; /* x,y,z rotation curves */
|
|
int i1, i2, i3; /* current index for each curve */
|
|
} tEulerFilter;
|
|
|
|
static int graphkeys_euler_filter_exec (bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
|
|
ListBase anim_data= {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
ListBase eulers = {NULL, NULL};
|
|
tEulerFilter *euf= NULL;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* The process is done in two passes:
|
|
* 1) Sets of three related rotation curves are identified from the selected channels,
|
|
* and are stored as a single 'operation unit' for the next step
|
|
* 2) Each set of three F-Curves is processed for each keyframe, with the values being
|
|
* processed according to one of several ways.
|
|
*/
|
|
|
|
/* step 1: extract only the rotation f-curves */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
|
|
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
FCurve *fcu = (FCurve *)ale->data;
|
|
|
|
/* check if this is an appropriate F-Curve
|
|
* - only rotation curves
|
|
* - for pchan curves, make sure we're only using the euler curves
|
|
*/
|
|
if (ELEM(0, fcu->rna_path, strstr(fcu->rna_path, "rotation")))
|
|
continue;
|
|
if (strstr(fcu->rna_path, "pose.pose_channels")) {
|
|
if (strstr(fcu->rna_path, "euler_rotation") == 0)
|
|
continue;
|
|
}
|
|
|
|
/* check if current set of 3-curves is suitable to add this curve to
|
|
* - things like whether the current set of curves is 'full' should be checked later only
|
|
* - first check if id-blocks are compatible
|
|
*/
|
|
if ((euf) && (ale->id != euf->id)) {
|
|
|
|
}
|
|
}
|
|
|
|
// XXX for now
|
|
return OPERATOR_CANCELLED;
|
|
}
|
|
|
|
void GRAPH_OT_euler_filter (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Euler Filter";
|
|
ot->idname= "GRAPH_OT_euler_filter";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_euler_filter_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
#endif // XXX this is not ready for the primetime yet
|
|
|
|
/* ***************** Jump to Selected Frames Operator *********************** */
|
|
|
|
/* snap current-frame indicator to 'average time' of selected keyframe */
|
|
static int graphkeys_framejump_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
ListBase anim_data= {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
BeztEditData bed;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* init edit data */
|
|
memset(&bed, 0, sizeof(BeztEditData));
|
|
|
|
/* loop over action data, averaging values */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
|
|
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
AnimData *adt= ANIM_nla_mapping_get(&ac, ale);
|
|
|
|
if (adt) {
|
|
ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
|
|
ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
|
|
ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
|
|
}
|
|
else
|
|
ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, bezt_calc_average, NULL);
|
|
|
|
}
|
|
|
|
BLI_freelistN(&anim_data);
|
|
|
|
/* set the new current frame value, based on the average time */
|
|
if (bed.i1) {
|
|
Scene *scene= ac.scene;
|
|
CFRA= (int)floor((bed.f1 / bed.i1) + 0.5f);
|
|
}
|
|
|
|
/* set notifier that things have changed */
|
|
WM_event_add_notifier(C, NC_SCENE|ND_FRAME, ac.scene);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_frame_jump (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Jump to Frame";
|
|
ot->idname= "GRAPH_OT_frame_jump";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_framejump_exec;
|
|
ot->poll= graphop_visible_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
/* ******************** Snap Keyframes Operator *********************** */
|
|
|
|
/* defines for snap keyframes tool */
|
|
EnumPropertyItem prop_graphkeys_snap_types[] = {
|
|
{GRAPHKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
|
|
{GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
|
|
{GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
|
|
{GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
|
|
{GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", 0, "Flatten Handles", ""},
|
|
{0, NULL, 0, NULL, NULL}
|
|
};
|
|
|
|
/* this function is responsible for snapping keyframes to frame-times */
|
|
static void snap_graph_keys(bAnimContext *ac, short mode)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
BeztEditData bed;
|
|
BeztEditFunc edit_cb;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* get beztriple editing callbacks */
|
|
edit_cb= ANIM_editkeyframes_snap(mode);
|
|
|
|
memset(&bed, 0, sizeof(BeztEditData));
|
|
bed.scene= ac->scene;
|
|
if (mode == GRAPHKEYS_SNAP_NEAREST_MARKER) {
|
|
bed.list.first= (ac->markers) ? ac->markers->first : NULL;
|
|
bed.list.last= (ac->markers) ? ac->markers->last : NULL;
|
|
}
|
|
|
|
/* snap keyframes */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
AnimData *adt= ANIM_nla_mapping_get(ac, ale);
|
|
|
|
if (adt) {
|
|
ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
|
|
ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
|
|
ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
|
|
}
|
|
else
|
|
ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
|
|
}
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_snap_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
short mode;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get snapping mode */
|
|
mode= RNA_enum_get(op->ptr, "type");
|
|
|
|
/* snap keyframes */
|
|
snap_graph_keys(&ac, mode);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_snap (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Snap Keys";
|
|
ot->idname= "GRAPH_OT_snap";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_menu_invoke;
|
|
ot->exec= graphkeys_snap_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* id-props */
|
|
RNA_def_enum(ot->srna, "type", prop_graphkeys_snap_types, 0, "Type", "");
|
|
}
|
|
|
|
/* ******************** Mirror Keyframes Operator *********************** */
|
|
|
|
/* defines for mirror keyframes tool */
|
|
EnumPropertyItem prop_graphkeys_mirror_types[] = {
|
|
{GRAPHKEYS_MIRROR_CFRA, "CFRA", 0, "By Times over Current frame", ""},
|
|
{GRAPHKEYS_MIRROR_YAXIS, "YAXIS", 0, "By Times over Time=0", ""},
|
|
{GRAPHKEYS_MIRROR_XAXIS, "XAXIS", 0, "By Values over Value=0", ""},
|
|
{GRAPHKEYS_MIRROR_MARKER, "MARKER", 0, "By Times over First Selected Marker", ""},
|
|
{0, NULL, 0, NULL, NULL}
|
|
};
|
|
|
|
/* this function is responsible for mirroring keyframes */
|
|
static void mirror_graph_keys(bAnimContext *ac, short mode)
|
|
{
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
BeztEditData bed;
|
|
BeztEditFunc edit_cb;
|
|
|
|
/* get beztriple editing callbacks */
|
|
edit_cb= ANIM_editkeyframes_mirror(mode);
|
|
|
|
memset(&bed, 0, sizeof(BeztEditData));
|
|
bed.scene= ac->scene;
|
|
|
|
/* for 'first selected marker' mode, need to find first selected marker first! */
|
|
// XXX should this be made into a helper func in the API?
|
|
if (mode == GRAPHKEYS_MIRROR_MARKER) {
|
|
TimeMarker *marker= NULL;
|
|
|
|
/* find first selected marker */
|
|
if (ac->markers) {
|
|
for (marker= ac->markers->first; marker; marker=marker->next) {
|
|
if (marker->flag & SELECT) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* store marker's time (if available) */
|
|
if (marker)
|
|
bed.f1= (float)marker->frame;
|
|
else
|
|
return;
|
|
}
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);
|
|
|
|
/* mirror keyframes */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
AnimData *adt= ANIM_nla_mapping_get(ac, ale);
|
|
|
|
if (adt) {
|
|
ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);
|
|
ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
|
|
ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);
|
|
}
|
|
else
|
|
ANIM_fcurve_keys_bezier_loop(&bed, ale->key_data, NULL, edit_cb, calchandles_fcurve);
|
|
}
|
|
BLI_freelistN(&anim_data);
|
|
}
|
|
|
|
/* ------------------- */
|
|
|
|
static int graphkeys_mirror_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
short mode;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get mirroring mode */
|
|
mode= RNA_enum_get(op->ptr, "type");
|
|
|
|
/* mirror keyframes */
|
|
mirror_graph_keys(&ac, mode);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_mirror (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Mirror Keys";
|
|
ot->idname= "GRAPH_OT_mirror";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= WM_menu_invoke;
|
|
ot->exec= graphkeys_mirror_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* id-props */
|
|
RNA_def_enum(ot->srna, "type", prop_graphkeys_mirror_types, 0, "Type", "");
|
|
}
|
|
|
|
/* ******************** Smooth Keyframes Operator *********************** */
|
|
|
|
static int graphkeys_smooth_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
ListBase anim_data = {NULL, NULL};
|
|
bAnimListElem *ale;
|
|
int filter;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* filter data */
|
|
filter= (ANIMFILTER_VISIBLE | ANIMFILTER_CURVEVISIBLE| ANIMFILTER_FOREDIT | ANIMFILTER_CURVESONLY);
|
|
ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
|
|
|
|
/* smooth keyframes */
|
|
for (ale= anim_data.first; ale; ale= ale->next) {
|
|
/* For now, we can only smooth by flattening handles AND smoothing curve values.
|
|
* Perhaps the mode argument could be removed, as that functionality is offerred through
|
|
* Snap->Flatten Handles anyway.
|
|
*/
|
|
smooth_fcurve(ale->key_data);
|
|
}
|
|
BLI_freelistN(&anim_data);
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that keyframes have changed */
|
|
WM_event_add_notifier(C, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_smooth (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Smooth Keys";
|
|
ot->idname= "GRAPH_OT_smooth";
|
|
|
|
/* api callbacks */
|
|
ot->exec= graphkeys_smooth_exec;
|
|
ot->poll= graphop_editable_keyframes_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
}
|
|
|
|
/* ************************************************************************** */
|
|
/* F-CURVE MODIFIERS */
|
|
|
|
/* ******************** Add F-Modifier Operator *********************** */
|
|
|
|
/* present a special customised popup menu for this, with some filtering */
|
|
static int graph_fmodifier_add_invoke (bContext *C, wmOperator *op, wmEvent *event)
|
|
{
|
|
uiPopupMenu *pup;
|
|
uiLayout *layout;
|
|
int i;
|
|
|
|
pup= uiPupMenuBegin(C, "Add F-Curve Modifier", 0);
|
|
layout= uiPupMenuLayout(pup);
|
|
|
|
/* start from 1 to skip the 'Invalid' modifier type */
|
|
for (i = 1; i < FMODIFIER_NUM_TYPES; i++) {
|
|
FModifierTypeInfo *fmi= get_fmodifier_typeinfo(i);
|
|
|
|
/* check if modifier is valid for this context */
|
|
if (fmi == NULL)
|
|
continue;
|
|
|
|
/* add entry to add this type of modifier */
|
|
uiItemEnumO(layout, fmi->name, 0, "GRAPH_OT_fmodifier_add", "type", i);
|
|
}
|
|
uiItemS(layout);
|
|
|
|
uiPupMenuEnd(C, pup);
|
|
|
|
return OPERATOR_CANCELLED;
|
|
}
|
|
|
|
static int graph_fmodifier_add_exec(bContext *C, wmOperator *op)
|
|
{
|
|
bAnimContext ac;
|
|
bAnimListElem *ale;
|
|
FCurve *fcu;
|
|
FModifier *fcm;
|
|
short type;
|
|
|
|
/* get editor data */
|
|
if (ANIM_animdata_get_context(C, &ac) == 0)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
// xxx call the raw methods here instead?
|
|
ale= get_active_fcurve_channel(&ac);
|
|
if (ale == NULL)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
fcu= (FCurve *)ale->data;
|
|
MEM_freeN(ale);
|
|
if (fcu == NULL)
|
|
return OPERATOR_CANCELLED;
|
|
|
|
/* get type of modifier to add */
|
|
type= RNA_enum_get(op->ptr, "type");
|
|
|
|
/* add F-Modifier of specified type to active F-Curve, and make it the active one */
|
|
fcm= add_fmodifier(&fcu->modifiers, type);
|
|
if (fcm)
|
|
set_active_fmodifier(&fcu->modifiers, fcm);
|
|
else {
|
|
BKE_report(op->reports, RPT_ERROR, "Modifier couldn't be added. See console for details.");
|
|
return OPERATOR_CANCELLED;
|
|
}
|
|
|
|
/* validate keyframes after editing */
|
|
ANIM_editkeyframes_refresh(&ac);
|
|
|
|
/* set notifier that things have changed */
|
|
// FIXME: this really isn't the best description for it...
|
|
WM_event_add_notifier(C, NC_ANIMATION, NULL);
|
|
|
|
return OPERATOR_FINISHED;
|
|
}
|
|
|
|
void GRAPH_OT_fmodifier_add (wmOperatorType *ot)
|
|
{
|
|
/* identifiers */
|
|
ot->name= "Add F-Curve Modifier";
|
|
ot->idname= "GRAPH_OT_fmodifier_add";
|
|
|
|
/* api callbacks */
|
|
ot->invoke= graph_fmodifier_add_invoke;
|
|
ot->exec= graph_fmodifier_add_exec;
|
|
ot->poll= graphop_active_fcurve_poll;
|
|
|
|
/* flags */
|
|
ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
|
|
|
|
/* id-props */
|
|
RNA_def_enum(ot->srna, "type", fmodifier_type_items, 0, "Type", "");
|
|
}
|
|
|
|
/* ************************************************************************** */
|