Detailed Description

The FCurve (function curve) class provides access to a set of functions for getting and setting Softimage fcurve attributes, as well as creating, retrieving, modifying and deleting fcurve keys.

FCurves can be created and connected to parameters using the Parameter::AddFCurve function. FCurves are supported by the following parameter types: siBool, siDouble, siFloat, siInt4, siInt2, siByte, siByte, siUInt4, siUInt2 and siUByte (see siVariantType for definitions of these types).

Note:: For more information on interpolation and extrapolation in Softimage, see dev_animation_FCurveInterpolationAndExtrapolation FCurve Interpolation and Extrapolation

See also:: Parameter::GetSource, FCurveKey, dev_FCurves About FCurves

Example:

        using namespace XSI;
        Application app;
        Model root = app.GetActiveSceneRoot();

        X3DObject myCube;
        root.AddGeometry( L"Cube", L"MeshSurface", L"", myCube );

        // create and connect an fcurve to the position x
        Parameter posx( myCube.GetParameter(L"posx") );

        FCurve fcrv;
        posx.AddFCurve( siUnknownFCurve, fcrv );

        // show the new fcurve type
        siFCurveType fcrvType = fcrv.GetFCurveType();

        CString strFcrvType;

        switch ( fcrvType )
        {
            case siUnknownFCurve: strFcrvType = L"siUnknownFCurve"; break;
            case siBooleanFCurve: strFcrvType = L"siBooleanFCurve"; break;
            case siIntegerFCurve: strFcrvType = L"siIntegerFCurve"; break;
            case siStandardFCurve: strFcrvType = L"siStandardFCurve"; break;
            case siRawDataFCurve: strFcrvType = L"siRawDataFCurve"; break;
            default:
                strFcrvType = L"Invalid FCurve type";
        }

        app.LogMessage( L"FCurve type : " + strFcrvType );

#include <xsi_fcurve.h>

Inheritance diagram for FCurve:

[legend]

List of all members.

Public Member Functions
	FCurve ()
	~FCurve ()
	FCurve (const CRef &in_ref)
	FCurve (const FCurve &in_obj)
