Public Member Functions
FCurve Class Reference

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:
Inheritance graph
[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
FCurveoperator= (const FCurve &in_obj)
FCurveoperator= (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_refconstant reference object.
FCurve ( const FCurve in_obj)

Copy constructor.

Parameters:
in_objconstant 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_ClassIDclass 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_objconstant 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_refconstant 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_typeFunction 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_valuenew 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_valueNew 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_valuefunction 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_typeThe 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_typeThe 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_valueThe 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_valueThe 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_frameThe 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_frameThe 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_startframeThe start frame of the range of keys. Defaults to the first key on the curve.
in_endframeThe 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_timearrayAn array of times
in_valuearrayAn 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_timearrayAn array of times
in_valuearrayAn array of values
in_keyinterpolationarrayAn array of key interpolations
in_lefttanxarrayAn array of left tan x, time value relative to key time (optional)
in_lefttanyarrayAn array of left tan y, a value relative to key value (optional)
in_righttanxarrayAn array of right tan x, a value relative to key value (optional)
in_righttanyarrayAn 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_arrayAn 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_valueTrue 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_frameNew key frame
in_valueNew key value
in_interpKey interpolation
in_ltxLeft tangent x
in_ltyLeft tangent y
in_rtxRight tangent x
in_rtyRight tangent y
in_tolBy default a tolerance of 0.5 frame is specified.
in_oklTrue 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_startframeThe start frame of the range to resample
in_endframeThe end frame of the range to resample
in_stepStep
in_keepexistingkeysTrue to keep existing keys in resample range
in_overridekeylockTrue 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_startThe 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_endThe 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_dFilterSizeDefines 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_dSamplingStepThe sampling step applied to the FCurve after smoothing. Must be less than in_dFilterSize. Defaults to 1.
in_filterTypeSpecifies the type of filter we want to use for smoothing (see siFCurveSmoothFilterType). Defaults to siFCurveAverageFilterType.
in_dGaussianVarianceVariance 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_startThe 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_endThe 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_dFittingToleranceAdjusts 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_fcurveThe 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_frameThe frame to look for the key
in_toleranceBy default a tolerance of 0.5 frame is specified.
in_overridekeylockTrue 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_indexThe key index
in_overridekeylockTrue 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_indexThe start key index
in_countNumber of keys to remove. The value specified must be greater than or equal to 1.
in_overridekeylockTrue 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_startframeThe start frame of the range to search
in_endframeThe end frame of the range to search
in_overridekeylockTrue 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_frameThe frame to look for a key
in_toleranceBy 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_frameThe frame to look for a key
in_toleranceBy 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_startframeThe start frame of the range to search
in_endframeThe 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_indexThe 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_frameThe frame to look for a key
in_toleranceBy 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_indexThe 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_indexThe 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_indexThe index of key to set
in_frameNew key frame
in_valueNew key value
in_overridekeylockTrue 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_valueNew 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_frameOffsetTime offset
in_valueOffsetValue 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_KeysKeys to offset
in_frameOffsetTime offset
in_valueOffsetValue 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_frameFactorFrame scale factor
in_valueFactorValue scale factor
in_frameAnchorFrame scale anchor
in_valueAnchorValue 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_KeysKeys to scale
in_frameFactorFrame scale factor
in_valueFactorValue scale factor
in_frameAnchorFrame scale anchor
in_valueAnchorValue scale anchor
in_rippleTrue 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_CyclesBeforeNumber of cycles to include before existing fcurve
in_CyclesAfterNumber 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_frameThe 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: