This reference page is linked to from the following overview topics: FBX SDK 2012, FBX SDK 2011, Supported Scene Elements, Animation data structures, Migrating to the new data structures for animation, Animation classes and their interrelationships, List of Python FBX classes.

Detailed Description

An animation curve, defined by a collection of keys (KFbxAnimCurveKey), and indicating how a value changes over time.

Since an animation curve is a function, on a given animation curve, only one key per time is allowed. The keys are sorted in time order. They can be accessed by their index on the curve, from 0 to KFbxAnimCurve::KeyGetCount-1. The time unit in FBX (KTime) is 1/46186158000 of one second.

Each key defines tangents and interpolation that modify the animation curve. Tangents control the way the animation curve enters and exits the keys. Interpolation indicates the animation curve's behavior between keys.

Interpolation modes are

Constant - Curve value stays the same until next key
Linear - Animation curve is a straight line
Cubic - Animation curve is a Bezier spline

Tangent modes are

Auto (Spline cardinal)
Spline TCB (Tension, Continuity, Bias)
User (Next slope at the left equal to slope at the right)

Tangent modes can be overridden by more tangent options:

Break (Independent left and right slopes)
Clamp (Key should be flat if next or previous key has the same value)
Time independent

Tangent can be modified some more by adding weights and velocity. By default, the weights are 0.333 on either side of the key, and there is no velocity. Velocity settings speed up or slow down animation on either side of a key without changing the trajectory of the animation. Unlike Auto and Weight settings, Velocity changes the animation in time, but not in space.

Remarks:: KFbxAnimCurve is now the main animation animation curve object of the SDK. Users should always use this class to handle animation curve. This class, for the time being, encapsulates the legacy KFCurve structure. However, its implementation is subject to change.

Note:

When adding keys to an animation curve, use KFbxAnimCurve::KeyModifyBegin and KFbxAnimCurve::KeyModifyEnd. please refer to the following sample code:

 KTime lTime;
 int lKeyIndex = 0;

 // Create curve
 KFbxAnimCurve* lAnimCurve = KFbxAnimCurve::Create(pScene, "Cube Animation");

 // Add keys to the curve
 lAnimCurve->KeyModifyBegin();

 // First key: time 0, value 0
 lTime.SetSecondDouble(0.0);
 lKeyIndex = lAnimCurve->KeyAdd(lTime);
 lAnimCurve->KeySet(lKeyIndex, lTime, 0.0, KFbxAnimCurveDef::eINTERPOLATION_LINEAR);

 // Second key: time 20s, value -3600
 // Since this curve will describe rotation, each cube will rotate 10 times around itself during 20 seconds.
 lTime.SetSecondDouble(20.0);
 lKeyIndex = lAnimCurve->KeyAdd(lTime);
 lAnimCurve->KeySet(lKeyIndex, lTime, -3600, KFbxAnimCurveDef::eINTERPOLATION_LINEAR);

 // Done adding keys.
 lAnimCurve->KeyModifyEnd();

Examples:: Animation/main.cxx, ExportScene01/main.cxx, ExportScene02/main.cxx, ExportScene03/main.cxx, ExportScene04/main.cxx, ImportScene/DisplayAnimation.cxx, Instances/main.cxx, Pivot/main.cxx, UIExamples/CubeCreator/SDK_Utility.cxx, UserProperties/main.cxx, ViewScene/DrawScene.cxx, and ViewScene/SetCamera.cxx.

Definition at line 800 of file kfbxanimcurve.h.

#include <kfbxanimcurve.h>

Inheritance diagram for KFbxAnimCurve:

[legend]

List of all members.

Public Member Functions
virtual bool	Store (KFbx *pFileObject)=0
virtual bool	Retrieve (KFbx *pFileObject)=0
Protected Member Functions
	KFbxAnimCurve (KFbxSdkManager &pManager, char const *pName)
virtual void	Construct (const KFbxAnimCurveBase *pFrom)
virtual void	Destruct (bool pRecursive, bool pDependents)
Animation curve creation.
static KFbxAnimCurve *	Create (KFbxScene pContainer, char const pName)
	Create a KFbxAnimCurve.
Key management.
virtual void	ResizeKeyBuffer (int pKeyCount)=0
	Resize animation curve buffer to hold a certain number of keys.
virtual void	KeyModifyBegin ()=0
	Call this function prior to adding, removing or editing keys of an animation curve.
virtual void	KeyModifyEnd ()=0
	Call this function after adding, removing or editing keys of an animation curve.
virtual void	KeyClear ()=0
	Remove all the keys of the animation curve and free buffer memory.