bool	IsA (siClassID in_ClassID) const
siClassID	GetClassID () const
FCurve &	operator= (const FCurve &in_obj)
FCurve &	operator= (const CRef &in_ref)
CValue::DataType	GetValueType () const
siFCurveType	GetFCurveType (void) const
CStatus	PutFCurveType (siFCurveType in_type)
bool	GetLocked (void) const
CStatus	PutLocked (bool in_value)
bool	GetDependsOnFrameRate (void) const
CStatus	PutDependsOnFrameRate (bool in_value)
CValue	GetNoKeyValue (void) const
CStatus	PutNoKeyValue (const CValue &in_value)
siFCurveExtrapolation	GetExtrapolation (void) const
CStatus	PutExtrapolation (siFCurveExtrapolation in_type)
siFCurveInterpolation	GetInterpolation (void) const
CStatus	PutInterpolation (siFCurveInterpolation in_type)
CValue	GetLowClamp (void) const
CStatus	PutLowClamp (const CValue &in_value)
CValue	GetHighClamp (void) const
CStatus	PutHighClamp (const CValue &in_value)
CValue	Eval (const CTime &in_frame) const
CValue	Eval (const double &in_frame) const
CFCurveKeyRefArray	GetKeys (void) const
CFCurveKeyRefArray	GetKeysBetween (const CTime &in_startframe=CTime(DBL_MAX, CTime::CUSTOM), const CTime &in_endframe=CTime(DBL_MAX, CTime::CUSTOM)) const
bool	GetSelected (void) const
CFCurveKeyRefArray	GetSelectedKeys () const
CStatus	SetKeys (const CTimeArray &in_timearray, const CValueArray &in_valuearray, bool in_keepexistingkeys=false)
CStatus	SetKeys (const CTimeArray &in_timearray, const CDoubleArray &in_valuearray, const CLongArray &in_keyinterpolationarray, const CTimeArray &in_lefttanxarray=CTimeArray(), const CDoubleArray &in_lefttanyarray=CDoubleArray(), const CTimeArray &in_righttanxarray=CTimeArray(), const CDoubleArray &in_righttanyarray=CDoubleArray(), bool in_keepexistingkeys=false)
CStatus	SetKeyTangents (const CDoubleArray &in_array)
bool	GetSI3DStyle (void) const
CStatus	PutSI3DStyle (bool in_value)
LONG	AddKey (const CTime &in_frame, const CValue &in_value, siFCurveKeyInterpolation in_interp=siDefaultKeyInterpolation, double in_ltx=DBL_MAX, double in_lty=DBL_MAX, double in_rtx=DBL_MAX, double in_rty=DBL_MAX, double in_tol=DBL_MAX, bool in_okl=false)
CStatus	Resample (const CTime &in_startframe=CTime(DBL_MAX, CTime::CUSTOM), const CTime &in_endframe=CTime(DBL_MAX, CTime::CUSTOM), double in_step=1, bool in_keepexistingkeys=false, bool in_overridekeylock=false)
CStatus	Smooth (const CTime &in_start=CTime(DBL_MAX, CTime::CUSTOM), const CTime &in_end=CTime(DBL_MAX, CTime::CUSTOM), double in_dFilterSize=5, double in_dSamplingStep=1, siFCurveSmoothFilterType in_filterType=siFCurveAverageFilterType, double in_dGaussianVariance=1)
CStatus	Fit (const CTime &in_start=CTime(DBL_MAX, CTime::CUSTOM), const CTime &in_end=CTime(DBL_MAX, CTime::CUSTOM), double in_dFittingTolerance=0.1)
CStatus	Set (const FCurve &in_fcurve)
CStatus	RemoveKey (const CTime &in_frame, double in_tolerance=DBL_MAX, bool in_overridekeylock=false)
CStatus	RemoveKeyAtIndex (LONG in_index, bool in_overridekeylock=false)
CStatus	RemoveKeysAtIndex (LONG in_index, LONG in_count, bool in_overridekeylock=false)
LONG	RemoveKeys (const CTime &in_startframe=CTime(DBL_MAX, CTime::CUSTOM), const CTime &in_endframe=CTime(DBL_MAX, CTime::CUSTOM), bool in_overridekeylock=false)
bool	KeyExists (const CTime &in_frame, double in_tolerance=DBL_MAX) const
FCurveKey	GetKey (const CTime &in_frame, double in_tolerance=DBL_MAX) const
LONG	GetNumKeys (const CTime &in_startframe=CTime(DBL_MAX, CTime::CUSTOM), const CTime &in_endframe=CTime(DBL_MAX, CTime::CUSTOM)) const
FCurveKey	GetKeyAtIndex (LONG in_index) const
LONG	GetKeyIndex (const CTime &in_frame, double in_tolerance=DBL_MAX) const
CTime	GetKeyTime (LONG in_index) const
CValue	GetKeyValue (LONG in_index) const
CStatus	SetKey (LONG in_index, const CTime &in_frame, const CValue &in_value, bool in_overridekeylock=false)
bool	IsEditing (void) const
CStatus	BeginEdit (void)
CStatus	EndEdit (void)
CStatus	UndoEdit (void)
bool	GetMute (void) const
CStatus	PutMute (bool in_value)
CStatus	Offset (const CTime &in_frameOffset, const CValue &in_valueOffset)
CStatus	OffsetKeys (const CFCurveKeyRefArray &in_Keys, const CTime &in_frameOffset, const CValue &in_valueOffset)
CStatus	Scale (double in_frameFactor, double in_valueFactor, const CTime &in_frameAnchor, const CValue &in_valueAnchor)
CStatus	ScaleKeys (const CFCurveKeyRefArray &in_Keys, double in_frameFactor, double in_valueFactor, const CTime &in_frameAnchor, const CValue &in_valueAnchor, bool in_ripple=false)
CStatus	ExtendCycle (LONG in_CyclesBefore, LONG in_CyclesAfter)
CStatus	SnapToNearestFrame (void)
CStatus	MakeRotationsContinuous (void)
CTime	GetMinKeyFrame (void) const
CTime	GetMidKeyFrame (void) const
CTime	GetMaxKeyFrame (void) const
CValue	GetMinKeyValue (void) const
CValue	GetMidKeyValue (void) const
CValue	GetMaxKeyValue (void) const
bool	InsertKeyAtFrame (const CTime &in_frame)

Constructor & Destructor Documentation

FCurve ( )

Default constructor.

~FCurve ( )

Default destructor.

FCurve ( const CRef & in_ref )

Constructor.

Parameters:

in_ref constant reference object.

FCurve ( const FCurve & in_obj )

Copy constructor.

Parameters:

in_obj constant class object.

Member Function Documentation

bool IsA ( siClassID in_ClassID ) const [virtual]

Returns true if a given class type is compatible with this API class.

Parameters:

in_ClassID class type.

Returns:: true if the class is compatible, false otherwise.

Reimplemented from AnimationSource.

siClassID GetClassID ( ) const [virtual]

Returns the type of the API class.

Returns:: The class type.

Reimplemented from AnimationSource.

FCurve& operator= ( const FCurve & in_obj )

Creates an object from another object. The newly created object is set to empty if the input object is not compatible.

Parameters:

in_obj constant class object.

Returns:: The new FCurve object.

FCurve& operator= ( const CRef & in_ref )

