kfbxkfcurvefilters.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXKFCURVEFILTERS_H
#define FBXFILESDK_KFBXPLUGINS_KFBXKFCURVEFILTERS_H

/**************************************************************************************

 Copyright (C) 2001 - 2009 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.

 The coded instructions, statements, computer programs, and/or related material 
 (collectively the "Data") in these files contain unpublished information 
 proprietary to Autodesk, Inc. and/or its licensors, which is protected by 
 Canada and United States of America federal copyright law and by international 
 treaties. 
 
 The Data may not be disclosed or distributed to third parties, in whole or in
 part, without the prior written consent of Autodesk, Inc. ("Autodesk").

 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR ARISING
 BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES OF TITLE, 
 NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR USE. 
 WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT WARRANT THAT THE OPERATION
 OF THE DATA WILL BE UNINTERRUPTED OR ERROR FREE. 
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR EXPENSES
 OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE DAMAGES OR OTHER
 SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS OF PROFITS, REVENUE
 OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR DAMAGES OF ANY KIND),
 HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF LIABILITY, WHETHER DERIVED
 FROM CONTRACT, TORT (INCLUDING, BUT NOT LIMITED TO, NEGLIGENCE), OR OTHERWISE,
 ARISING OUT OF OR RELATING TO THE DATA OR ITS USE OR ANY OTHER PERFORMANCE,
 WHETHER OR NOT AUTODESK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS
 OR DAMAGE. 

**************************************************************************************/
#include <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/kfbxplugins/kfbxobject.h>
#include <fbxfilesdk/components/kbaselib/klib/ktime.h>
#include <fbxfilesdk/components/kbaselib/klib/kerror.h>
#include <fbxfilesdk/kfbxmath/kfbxxmatrix.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFbxAnimStack;
class KFbxAnimCurve;
class KFbxAnimCurveNode;
class KFCurve;
class KFCurveNode;
class KFCurveFilterKeyReducer;
class KFCurveFilterConstantKeyReducer;
class KFCurveFilterMatrixConverter;
class KFCurveFilterResample;
class KFCurveFilterUnroll;
class KFCurveFilterGimbleKiller;
class KFCurveFilterTimeShiftAndScale;
class KFCurveFilterKeySync;
class KFCurveFilterScale;


class KFBX_DLL KFbxKFCurveFilter : public KFbxObject
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilter,KFbxObject);

public:
    virtual const char* GetName() const {return NULL;}

    virtual KTime& GetStartTime() {return mTime;}

    virtual void SetStartTime(KTime& pTime){return;}

    virtual KTime& GetStopTime(){return mTime;}

    virtual void SetStopTime(KTime& pTime){return ;}

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const {return 0;}

    virtual int GetStartKey(KFCurve& pCurve) const {return 0;}

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const {return 0;}

    virtual int GetStopKey(KFCurve& pCurve) const {return 0;}

    virtual bool NeedApply(KFbxAnimStack* pAnimStack);

    virtual bool NeedApply(KFbxObject* pObj, KFbxAnimStack* pAnimStack);

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode) {return false;}

    virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true){return false;}

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount){return false;}

    virtual bool NeedApply(KFCurve** pCurve, int pCount){return false;}

    virtual bool NeedApply(KFbxAnimCurve& pCurve){return false;}

    virtual bool Apply(KFbxAnimStack* pAnimStack);

    virtual bool Apply(KFbxObject* pObj, KFbxAnimStack* pAnimStack);

    virtual bool NeedApply(KFCurve& pCurve){return false;}

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode){return false;}

    virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true){return false;}

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount){return false;}

    virtual bool Apply(KFCurve** pCurve, int pCount){return false;}

    virtual bool Apply(KFbxAnimCurve& pCurve){return false;}

    virtual bool Apply(KFCurve& pCurve){return false;}

    virtual void Reset(){return ;}

    virtual KError* GetError() {return NULL;}

    virtual int GetLastErrorID(){return -1;}

    virtual char* GetLastErrorString(){return NULL;}
//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS

protected:
    KFbxKFCurveFilter(KFbxSdkManager& pManager, char const* pName);
    void GetKFCurvesFromAnimCurve(KFbxAnimCurve** pSrc, int pSrcCount, KFCurve** pDst, int& pDstCount);

    KTime mTime;
#endif
};


class KFBX_DLL KFbxKFCurveFilterKeyReducer : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterKeyReducer,KFbxKFCurveFilter);

public:

    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return ParentClass::NeedApply(pAnimStack); }

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return ParentClass::Apply(pAnimStack); }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    double GetPrecision() const;

    void SetPrecision(double pPrecision);

    bool GetKeySync() const;

    void SetKeySync(bool pKeySync);

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterKeyReducer(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterKeyReducer *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);

#endif
};



class KFBX_DLL KFbxKFCurveFilterConstantKeyReducer : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterConstantKeyReducer,KFbxKFCurveFilter);

public:

    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return ParentClass::NeedApply(pAnimStack); }

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return ParentClass::Apply(pAnimStack); }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    double GetDerivativeTolerance() const;

    void SetDerivativeTolerance(double pValue);

    double GetValueTolerance() const;

    void SetValueTolerance(double pValue);

    bool GetKeepFirstAndLastKeys() const;

    void SetKeepFirstAndLastKeys( bool pKeepFirstAndLastKeys );

    bool GetKeepOneKey() const;

    void SetKeepOneKey( bool pKeepOneKey );

    void SetKeepNotPureAutoKeys(bool pKeep);

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    //
    //  If ValueTolerance is default, we use the thresholds here, otherwise
    //  it is the ValueTolerance that is used. (Mainly for backward compatibility)
    //
    void SetTranslationThreshold    ( double pTranslationThreshold );
    void SetRotationThreshold       ( double pRotationThreshold );
    void SetScalingThreshold        ( double pScalingThreshold );
    void SetDefaultThreshold        ( double pDefaultThreshold );
