kfbxanimcurvefilters.h

Go to the documentation of this file.

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

   Copyright (C) 2010 Autodesk, Inc.
   All rights reserved.

   This computer source code and related instructions and comments are the unpublished
   confidential and proprietary information of Autodesk, Inc. and are protected under
   applicable copyright and trade secret law.  They may not be disclosed to, copied or
   used by any third party without the prior written consent of Autodesk, Inc.

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


#ifndef FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEFILTERS_H
#define FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEFILTERS_H


#include <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/kfbxplugins/kfbxobject.h>
#include <fbxfilesdk/kfbxplugins/kfbxanimcurve.h>

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

#include <fbxfilesdk/kfbxio/kfbxiosettings.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFbxAnimStack;
class KFbxAnimCurve;
class KFbxAnimCurveNode;
class KMBRotationOrder;

class KFBX_DLL KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilter();

    virtual ~KFbxAnimCurveFilter() {};

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

    KTime& GetStartTime() {return mStart;}

    void SetStartTime(KTime& pTime) { mStart = pTime; }

    KTime& GetStopTime() {return mStop;}

    void SetStopTime(KTime& pTime) { mStop = pTime; }

    int GetStartKey(KFbxAnimCurve& pCurve) const;

    int GetStopKey(KFbxAnimCurve& pCurve) const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack);

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

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    virtual bool NeedApply(KFbxAnimCurve& pCurve);

    virtual bool Apply(KFbxAnimStack* pAnimStack);

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

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

    virtual bool Apply(KFbxAnimCurve& pCurve) = 0;

    virtual void Reset() 
    { 
        mStart= KTIME_MINUS_INFINITE;
        mStop = KTIME_INFINITE;    
    }

    KError* GetError() { return &mError; }

    int GetLastErrorID() { return mError.GetLastErrorID(); }

    const char* GetLastErrorString() const { return mError.GetLastErrorString(); }

    static bool GetContinuousOffset(KMBRotationOrder& pOrder, double pOffset[3], double pNew[3], double pOld[3]);

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

protected:
    void GetKFCurvesFromAnimCurve(KFbxAnimCurve** pSrc, int pSrcCount, KFCurve** pDst, int& pDstCount);

    // Called for progress bar update, indicating what portion of work is done.
    virtual void UpdateProgressInformation(KTime pStart, KTime pStop) {};

    void FillError(const char* pErrorStringArray [], int pErrorCount)
    {
        mError.Reset(pErrorStringArray, pErrorCount);
    };

    // Time span for applying the filter.
    KTime mStart, mStop;

    // Error handling.
    KError mError;
#endif
};


class KFBX_DLL KFbxAnimCurveFilterConstantKeyReducer : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterConstantKeyReducer();

    virtual ~KFbxAnimCurveFilterConstantKeyReducer() {};

    virtual const char* GetName() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack)                   { return KFbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(KFbxObject* pObj, KFbxAnimStack* pAnimStack) { return KFbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount)          { return KFbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

    virtual bool Apply(KFbxAnimCurve& 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 );

    void SetModes(bool pExporting, KFbxIOSettings& pIOS);

private:
    double  mDerTol;
    double  mValTol;

    double  mTranslationThreshold;
    double  mRotationThreshold;
    double  mScalingThreshold;
    double  mDefaultThreshold;

    bool   mKeepFirstAndLastKeys;
    bool   mKeepOneKey;
    bool   mKeepNotPureAutoKeys;

    bool IsKeyConstant(KFbxAnimCurve& pCurve, int pIndex, int pFirstIndex, int pLastIndex, 
                       double pMinValue, double pMaxValue, bool pOnlyCheckAutoKeys);
#endif
};

class KFBX_DLL KFCurveFilterScaleCompensate : public KFbxAnimCurveFilter
{
public:
    enum EError
    {
        eNo2Curves, 
        eErrorCount 
    };

    KFCurveFilterScaleCompensate();
    virtual const char* GetName() const;

    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount, KFbxIOSettings& pIOS);
    virtual bool Apply(KFbxAnimCurve& pCurve);
};

class KFBX_DLL KFbxAnimCurveFilterGimbleKiller : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterGimbleKiller();

    virtual ~KFbxAnimCurveFilterGimbleKiller();

    virtual const char* GetName() const;

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

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

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

    virtual bool NeedApply(KFbxAnimCurve& pCurve) { return false; }
    
    virtual bool Apply(KFbxAnimStack* pAnimStack) { return false; }

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

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

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

    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
private:
    KMBRotationOrder*   mRotationOrder;
    bool                mApplyKeySyncFilter;
    int                 mRotationLayerType;
#endif
};

class KFBX_DLL KFbxAnimCurveFilterKeyReducer : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterKeyReducer();

    virtual ~KFbxAnimCurveFilterKeyReducer() {};

    virtual const char* GetName() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack)                   { return KFbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(KFbxObject* pObj, KFbxAnimStack* pAnimStack) { return KFbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(KFbxAnimCurveNode& pCurveNode)               { return KFbxAnimCurveFilter::Apply(pCurveNode); }

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

    virtual bool Apply(KFbxAnimCurve& 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
private:
    bool  KeyReducer(KFbxAnimCurve& pSCurve, KFbxAnimCurve& pTCurve, KTime pStart, KTime pStop);
    bool  Subdivise(KFbxAnimCurve& pSCurve, KFbxAnimCurve& pTCurve, int pLeft, int pRight);
    double FindMaxError(KFbxAnimCurve& pSCurve, KFbxAnimCurve& pTCurve, int pLeft, int pRight, int& pSplit);
        
    // User parameters.
    double  mPrecision;
    int    mProgressCurrentRecurseLevel;
    bool   mKeySync;
#endif
};


class KFBX_DLL KFbxAnimCurveFilterKeySync : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterKeySync();

    virtual ~KFbxAnimCurveFilterKeySync() {};

    virtual const char* GetName() const;

    virtual bool NeedApply(KFbxAnimStack* pAnimStack)                   { return KFbxAnimCurveFilter::NeedApply(pAnimStack); }
    virtual bool NeedApply(KFbxObject* pObj, KFbxAnimStack* pAnimStack) { return KFbxAnimCurveFilter::NeedApply(pObj, pAnimStack); }
    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode)               { return KFbxAnimCurveFilter::NeedApply(pCurveNode); }
    virtual bool Apply(KFbxAnimStack* pAnimStack)                       { return KFbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(KFbxObject* pObj, KFbxAnimStack* pAnimStack)     { return KFbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(KFbxAnimCurveNode& pCurveNode)                   { return KFbxAnimCurveFilter::Apply(pCurveNode); }

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

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

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

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

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

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#endif
};


class KFBX_DLL KFbxAnimCurveFilterResample : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterResample();

    virtual ~KFbxAnimCurveFilterResample() {};

    virtual const char* GetName() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack)                       { return KFbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(KFbxObject* pObj, KFbxAnimStack* pAnimStack)     { return KFbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(KFbxAnimCurveNode& pCurveNode)                   { return KFbxAnimCurveFilter::Apply(pCurveNode); }
    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount)              { return KFbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(KFbxAnimCurve& 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
private:
    bool    mKeysOnFrame;
    KTime   mPeriod;
    bool    mIntelligent;
#endif

};


class KFBX_DLL KFbxAnimCurveFilterScale : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterScale();

    virtual ~KFbxAnimCurveFilterScale() {};

    virtual const char* GetName() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack)                       { return KFbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(KFbxObject* pObj, KFbxAnimStack* pAnimStack)     { return KFbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount)              { return KFbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

    virtual bool Apply(KFbxAnimCurve& pCurve);

    virtual void Reset();

    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
private:
    double mScale;
#endif
};


class KFBX_DLL KFbxAnimCurveFilterTSS : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterTSS();

    virtual ~KFbxAnimCurveFilterTSS() {};

    virtual const char* GetName() const;

    virtual bool Apply(KFbxAnimStack* pAnimStack)                       { return KFbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(KFbxObject* pObj, KFbxAnimStack* pAnimStack)     { return KFbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(KFbxAnimCurveNode& pCurveNode)                   { return KFbxAnimCurveFilter::Apply(pCurveNode); }
    virtual bool Apply(KFbxAnimCurve** pCurve, int pCount)              { return KFbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(KFbxAnimCurve& 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
private:
    KTime  mShift;
    double  mScale;
#endif
};

class KFBX_DLL KFbxAnimCurveFilterUnroll : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterUnroll();

    virtual ~KFbxAnimCurveFilterUnroll() {};
   
    virtual const char* GetName() const;

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

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

    virtual bool NeedApply(KFbxAnimCurveNode& pCurveNode);

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

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

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

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

    virtual bool Apply(KFbxAnimCurveNode& pCurveNode);

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

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

    virtual void Reset();

    double GetQualityTolerance() const;

    void SetQualityTolerance(double pQualityTolerance);

    bool GetTestForPath() const;

    void SetTestForPath(bool pTestForPath);

    bool GetForceAutoTangents() const;

    void SetForceAutoTangents(bool pForceAutoTangents);

//
//  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
private:
    double  InterpolationQualityFactor(KFbxVector4& lV1, KFbxVector4& lV2);

    double          mQualityTolerance;
    bool            mTestForPath;
    bool            mForceAutoTangents;
    int             mRotationOrder;
    int             mRotationLayerType;
#endif
};

class KFBX_DLL KFbxAnimCurveFilterMatrixConverter : public KFbxAnimCurveFilter
{
public:
    KFbxAnimCurveFilterMatrixConverter();

    virtual ~KFbxAnimCurveFilterMatrixConverter();

    virtual const char* GetName() const;

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

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

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

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

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

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

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

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

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

    bool Apply(KFbxAnimCurve** pCurve, double* pVals);

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

    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 SetSourceMatrix(EMatrixID pIndex, KgeAMatrix& pMatrix);

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

    void SetDestMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);
    void SetDestMatrix(EMatrixID pIndex, KgeAMatrix& 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
private:
    // Nicer than refering to 0, 1, 2...
    enum
    {
        eX,
        eY,
        eZ,
        eDimCount
    };
        
    // Convert parameter cell.
    class Cell;
    
    bool MatricesEquivalence(KFbxXMatrix pMatArrayA [eMatrixCount], 
                             KFbxXMatrix pMatArrayB [eMatrixCount]) const;

    bool DoConvert(KFbxAnimCurve** pCurve, 
                    double pT[eDimCount], 
                    double pR[eDimCount], 
                    double pS[eDimCount]);

    void FindTimeInterval
    (
        KTime& pStart, 
        KTime& pEnd,
        KFbxAnimCurve* pTFCurve [eDimCount], 
        KFbxAnimCurve* pRFCurve [eDimCount], 
        KFbxAnimCurve* pSFCurve [eDimCount]
    );

    void ComputeTotalMatrix
    (
        KFbxXMatrix& pGlobal, 
        Cell& pCell,
        KFbxXMatrix& pTranslate,
        KFbxXMatrix& pRotate,
        KFbxXMatrix& pScale
    );

    void ExtractTransforms
    (
        KFbxVector4& pScaleVector,
        KFbxVector4& pRotateVector,
        KFbxVector4& pTranslateVector,
        KFbxXMatrix& pGlobal,
        Cell& pDest
    );

    void SetDestFCurve(KFbxAnimCurve* pCurve [eDimCount], 
                       int pIndex, 
                       KTime pTime, 
                       KFbxVector4 pVector,
                       KFbxAnimCurveDef::EInterpolationType pInterpMode[eDimCount], 
                       KFbxAnimCurveDef::ETangentMode pTangentMode[eDimCount]);

    void FillInterpAndTangeant(KTime& pTime, 
                               KFbxAnimCurve* pSourceCurve[eDimCount], 
                               KFbxAnimCurveDef::EInterpolationType* pInterp, 
                               KFbxAnimCurveDef::ETangentMode* pTangeant);

    void SetDestFCurveTangeant(KFbxAnimCurve* pCurve [eDimCount], 
                               int pIndex, 
                               KFbxAnimCurveDef::ETangentMode pTangentMode[eDimCount], 
                               KFbxVector4 pKeyValue, 
                               KFbxVector4 pNextKeyValue);

    Cell* mSource;
    Cell* mDest;

    KTime mResamplingPeriod;
    bool mResamplingOnFrameRateMultiple;

    bool mApplyUnroll;
    bool mApplyConstantKeyReducer;

    // PP : So that the concatenation of matrices takes into account the rotation order
    KMBRotationOrder* mSrcRotationOrder;
    KMBRotationOrder* mDestRotationOrder;

    // Set last key exactly at end time or a frame period later.    
    bool mGenerateLastKeyExactlyAtEndTime;

    // Translation resampling flag.
    bool mResampleTranslation;

    // Force Apply
    bool mForceApply;

    // internal usage
    KFbxAnimCurveNode* mRotationCurveNode;
#endif
};


#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEFILTER_H