Creates an object from a reference object. The newly created object is set to empty if the input reference object is not compatible.

Parameters:

in_ref constant class object.

Returns:: The new FCurve object.

Reimplemented from AnimationSource.

CValue::DataType GetValueType ( ) const

Returns the value type of the function curve.

Returns:: The value type of the fcurve.

siFCurveType GetFCurveType ( void ) const

Returns the function curve's FCurve type (standard, boolean, raw, etc.).

Returns:: The fcurve type (one of the siFCurveType values).

CStatus PutFCurveType ( siFCurveType in_type )

Sets the function curve's curve type.

Parameters:

in_type Function curve type.

Returns:: CStatus::OK success; CStatus::Fail failure

bool GetLocked ( void ) const

Returns true if the function curve is locked.

Returns:: True if the fcurve is locked

CStatus PutLocked ( bool in_value )

Sets the locked state of the function curve.

Parameters:

in_value new locked state

Returns:: CStatus::OK success; CStatus::Fail failure

bool GetDependsOnFrameRate ( void ) const

Returns the fcurve's dependency on the frame rate (time). If the fcurve is set as time-dependent it will adjust when the scene's frame rate changes. Typically you don't want this to be set to true when the fcurve is a profile curve that does not use time as a factor.

Animation fcurves are typically time-dependent; that is, they generally represent change in a parameter's value over time (for example, a change in an object's X position from frame 10 to frame 90).

Profile fcurves usually do not use frame values on either axis. Profile fcurves are used in deformations to allow a user to fine-tune an effect (for example, the Bulge operator uses percentage of amplitude on the Y-axis over distance from the deformation center on the X-axis).

Returns:: True if the fcurve X axis represents time

Since:: 5.0

CStatus PutDependsOnFrameRate ( bool in_value )

Sets the fcurve's dependency on the frame rate (time). If the fcurve is set as time-dependent it will adjust when the scene's frame rate changes. Typically you don't want this to be set to true when the fcurve is a profile curve that does not use time as a factor.

Animation fcurves are typically time-dependent; that is, they generally represent change in a parameter's value over time (for example, a change in an object's X position from frame 10 to frame 90).

Profile fcurves usually do not use frame values on either axis. Profile fcurves are used in deformations to allow a user to fine-tune an effect (for example, the Bulge operator uses percentage of amplitude on the Y-axis over distance from the deformation center on the X-axis).

Parameters:

in_value New time dependency type

Returns:: CStatus::OK success; CStatus::Fail failure

Since:: 5.0

CValue GetNoKeyValue ( void ) const

Returns the value of the function curve when there are no keys.

Returns:: The fcurve value.

CStatus PutNoKeyValue ( const CValue & in_value )

Sets the value of the function curve when there are no keys.

Parameters:

in_value function curve value

Returns:: CStatus::OK success; CStatus::Fail failure

siFCurveExtrapolation GetExtrapolation ( void ) const

Returns the extrapolation type of the function curve.

Note:: For more information on interpolation and extrapolation in Softimage, see dev_animation_FCurveInterpolationAndExtrapolation FCurve Interpolation and Extrapolation

Returns:: The fcurve's extrapolation type (one of the siFCurveExtrapolation values).

CStatus PutExtrapolation ( siFCurveExtrapolation in_type )

Sets the extrapolation type of the function curve.

Note:: For more information on interpolation and extrapolation in Softimage, see dev_animation_FCurveInterpolationAndExtrapolation FCurve Interpolation and Extrapolation

Parameters:

in_type The fcurve's extrapolation type (one of the siFCurveExtrapolation values).

Returns:: CStatus::OK success; CStatus::Fail failure

siFCurveInterpolation GetInterpolation ( void ) const

Returns the interpolation type of a standard function curve.

Note:: For more information on interpolation and extrapolation in Softimage, see dev_animation_FCurveInterpolationAndExtrapolation FCurve Interpolation and Extrapolation

Returns:: The fcurve's interpolation type (one of the siFCurveInterpolation values).

CStatus PutInterpolation ( siFCurveInterpolation in_type )

Sets the interpolation type of a standard function curve.

Note:: For more information on interpolation and extrapolation in Softimage, see dev_animation_FCurveInterpolationAndExtrapolation FCurve Interpolation and Extrapolation

Parameters:

in_type The fcurve's interpolation type (one of the siFCurveInterpolation values).

Returns:: CStatus::OK success; CStatus::Fail failure

CValue GetLowClamp ( void ) const

Returns the lower-clamping value of the function curve.

Returns:: The fcurve's lower-clamping value.

CStatus PutLowClamp ( const CValue & in_value )

Sets the lower-clamping value of the function curve.

Parameters:

in_value The fcurve's lower-clamping value.

Returns:: CStatus::OK success; CStatus::Fail failure

CValue GetHighClamp ( void ) const

Returns the higher-clamping value of the function curve.

Returns:: The fcurve's higher-clamping value.

CStatus PutHighClamp ( const CValue & in_value )

Sets the higher-clamping value of the function curve.

Parameters:

in_value The fcurve's higher-clamping value.

Returns:: CStatus::OK success; CStatus::Fail failure

CValue Eval ( const CTime & in_frame ) const

Evaluates the function curve at a given frame. If the curve is discontinuous, the right limit is returned.

Parameters:

in_frame The frame at which to evaluate the function curve.

Returns:: The value of the fcurve at a given frame.

CValue Eval ( const double & in_frame ) const

Evaluates the function curve at a given frame. If the curve is discontinuous, the right limit is returned.

Parameters:

in_frame The frame at which to evaluate the function curve

Returns:: The value of the fcurve at a given frame.

CFCurveKeyRefArray GetKeys ( void ) const

Returns an array of FCurveKey objects on the function curve.

Returns:: Array of references to FCurveKey objects.

CFCurveKeyRefArray GetKeysBetween	(	const CTime &	in_startframe = `CTime(DBL_MAX, CTime::CUSTOM)`,
		const CTime &	in_endframe = `CTime(DBL_MAX, CTime::CUSTOM)`
	)		const

Returns an array of FCurveKey objects on the function curve between the start frame and end frame.

Parameters:

in_startframe	The start frame of the range of keys. Defaults to the first key on the curve.
in_endframe	The end frame of the range of keys. Defaults to the last key on the curve.

Returns:: Array of references to FCurveKey objects.

Since:: 6.0

bool GetSelected ( void ) const

Returns the selected state of the function curve.

Returns:: True if the FCurve is selected; false otherwise.

Since:: 6.0

CFCurveKeyRefArray GetSelectedKeys ( ) const

Returns an array of selected FCurveKey objects on the function curve.

Returns:: Array of references to FCurveKey objects.

Since:: 6.0

CStatus SetKeys	(	const CTimeArray &	in_timearray,
		const CValueArray &	in_valuearray,
		bool	in_keepexistingkeys = `false`
	)

Sets the keys of the function curve, previous keys are discarded if the argument in_keepexistingkeys = false.

Parameters:

in_timearray	An array of times
in_valuearray	An array of values
in_keepexistingkeys	(optional--defaults to false)

Returns:: CStatus::OK success; CStatus::Fail failure

CStatus SetKeys	(	const CTimeArray &	in_timearray,
		const CDoubleArray &	in_valuearray,
		const CLongArray &	in_keyinterpolationarray,
		const CTimeArray &	in_lefttanxarray = `CTimeArray()`,
		const CDoubleArray &	in_lefttanyarray = `CDoubleArray()`,
		const CTimeArray &	in_righttanxarray = `CTimeArray()`,
		const CDoubleArray &	in_righttanyarray = `CDoubleArray()`,
		bool	in_keepexistingkeys = `false`
	)

Sets the keys of the function curve, previous keys are discarded if the argument in_keepexistingkeys = false. This function can only be used with standard fcurves, since only standard fcurves support key interpolation and key tangents.

The tangents are optional; however, if specified, the auto tangent constraint will be turned off to allow the tangents to be set without modification. This may lead to an invalid curve depending on the tangent values. If you want the tangents to be automatically calculated pass an empty array for each of the tangent values or specify both the x,y values to be DBL_MAX.

Parameters:

in_timearray	An array of times
in_valuearray	An array of values
in_keyinterpolationarray	An array of key interpolations
in_lefttanxarray	An array of left tan x, time value relative to key time (optional)
in_lefttanyarray	An array of left tan y, a value relative to key value (optional)
in_righttanxarray	An array of right tan x, a value relative to key value (optional)
in_righttanyarray	An array of right tan y (optional)
in_keepexistingkeys	(optional--defaults to false)

Returns:: CStatus::OK success; CStatus::Fail failure

CStatus SetKeyTangents ( const CDoubleArray & in_array )

Sets the values of the tangency values on both sides of the key value.

Parameters:

in_array An array of tangency values (LeftTanX, LeftTanY, RightTanX, RightTanY). The LeftTanX and RightTanX must be specified in frame units.

Returns:: CStatus::OK success; CStatus::Fail failure

bool GetSI3DStyle ( void ) const

Returns true if the fcurve is using the SI3D style of tangent constraints.

Returns:: true for SI3D tangent constraint style.

CStatus PutSI3DStyle ( bool in_value )

Sets the style of tangent constraints to use. True to use the SI3D style of tangent constraints.

Parameters:

in_value True to use SI3D tangent constraints; false for Softimage tangent constraints.