protected:
    KFbxKFCurveFilterConstantKeyReducer(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterConstantKeyReducer *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);

#endif
};




class KFBX_DLL KFbxKFCurveFilterMatrixConverter : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterMatrixConverter,KFbxKFCurveFilter);

public:

    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return false; }

    virtual bool NeedApply(KFbxAnimCurveNode* pCurveNode[3]);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return false; }

    virtual bool Apply(KFbxAnimCurveNode* pCurveNode[3]);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    enum EMatrixID
    {
        ePreGlobal,
        ePreTranslate,
        ePostTranslate,
        ePreRotate,
        ePostRotate,
        ePreScale,
        ePostScale,
        ePostGlobal,
        eScaleOffset,
        eInactivePre,
        eInactivePost,
        eRotationPivot,
        eScalingPivot,
        eMatrixCount
    };

    void GetSourceMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix) const;

    void SetSourceMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

    void GetDestMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix) const;

    void SetDestMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

    KTime GetResamplingPeriod () const;

    void SetResamplingPeriod (KTime& pResamplingPeriod);

    bool GetGenerateLastKeyExactlyAtEndTime() const;

    void SetGenerateLastKeyExactlyAtEndTime(bool pFlag);

    bool GetResamplingOnFrameRateMultiple() const;

    void SetResamplingOnFrameRateMultiple(bool pFlag);

    bool GetApplyUnroll() const;

    void SetApplyUnroll(bool pFlag);

    bool GetApplyConstantKeyReducer() const;

    void SetApplyConstantKeyReducer(bool pFlag);

    bool GetResampleTranslation() const;

    void SetResampleTranslation(bool pFlag);

    void SetSrcRotateOrder(int pOrder);

    void SetDestRotateOrder(int pOrder);

    void SetForceApply(bool pVal);

    bool GetForceApply() const;
//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterMatrixConverter(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterMatrixConverter *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);
#endif
};




class KFBX_DLL KFbxKFCurveFilterResample : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterResample,KFbxKFCurveFilter);

public:
    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return ParentClass::NeedApply(pAnimStack); }

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return ParentClass::Apply(pAnimStack); }

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    void SetKeysOnFrame(bool pKeysOnFrame);

    bool GetKeysOnFrame() const;

    KTime GetPeriodTime() const;

    void SetPeriodTime(KTime &pPeriod);


    bool  GetIntelligentMode() const;

    void  SetIntelligentMode( bool pIntelligent );

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterResample(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterResample *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);
#endif

};

class KFBX_DLL KFbxKFCurveFilterUnroll : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterUnroll,KFbxKFCurveFilter);

public:

    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return false; };

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return false; };

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    double GetQualityTolerance() const;

    void SetQualityTolerance(double pQualityTolerance);

    bool GetTestForPath() const;

    void SetTestForPath(bool pTestForPath);

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
    void SetRotationOrder(int pOrder);

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterUnroll(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterUnroll *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);
#endif
};


class KFBX_DLL KFbxKFCurveFilterGimbleKiller : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterGimbleKiller,KFbxKFCurveFilter);

public:

    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return false; }

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return false; }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    bool GetApplyKeySyncFilter() const;

    void SetApplyKeySyncFilter(bool pFlag);

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterGimbleKiller(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterGimbleKiller *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);
#endif
};


class KFBX_DLL KFbxKFCurveFilterTSS : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterTSS,KFbxKFCurveFilter);

public:

    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return ParentClass::NeedApply(pAnimStack); }

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return ParentClass::Apply(pAnimStack); }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    KTime& GetShift() const;

    void SetShift(KTime& pShift);

    double GetScale() const;

    void SetScale(double pScale);

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterTSS(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterTimeShiftAndScale *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);
#endif
};

class KFBX_DLL KFbxKFCurveFilterKeySync : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterKeySync,KFbxKFCurveFilter);

public:
    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return ParentClass::NeedApply(pAnimStack); }

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return ParentClass::Apply(pAnimStack); }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterKeySync(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterKeySync *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);

#endif
};

class KFBX_DLL KFbxKFCurveFilterScale : public KFbxKFCurveFilter
{
    KFBXOBJECT_DECLARE(KFbxKFCurveFilterScale,KFbxKFCurveFilter);

public:
    virtual const char* GetName() const;

    virtual KTime& GetStartTime();
    virtual void SetStartTime(KTime& pTime);
    virtual KTime& GetStopTime();

    virtual void SetStopTime(KTime& pTime);

    virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStartKey(KFCurve& pCurve) const;

    virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    K_DEPRECATED virtual int GetStopKey(KFCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return ParentClass::NeedApply(pAnimStack); }

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool NeedApply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool NeedApply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool NeedApply(KFCurve** pCurve, int pCount);

    virtual bool NeedApply(KFbxAnimCurve& pCurve);
    K_DEPRECATED virtual bool NeedApply(KFCurve& pCurve);

    virtual KError* GetError();
    virtual int GetLastErrorID() const;
    virtual const char* GetLastErrorString() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack) { return ParentClass::Apply(pAnimStack); }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);
    K_DEPRECATED virtual bool Apply(KFCurveNode& pCurveNode, bool pRecursive = true);

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount);
    K_DEPRECATED virtual bool Apply(KFCurve** pCurve, int pCount);

    virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual bool Apply(KFCurve& pCurve);

    virtual void Reset();

    float GetScale() const;

    void SetScale(float pScale);

//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    KFbxKFCurveFilterScale(KFbxSdkManager& pManager, char const* pName);
    KFCurveFilterScale *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);

#endif
};

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXKFCURVEFILTERS_H