virtual int	KeyGetCount () const =0
	Get the number of keys.
virtual int	KeyAdd (KTime pTime, KFbxAnimCurveKeyBase &pKey, int *pLast=NULL)=0
	Add a given key at given time.
virtual int	KeyAdd (KTime pTime, int *pLast=NULL)=0
	Add a key at given time.
virtual bool	KeySet (int pIndex, KFbxAnimCurveKeyBase &pKey)=0
	Set (or replace) key at given index with given key.
virtual bool	KeyRemove (int pIndex)=0
	Remove key at given index.
virtual bool	KeyRemove (int pStartIndex, int pEndIndex)=0
	Remove all the keys in the given range.
virtual int	KeyInsert (KTime pTime, int *pLast=NULL)=0
	Insert a key at given time.
virtual double	KeyFind (KTime pTime, int *pLast=NULL)=0
	Find key index for a given time.
virtual bool	KeyScaleValue (float pMultValue)=0
	Scale value of all keys.
virtual bool	KeyScaleValueAndTangent (float pMultValue)=0
	Scale value and tangent of all keys.
Key Manipulation
virtual void	KeySet (int pKeyIndex, KTime pTime, float pValue, KFbxAnimCurveDef::EInterpolationType pInterpolation=KFbxAnimCurveDef::eINTERPOLATION_CUBIC, KFbxAnimCurveDef::ETangentMode pTangentMode=KFbxAnimCurveDef::eTANGENT_AUTO, float pData0=0.0, float pData1=0.0, KFbxAnimCurveDef::EWeightedMode pTangentWeightMode=KFbxAnimCurveDef::eWEIGHTED_NONE, float pWeight0=KFbxAnimCurveDef::sDEFAULT_WEIGHT, float pWeight1=KFbxAnimCurveDef::sDEFAULT_WEIGHT, float pVelocity0=KFbxAnimCurveDef::sDEFAULT_VELOCITY, float pVelocity1=KFbxAnimCurveDef::sDEFAULT_VELOCITY)=0
	General function to set key properties.
virtual void	KeySetTCB (int pKeyIndex, KTime pTime, float pValue, float pData0=0.0f, float pData1=0.0f, float pData2=0.0f)=0
	Set a key with cubic interpolation, TCB tangent mode.
virtual KFbxAnimCurveDef::EInterpolationType	KeyGetInterpolation (int pKeyIndex) const =0
	Get key's interpolation type.
virtual void	KeySetInterpolation (int pKeyIndex, KFbxAnimCurveDef::EInterpolationType pInterpolation)=0
	Set key's interpolation type.
virtual KFbxAnimCurveDef::EConstantMode	KeyGetConstantMode (int pKeyIndex) const =0
	Get key's constant mode.
virtual KFbxAnimCurveDef::ETangentMode	KeyGetTangentMode (int pKeyIndex, bool pIncludeOverrides=false) const =0
	Get key's tangent mode.
virtual void	KeySetConstantMode (int pKeyIndex, KFbxAnimCurveDef::EConstantMode pMode)=0
	Set key's constant mode.
virtual void	KeySetTangentMode (int pKeyIndex, KFbxAnimCurveDef::ETangentMode pTangent)=0
	Set key's tangent mode.
virtual KFbxAnimCurveKey	KeyGet (int pIndex) const =0
	Get key at given index.
virtual float	KeyGetValue (int pKeyIndex) const =0
	Get key value.
virtual void	KeySetValue (int pKeyIndex, float pValue)=0
	Set key value.
virtual void	KeyIncValue (int pKeyIndex, float pValue)=0
	Increment key value.
virtual void	KeyMultValue (int pKeyIndex, float pValue)=0
	Multiply key value.
virtual void	KeyMultTangent (int pKeyIndex, float pValue)=0
	Multiply key tangents.
virtual KTime	KeyGetTime (int pKeyIndex) const =0
	Get key time.
virtual void	KeySetTime (int pKeyIndex, KTime pTime)=0
	Set key time.
virtual void	KeySetBreak (int pKeyIndex, bool pVal)=0
	Set or unset the tangent break.
virtual bool	KeyGetBreak (int pKeyIndex) const =0
	Get if the tangent has a break.
Key Tangent Management
virtual float	KeyGetLeftDerivative (int pIndex)=0
	Get the left derivative of a key.
virtual void	KeySetLeftDerivative (int pIndex, float pValue)=0
	Set the left derivative of a key.
virtual float	KeyGetLeftAuto (int pIndex, bool pApplyOvershootProtection=false)=0
	Get the left auto parametric of a key.
virtual KFCurveTangeantInfo	KeyGetLeftDerivativeInfo (int pIndex)=0
	Get the left derivative info (of type KFCurveTangeantInfo) of a key.
virtual void	KeySetLeftDerivativeInfo (kFCurveIndex pIndex, KFCurveTangeantInfo pValue, bool pForceDerivative=false)=0
	Set the left derivative info (of type KFCurveTangeantInfo) of a key.
virtual float	KeyGetRightDerivative (int pIndex)=0
	Get the right derivative of a key.
virtual void	KeySetRightDerivative (int pIndex, float pValue)=0
	Set the right derivative of a key.
virtual float	KeyGetRightAuto (int pIndex, bool pApplyOvershootProtection=false)=0
	Get the right auto parametric of a key.
virtual KFCurveTangeantInfo	KeyGetRightDerivativeInfo (int pIndex)=0
	Get the right derivative info (of type KFCurveTangeantInfo) of a key.
virtual void	KeySetRightDerivativeInfo (kFCurveIndex pIndex, KFCurveTangeantInfo pValue, bool pForceDerivative=false)=0
	Set the right derivative info (of type KFCurveTangeantInfo) of a key.
virtual bool	KeyIsLeftTangentWeighted (int pIndex) const =0
	Get the left tangent weight mode of a key.
virtual bool	KeyIsRightTangentWeighted (int pIndex) const =0
	Get the right tangent weight mode of a key.
virtual float	KeyGetLeftTangentWeight (int pIndex) const =0
	Get the weight value component of the left tangent of a key.
virtual float	KeyGetRightTangentWeight (int pIndex) const =0
	Get the weight value component of the right tangent of a key.
virtual void	KeySetLeftTangentWeight (int pIndex, float pWeight, bool pAdjustTan=false)=0
	Set the left tangent weight of a key.
virtual void	KeySetRightTangentWeight (int pIndex, float pWeight, bool pAdjustTan=false)=0
	Set the right tangent weight of a key.
virtual float	KeyGetLeftTangentVelocity (int pIndex) const =0
	Get the velocity value component of the left tangent of a key.
virtual float	KeyGetRightTangentVelocity (int pIndex) const =0
	Get the velocity value component of the right tangent of a key.
Evaluation and Analysis
virtual float	Evaluate (KTime pTime, int *pLast=NULL)=0
	Evaluate animation curve value at a given time.
virtual float	EvaluateIndex (double pIndex)=0
	Evaluate animation curve value at a given key index.
virtual float	EvaluateLeftDerivative (KTime pTime, int *pLast=NULL)=0
	Evaluate function left derivative at given time.
virtual float	EvaluateRightDerivative (KTime pTime, int *pLast=NULL)=0
	Evaluate function right derivative at given time.
Utility functions.
virtual bool	GetTimeInterval (KTime &pStart, KTime &pStop)=0
	Find out start and end time of the animation animation curve.
virtual bool	GetTimeInterval (KTimeSpan &pTimeInterval)=0
	Find out start and end time of the animation animation curve.
virtual KFCurve *	GetKFCurve ()=0
	Get the pointer to KFCurve.
virtual void	CopyFrom (KFbxAnimCurve &pSource, bool pWithKeys=true)=0
	Copy animation curve content into current animation curve.

Constructor & Destructor Documentation

KFbxAnimCurve	(	KFbxSdkManager &	pManager,
		char const *	pName
	)		`[protected]`

Member Function Documentation

static KFbxAnimCurve* Create	(	KFbxScene *	pContainer,
		char const *	pName
	)		`[static]`

pContainer	Scene to which the created animation curve belongs.
pName	Name of the animation curve.

virtual int KeyAdd	(	KTime	pTime,
		KFbxAnimCurveKeyBase &	pKey,
		int *	pLast = `NULL`
	)		`[pure virtual]`

pTime	Time of the new key.
pKey	Key to add.
pLast	Index of the last processed key to speed up search. If this function is called in a loop, initialize this value to 0 and let it be updated by each call.

virtual bool KeySet	(	int	pIndex,
		KFbxAnimCurveKeyBase &	pKey
	)		`[pure virtual]`

pIndex	Index of the key to be set or replaced.
pKey	New key at this index.

virtual bool KeyRemove	(	int	pStartIndex,
		int	pEndIndex
	)		`[pure virtual]`

pStartIndex	Index of the first key to remove (inclusive).
pEndIndex	Index of the last key to remove (inclusive).

virtual int KeyInsert	(	KTime	pTime,
		int *	pLast = `NULL`
	)		`[pure virtual]`

