kfbxkfcurvefilters.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXKFCURVEFILTERS_H
#define FBXFILESDK_KFBXPLUGINS_KFBXKFCURVEFILTERS_H

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

 Copyright (C) 2001 - 2010 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 GetStopKey(KFbxAnimCurve& 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(KFbxAnimCurve** 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 Apply(KFbxAnimCurveNode& pCurveNode){return false;}

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

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

    virtual void Reset(){return ;}

    virtual KError* GetError() {return NULL;}

    virtual int GetLastErrorID(){return -1;}

    virtual char* GetLastErrorString(){return NULL;}


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

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

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

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

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

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

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

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

//
//  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:

    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

    K_DEPRECATED double GetPrecision() const;

    K_DEPRECATED void SetPrecision(double pPrecision);

    K_DEPRECATED bool GetKeySync() const;

    K_DEPRECATED 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:

    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

    K_DEPRECATED double GetDerivativeTolerance() const;

    K_DEPRECATED void SetDerivativeTolerance(double pValue);

    K_DEPRECATED double GetValueTolerance() const;

    K_DEPRECATED void SetValueTolerance(double pValue);

    K_DEPRECATED bool GetKeepFirstAndLastKeys() const;

    K_DEPRECATED void SetKeepFirstAndLastKeys( bool pKeepFirstAndLastKeys );

    K_DEPRECATED bool GetKeepOneKey() const;

    K_DEPRECATED void SetKeepOneKey( bool pKeepOneKey );

    K_DEPRECATED 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)
    //
    K_DEPRECATED void SetTranslationThreshold    ( double pTranslationThreshold );
    K_DEPRECATED void SetRotationThreshold       ( double pRotationThreshold );
    K_DEPRECATED void SetScalingThreshold        ( double pScalingThreshold );
    K_DEPRECATED 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:

    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode* pCurveNode[3]);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode* pCurveNode[3]);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

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

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

    K_DEPRECATED void SetSourceMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

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

    K_DEPRECATED void SetDestMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

    K_DEPRECATED KTime GetResamplingPeriod () const;

    K_DEPRECATED void SetResamplingPeriod (KTime& pResamplingPeriod);

    K_DEPRECATED bool GetGenerateLastKeyExactlyAtEndTime() const;

    K_DEPRECATED void SetGenerateLastKeyExactlyAtEndTime(bool pFlag);

    K_DEPRECATED bool GetResamplingOnFrameRateMultiple() const;

    K_DEPRECATED void SetResamplingOnFrameRateMultiple(bool pFlag);

    K_DEPRECATED bool GetApplyUnroll() const;

    K_DEPRECATED void SetApplyUnroll(bool pFlag);

    K_DEPRECATED bool GetApplyConstantKeyReducer() const;

    K_DEPRECATED void SetApplyConstantKeyReducer(bool pFlag);

    K_DEPRECATED bool GetResampleTranslation() const;

    K_DEPRECATED void SetResampleTranslation(bool pFlag);

    K_DEPRECATED void SetSrcRotateOrder(int pOrder);

    K_DEPRECATED void SetDestRotateOrder(int pOrder);

    K_DEPRECATED void SetForceApply(bool pVal);

    K_DEPRECATED 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:
    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);
    
    K_DEPRECATED virtual KError* GetError();
    K_DEPRECATED virtual int GetLastErrorID() const;
    K_DEPRECATED virtual const char* GetLastErrorString() const;

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

    K_DEPRECATED void SetKeysOnFrame(bool pKeysOnFrame);

    K_DEPRECATED bool GetKeysOnFrame() const;

    K_DEPRECATED KTime GetPeriodTime() const;

    K_DEPRECATED void SetPeriodTime(KTime &pPeriod);


    K_DEPRECATED bool  GetIntelligentMode() const;

    K_DEPRECATED 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:

    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;
    
    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;
    
    K_DEPRECATED virtual bool NeedApply(KFbxAnimStack* pAnimStack) { return false; };

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

    K_DEPRECATED double GetQualityTolerance() const;

    K_DEPRECATED void SetQualityTolerance(double pQualityTolerance);

    K_DEPRECATED bool GetTestForPath() const;

    K_DEPRECATED 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:

    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);
    
    K_DEPRECATED virtual KError* GetError();
    K_DEPRECATED virtual int GetLastErrorID() const;
    K_DEPRECATED virtual const char* GetLastErrorString() const;

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

    K_DEPRECATED bool GetApplyKeySyncFilter() const;

    K_DEPRECATED 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:

    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

    K_DEPRECATED KTime& GetShift() const;

    K_DEPRECATED void SetShift(KTime& pShift);

    K_DEPRECATED double GetScale() const;

    K_DEPRECATED 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:
    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED 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:
    K_DEPRECATED virtual const char* GetName() const;

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

    K_DEPRECATED virtual void SetStopTime(KTime& pTime);

    K_DEPRECATED virtual int GetStartKey(KFbxAnimCurve& pCurve) const;

    K_DEPRECATED virtual int GetStopKey(KFbxAnimCurve& pCurve) const;

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool NeedApply(KFbxAnimCurve& pCurve);

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

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    K_DEPRECATED virtual bool Apply(KFbxAnimCurve& pCurve);

    K_DEPRECATED virtual void Reset();

    K_DEPRECATED float GetScale() const;

    K_DEPRECATED 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