Returns:: CStatus::OK success; CStatus::Fail failure

LONG AddKey	(	const CTime &	in_frame,
		const CValue &	in_value,
		siFCurveKeyInterpolation	in_interp = `siDefaultKeyInterpolation`,
		double	in_ltx = `DBL_MAX`,
		double	in_lty = `DBL_MAX`,
		double	in_rtx = `DBL_MAX`,
		double	in_rty = `DBL_MAX`,
		double	in_tol = `DBL_MAX`,
		bool	in_okl = `false`
	)

Adds a new key at the specified range with the specified value. The tolerance argument can be used to merge all keys within a certain range. The range is defined as Frame - Tolerance and Frame + Tolerance. The merged key will inherit the constraints of the nearest key within this range.

Parameters:

in_frame	New key frame
in_value	New key value
in_interp	Key interpolation
in_ltx	Left tangent x
in_lty	Left tangent y
in_rtx	Right tangent x
in_rty	Right tangent y
in_tol	By default a tolerance of 0.5 frame is specified.
in_okl	True to override the key locks

Returns:: index > 0 (success); index == -1 (failure)

See also:: FCurve::InsertKeyAtFrame

CStatus Resample	(	const CTime &	in_startframe = `CTime(DBL_MAX, CTime::CUSTOM)`,
		const CTime &	in_endframe = `CTime(DBL_MAX, CTime::CUSTOM)`,
		double	in_step = `1`,
		bool	in_keepexistingkeys = `false`,
		bool	in_overridekeylock = `false`
	)

Resamples the fcurve, adding keys from startframe to endframe at the interval defined by the step argument. A valid range is defined as:

 startframe < endframe and step < 0.25 * ( endframe - startframe )

By default the frame range specified by the playcontrol's In and Out parameters will be used. A key is created at the start frame and end frame. The number of samples created between these keys is:

 ( endframe - startframe ) / step

Depending on the frame rate there may be a rounding error with the last key resulting in an extra key being created at the end.

Parameters:

in_startframe	The start frame of the range to resample
in_endframe	The end frame of the range to resample
in_step	Step
in_keepexistingkeys	True to keep existing keys in resample range
in_overridekeylock	True to override the key locks

Returns:: CStatus::OK success; CStatus::AccessDenied if the fcurve or fcurvekeys are locked; CStatus::Fail failure

See also:: FCurve::Smooth,FCurve::Fit

CStatus Smooth	(	const CTime &	in_start = `CTime(DBL_MAX, CTime::CUSTOM)`,
		const CTime &	in_end = `CTime(DBL_MAX, CTime::CUSTOM)`,
		double	in_dFilterSize = `5`,
		double	in_dSamplingStep = `1`,
		siFCurveSmoothFilterType	in_filterType = `siFCurveAverageFilterType`,
		double	in_dGaussianVariance = `1`
	)

Smooths the FCurve in a given time span using a filter by removing sharp spikes and jags from the FCurve by averaging between keys. The FCurve is smoothed first and re-sampled at a sampling step of in_dSamplingStep.

Parameters:

in_start	The start time of the range to smooth. Must be less than the end time (`in_end` value). Defaults to the first key frame on the fcurve or, if there are no keys, the PlayControl.In frame value.
in_end	The end time of the range to smooth. Defaults to the last key frame or, if there are no keys, the PlayControl.Out frame value.
in_dFilterSize	Defines the number of keys that are averaged to calculate a new key. A high filter size will yield a much straighter curve. Defaults to `5` and must be greater than `1`.
in_dSamplingStep	The sampling step applied to the FCurve after smoothing. Must be less than `in_dFilterSize`. Defaults to `1`.
in_filterType	Specifies the type of filter we want to use for smoothing (see siFCurveSmoothFilterType). Defaults to siFCurveAverageFilterType.
in_dGaussianVariance	Variance of the Gaussian filter. Controls the degree of smoothing. A higher variance smooths the function curve more. Defaults to `1` and must be greater than `0`.

Returns:: CStatus::OK success; CStatus::AccessDenied if the FCurve or FCurveKeys are locked; CStatus::InvalidArgument One of the argument is invalid.; CStatus::Fail failure

See also:: FCurve::Fit,FCurve::Resample

Since:: 5.1

CStatus Fit	(	const CTime &	in_start = `CTime(DBL_MAX, CTime::CUSTOM)`,
		const CTime &	in_end = `CTime(DBL_MAX, CTime::CUSTOM)`,
		double	in_dFittingTolerance = `0.1`
	)

FCurve:retiming;retiming;fcurves:retiming fcurves Fits the FCurve within a time span by removing redundant keys while preserving the original shape of a function curve.

Parameters:

in_start	The start time of the range to fit. Must be less than the end time (`in_end` value). Defaults to the first key frame on the fcurve or, if there are no keys, the PlayControl.In frame value.
in_end	The end time of the range to fit. Defaults to the last key frame or, if there are no keys, the PlayControl.Out frame value.
in_dFittingTolerance	Adjusts the closeness of the fit (that is, Maximum distance between the FCurve and the resulting fitted FCurve). Smaller values will respect the original shape of the curve more by using more keys, while larger values will use less keys and result in a fit that deviates from the original curve. Defaults to `0.1` and must be greater than `0`.

Returns:: CStatus::OK success; CStatus::AccessDenied if the FCurve or FCurveKeys are locked; CStatus::InvalidArgument One of the argument is invalid.; CStatus::Fail failure

See also:: FCurve::Smooth, FCurve::Resample

Since:: 5.1

CStatus Set ( const FCurve & in_fcurve )

Copies the specified FCurve (source) to this FCurve (target).

Note:: The operation is undoable. Any pending undo session previously set with FCurve::BeginEdit is automatically ended before copying the FCurve.

Parameters:

in_fcurve The source FCurve to copy.

Returns:: CStatus::OK success; CStatus::AccessDenied if the FCurve or FCurveKeys are locked; CStatus::InvalidArgument The source FCurve is invalid.; CStatus::Fail Input FCurve type is not compatible. You cannot set an FCurve which is connected to a non-boolean parameter with a boolean FCurve (i.e. siBooleanFCurve).

See also:: Parameter.AddFCurve

Since:: 5.1

Example:

        using namespace XSI;
        Application app;
        Model root = app.GetActiveSceneRoot();

        X3DObject myCube;
        root.AddGeometry( L"Cube", L"MeshSurface", L"", myCube );

        // Create and connect an fcurve to position X
        Parameter posx( myCube.GetParameter(L"posx") );

        FCurve posxFc;
        posx.AddFCurve( siStandardFCurve, posxFc );

        // Add some keys
        posxFc.Resample();
        posxFc.PutLowClamp( 25.0 );
        posxFc.PutHighClamp( 75.0 );

        // Create and connect an fcurve to rotation X
        Parameter rotx( myCube.GetParameter(L"rotx") );

        FCurve rotxFc;
        rotx.AddFCurve( siStandardFCurve, rotxFc );

        // Set rotxFc with the posx fcurve
        rotxFc.Set( posxFc );

        // Expected output:
        //'INFO : rotxFc nb keys : 100
        //'INFO : rotxFc low clamp: 25
        //'INFO : rotxFc high clamp: 75
        app.LogMessage( L"rotxFc nb keys : " + CString(rotxFc.GetKeys().GetCount()) );
        app.LogMessage( L"rotxFc low clamp: " + CString(rotxFc.GetLowClamp()) );
        app.LogMessage( L"rotxFc high clamp: " + CString(rotxFc.GetHighClamp()) );

CStatus RemoveKey	(	const CTime &	in_frame,
		double	in_tolerance = `DBL_MAX`,
		bool	in_overridekeylock = `false`
	)

Removes the nearest key to the specified frame within the specified tolerance range.

Parameters:

in_frame	The frame to look for the key
in_tolerance	By default a tolerance of `0.5` frame is specified.
in_overridekeylock	True to override the key locks

Returns:: CStatus::OK success; CStatus::AccessDenied the fcurve or key are locked; CStatus::Fail failure

CStatus RemoveKeyAtIndex	(	LONG	in_index,
		bool	in_overridekeylock = `false`
	)

Removes the key at the specified key index.

Parameters:

in_index	The key index
in_overridekeylock	True to override the key locks

Returns:: CStatus::OK success; CStatus::InvalidArgument index arguments are out of range; CStatus::AccessDenied the fcurve or key are locked; CStatus::Fail failure

CStatus RemoveKeysAtIndex	(	LONG	in_index,
		LONG	in_count,
		bool	in_overridekeylock = `false`
	)

Removes a specified number of keys starting at the specified key index. By default startframe is the first key and endframe is the last key.

Parameters:

in_index	The start key index
in_count	Number of keys to remove. The value specified must be greater than or equal to `1`.
in_overridekeylock	True to override the key locks

Returns:: CStatus::OK success; CStatus::InvalidArgument index or count arguments are out of range; CStatus::AccessDenied the fcurve or key are locked; CStatus::Fail failure

LONG RemoveKeys	(	const CTime &	in_startframe = `CTime(DBL_MAX, CTime::CUSTOM)`,
		const CTime &	in_endframe = `CTime(DBL_MAX, CTime::CUSTOM)`,
		bool	in_overridekeylock = `false`
	)

Removes all keys within the specified range. By default startframe is the first key and endframe is the last key.

Parameters:

in_startframe	The start frame of the range to search
in_endframe	The end frame of the range to search
in_overridekeylock	True to override the key locks

Returns:: The number of keys removed (success); -1 (failure)

bool KeyExists	(	const CTime &	in_frame,
		double	in_tolerance = `DBL_MAX`
	)		const

Returns whether a key can be found at the specified frame within the tolerance range.

Parameters:

in_frame	The frame to look for a key
in_tolerance	By default a tolerance of `0.5` frame is specified.

Returns:: True if a key can be found at the specified frame within the tolerance range

FCurveKey GetKey	(	const CTime &	in_frame,
		double	in_tolerance = `DBL_MAX`
	)		const

Returns the nearest key to the specified frame within the tolerance range.

Parameters:

in_frame	The frame to look for a key
in_tolerance	By default a tolerance of `0.5` frame is specified.

Returns:: The nearest FCurveKey.; Empty CRef object if the key does not exist.

LONG GetNumKeys	(	const CTime &	in_startframe = `CTime(DBL_MAX, CTime::CUSTOM)`,
		const CTime &	in_endframe = `CTime(DBL_MAX, CTime::CUSTOM)`
	)		const

Returns the number of keys within the specified range. By default startframe is the first key and endframe is the last key.

Parameters:

in_startframe	The start frame of the range to search
in_endframe	The end frame of the range to search

Returns:: The number of keys on the fcurve.

FCurveKey GetKeyAtIndex ( LONG in_index ) const

Returns the key at the specified index.

Parameters:

in_index The index of the key to get.

Returns:: The FCurveKey at the specified index.; CStatus::InvalidArgument error if the index is out of range

LONG GetKeyIndex	(	const CTime &	in_frame,
		double	in_tolerance = `DBL_MAX`
	)		const

Returns the index of the nearest key to the specified frame within the tolerance range.

Parameters:

in_frame	The frame to look for a key
in_tolerance	By default a tolerance of 0.5 frame is specified.

Returns:: The index of the key.; -1 if the key does not exist.

CTime GetKeyTime ( LONG in_index ) const

Returns the frame of the key at the specified index.

Parameters:

in_index The index of the key to get.

Returns:: The key time.; CStatus::InvalidArgument error if the index is out of range.

CValue GetKeyValue ( LONG in_index ) const

Returns the value of the key at a specified index.

Parameters:

in_index The index of the key to get.

Returns:: The key value.; CStatus::InvalidArgument error if the index is out of range.

CStatus SetKey	(	LONG	in_index,
		const CTime &	in_frame,
		const CValue &	in_value,
		bool	in_overridekeylock = `false`
	)

Sets the time (in frames) and value of the key at the specified index.

Parameters:

in_index	The index of key to set
in_frame	New key frame
in_value	New key value
in_overridekeylock	True to override the key lock

Returns:: CStatus::OK success; CStatus::InvalidArgument if the index is out of range; CStatus::AccessDenied if the fcurve or key is locked; CStatus::Fail error if another key already exists at the new frame value

bool IsEditing ( void ) const

Returns true if a bulk edit of the fcurve is in progress.

Returns:: True if a bulk edit of the fcurve is in progress

CStatus BeginEdit ( void )

Starts recording bulk edits made to the fcurve. A call to FCurve::BeginEdit must be paired with a call to FCurve::EndEdit, which will commit your changes to the undo/redo stack.

Editing changes can be undone by calling FCurve::UndoEdit and you can check if the fcurve is being bulk edited by using FCurve::IsEditing. If you try to begin another bulk edit a warning is issued, and the current editing session is committed to the undo/redo stack.

Returns:: CStatus::OK success; CStatus::Fail failure

CStatus EndEdit ( void )

Stops recording bulk edits made to the fcurve and commits changes to the undo/redo stack. A call to FCurve::EndEdit must follow a call to FCurve::BeginEdit.

Note:: If you call FCurve::EndEdit when there is no bulk edit in progress, the function will return an error. You can check if a bulk edit is in process by using the FCurve::IsEditing function.

Returns:: CStatus::OK success; CStatus::Fail failure

CStatus UndoEdit ( void )

Undoes the bulk edits made to the fcurve and closes the current bulk edit.

Note:: If you call FCurve::UndoEdit when there is no bulk edit is progress, the function returns CStatus::False.

Returns:: CStatus::OK success; CStatus::False no bulk edit in progress to undo.; CStatus::Fail failure

bool GetMute ( void ) const

Returns the fcurve's mute state. If the fcurve is muted it will not update its corresponding parameter when the time changes.

Returns:: True if the fcurve is muted

Since:: 6.0

CStatus PutMute ( bool in_value )

Sets the fcurve's mute state. If the fcurve is muted it will not update its corresponding parameter when the time changes.

Parameters:

in_value New mute state