virtual double KeyFind	(	KTime	pTime,
		int *	pLast = `NULL`
	)		`[pure virtual]`

pTime	Time of the key looked for.
pLast	Index of the last processed key to speed up search. If this function is called in a loop, initialize this value to 0 and let it be updated by each call.

virtual void KeySet	(	int	pKeyIndex,
		KTime	pTime,
		float	pValue,
		KFbxAnimCurveDef::EInterpolationType	pInterpolation = `KFbxAnimCurveDef::eINTERPOLATION_CUBIC`,
		KFbxAnimCurveDef::ETangentMode	pTangentMode = `KFbxAnimCurveDef::eTANGENT_AUTO`,
		float	pData0 = `0.0`,
		float	pData1 = `0.0`,
		KFbxAnimCurveDef::EWeightedMode	pTangentWeightMode = `KFbxAnimCurveDef::eWEIGHTED_NONE`,
		float	pWeight0 = `KFbxAnimCurveDef::sDEFAULT_WEIGHT`,
		float	pWeight1 = `KFbxAnimCurveDef::sDEFAULT_WEIGHT`,
		float	pVelocity0 = `KFbxAnimCurveDef::sDEFAULT_VELOCITY`,
		float	pVelocity1 = `KFbxAnimCurveDef::sDEFAULT_VELOCITY`
	)		`[pure virtual]`

pKeyIndex	Index of the key.
pIncludeOverrides	Include override flags: Break, Clamp, Time-Independent. This method is meaningful for cubic interpolation only. Using this method for non cubic interpolated key will return unpredictable value.

virtual void KeySetTCB	(	int	pKeyIndex,
		KTime	pTime,
		float	pValue,
		float	pData0 = `0.0f`,
		float	pData1 = `0.0f`,
		float	pData2 = `0.0f`
	)		`[pure virtual]`

virtual void KeySetInterpolation	(	int	pKeyIndex,
		KFbxAnimCurveDef::EInterpolationType	pInterpolation
	)		`[pure virtual]`

pKeyIndex	Index of the key.
pInterpolation	Key interpolation type.

virtual KFbxAnimCurveDef::ETangentMode KeyGetTangentMode	(	int	pKeyIndex,
		bool	pIncludeOverrides = `false`
	)		const `[pure virtual]`

virtual void KeySetConstantMode	(	int	pKeyIndex,
		KFbxAnimCurveDef::EConstantMode	pMode
	)		`[pure virtual]`

virtual void KeySetTangentMode	(	int	pKeyIndex,
		KFbxAnimCurveDef::ETangentMode	pTangent
	)		`[pure virtual]`

virtual void KeySetValue	(	int	pKeyIndex,
		float	pValue
	)		`[pure virtual]`

virtual void KeyIncValue	(	int	pKeyIndex,
		float	pValue
	)		`[pure virtual]`

pKeyIndex	Index of the key.
pValue	Term added to the key value.

virtual void KeyMultValue	(	int	pKeyIndex,
		float	pValue
	)		`[pure virtual]`

KFbxAnimCurve Class Reference

Detailed Description

Public Member Functions

Protected Member Functions

Animation curve creation.

Key management.

Key Manipulation

Key Tangent Management

Evaluation and Analysis

Utility functions.

Constructor & Destructor Documentation

Member Function Documentation

virtual void KeyMultTangent	(	int	pKeyIndex,
		float	pValue
	)		`[pure virtual]`

virtual void KeySetTime	(	int	pKeyIndex,
		KTime	pTime
	)		`[pure virtual]`

virtual void KeySetBreak	(	int	pKeyIndex,
		bool	pVal
	)		`[pure virtual]`

pKeyIndex	Index of the key.
pVal	Break flag (`true` or `false`).

virtual void KeySetLeftDerivative	(	int	pIndex,
		float	pValue
	)		`[pure virtual]`

virtual float KeyGetLeftAuto	(	int	pIndex,
		bool	pApplyOvershootProtection = `false`
	)		`[pure virtual]`

pIndex	Index of the key.
pApplyOvershootProtection	Clamp flag (eGENERIC_CLAMP) is taken into account.

virtual void KeySetLeftDerivativeInfo	(	kFCurveIndex	pIndex,
		KFCurveTangeantInfo	pValue,
		bool	pForceDerivative = `false`
	)		`[pure virtual]`

virtual void KeySetRightDerivative	(	int	pIndex,
		float	pValue
	)		`[pure virtual]`

virtual float KeyGetRightAuto	(	int	pIndex,
		bool	pApplyOvershootProtection = `false`
	)		`[pure virtual]`