Returns:: CStatus::OK success; CStatus::Fail failure

Since:: 6.0

CStatus Offset	(	const CTime &	in_frameOffset,
		const CValue &	in_valueOffset
	)

Offsets the fcurve in time and/or value by a relative amount.

Parameters:

in_frameOffset	Time offset
in_valueOffset	Value offset

Returns:: CStatus::OK success; CStatus::Fail failure

Since:: 6.0

CStatus OffsetKeys	(	const CFCurveKeyRefArray &	in_Keys,
		const CTime &	in_frameOffset,
		const CValue &	in_valueOffset
	)

Offsets fcurve keys in time and/or value by a relative amount.

Parameters:

in_Keys	Keys to offset
in_frameOffset	Time offset
in_valueOffset	Value offset

Returns:: CStatus::OK success; CStatus::Fail failure; CStatus::InvalidArgument if keys are invalid or from a different fcurve

Since:: 6.0

CStatus Scale	(	double	in_frameFactor,
		double	in_valueFactor,
		const CTime &	in_frameAnchor,
		const CValue &	in_valueAnchor
	)

Scales the fcurve in time and/or value relative to the given anchor point.

Warning:: You cannot use negative values for scaling with this function.

Parameters:

in_frameFactor	Frame scale factor
in_valueFactor	Value scale factor
in_frameAnchor	Frame scale anchor
in_valueAnchor	Value scale anchor

Returns:: CStatus::OK success; CStatus::Fail failure

Since:: 6.0

CStatus ScaleKeys	(	const CFCurveKeyRefArray &	in_Keys,
		double	in_frameFactor,
		double	in_valueFactor,
		const CTime &	in_frameAnchor,
		const CValue &	in_valueAnchor,
		bool	in_ripple = `false`
	)

Scales fcurve keys in time and/or value relative to the given anchor point.

Parameters:

in_Keys	Keys to scale
in_frameFactor	Frame scale factor
in_valueFactor	Value scale factor
in_frameAnchor	Frame scale anchor
in_valueAnchor	Value scale anchor
in_ripple	True to keep keys before/after the ones being scaled the same distance from the modified keys

Returns:: CStatus::OK success; CStatus::Fail failure; CStatus::InvalidArgument if keys are invalid or from a different fcurve

Since:: 6.0

CStatus ExtendCycle	(	LONG	in_CyclesBefore,
		LONG	in_CyclesAfter
	)

Extends fcurve to include cycles before/after.

Parameters:

in_CyclesBefore	Number of cycles to include before existing fcurve
in_CyclesAfter	Number of cycles to include after existing fcurve

Returns:: CStatus::OK success; CStatus::Fail failure; CStatus::InvalidArgument if a negative cycle count is specified

Since:: 6.0

CStatus SnapToNearestFrame ( void )

Snaps fcurve keys to their nearest frame times.

Returns:: CStatus::OK success; CStatus::Fail failure

See also:: FCurveKey

Since:: 6.0

CStatus MakeRotationsContinuous ( void )

Removes discontinuities of more than 180 from the fcurve.

Returns:: CStatus::OK success; CStatus::Fail failure

Since:: 6.0

CTime GetMinKeyFrame ( void ) const

Returns the smallest key time in the fcurve.

Returns:: Minimum key time; CStatus::Fail If the fcurve has no keys

Since:: 6.0

CTime GetMidKeyFrame ( void ) const

Returns the average of the first and last key times in the fcurve.

Returns:: Center key time; CStatus::Fail If the fcurve has no keys

Since:: 6.0

CTime GetMaxKeyFrame ( void ) const

Returns the largest key time in the fcurve.

Returns:: Maximum key time; CStatus::Fail If the fcurve has no keys

Since:: 6.0

CValue GetMinKeyValue ( void ) const

Returns the smallest key value in the fcurve.

Returns:: Minimum key value; CStatus::Fail If the fcurve has no keys

Since:: 6.0

CValue GetMidKeyValue ( void ) const

Returns the average of the largest and smallest key values in the fcurve.

Returns:: Center key value; CStatus::Fail If the fcurve has no keys

Since:: 6.0

CValue GetMaxKeyValue ( void ) const

Returns the largest key value in the fcurve.

Returns:: Maximum key value; CStatus::Fail If the fcurve has no keys

Since:: 6.0

bool InsertKeyAtFrame ( const CTime & in_frame )

Inserts a key at the time specified by the frame argument. Unlike FCurve::AddKey, this member function maintains the shape of the fcurve.

Parameters:

in_frame The frame at which to insert the new key.

Returns:: CStatus::Fail If the fcurve has no keys

See also:: FCurve::AddKey

Since:: 7.5

The documentation for this class was generated from the following file:

xsi_fcurve.h

Detailed Description

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation