fbxanimcurvefilters.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2012 Autodesk, Inc.
   All rights reserved.
 
   Use of this software is subject to the terms of the Autodesk license agreement
   provided at the time of installation or download, or which otherwise accompanies
   this software in either electronic or hard copy form.
 
****************************************************************************************/

#ifndef _FBXSDK_SCENE_ANIMATION_CURVE_FILTERS_H_
#define _FBXSDK_SCENE_ANIMATION_CURVE_FILTERS_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/fbxobject.h>
#include <fbxsdk/scene/animation/fbxanimcurve.h>

#include <fbxsdk/core/base/fbxtime.h>
#include <fbxsdk/core/base/fbxerror.h>
#include <fbxsdk/core/math/fbxaffinematrix.h>

#include <fbxsdk/fileio/fbxiosettings.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FbxAnimStack;
class FbxAnimCurve;
class FbxAnimCurveNode;
class FbxRotationOrder;

class FBXSDK_DLL FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilter();

    virtual ~FbxAnimCurveFilter() {};

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

    FbxTime& GetStartTime() {return mStart;}

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

    FbxTime& GetStopTime() {return mStop;}

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

    int GetStartKey(FbxAnimCurve& pCurve) const;

    int GetStopKey(FbxAnimCurve& pCurve) const;

    virtual bool NeedApply(FbxAnimStack* pAnimStack);

    virtual bool NeedApply(FbxObject* pObj, FbxAnimStack* pAnimStack);

    virtual bool NeedApply(FbxAnimCurveNode& pCurveNode);

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

    virtual bool NeedApply(FbxAnimCurve& pCurve);

    virtual bool Apply(FbxAnimStack* pAnimStack);

    virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack);

    virtual bool Apply(FbxAnimCurveNode& pCurveNode);

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

    virtual bool Apply(FbxAnimCurve& pCurve) = 0;

    virtual void Reset() 
    { 
        mStart= FBXSDK_TIME_MINUS_INFINITE;
        mStop = FBXSDK_TIME_INFINITE;    
    }

    FbxError* GetError() { return &mError; }

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

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

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

    static bool GetContinuousOffset(FbxRotationOrder& pOrder, FbxVector4& pOffset, FbxVector4& pNew, FbxVector4& pOld);

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

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

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

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

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


class FBXSDK_DLL FbxAnimCurveFilterConstantKeyReducer : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterConstantKeyReducer();

    virtual ~FbxAnimCurveFilterConstantKeyReducer() {};

    virtual const char* GetName() const;

    virtual bool Apply(FbxAnimStack* pAnimStack)                   { return FbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack) { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(FbxAnimCurve** pCurve, int pCount)          { return FbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(FbxAnimCurveNode& pCurveNode);

    virtual bool Apply(FbxAnimCurve& 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, FbxIOSettings& pIOS);

private:
    double  mDerTol;
    double  mValTol;

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

    bool   mKeepFirstAndLastKeys;
    bool   mKeepOneKey;
    bool   mKeepNotPureAutoKeys;

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

class FBXSDK_DLL FbxAnimCurveFilterScaleCompensate : public FbxAnimCurveFilter
{
public:
    enum EErrorCode
    {
        eNo2Curves, 
        eErrorCount 
    };

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

    virtual bool Apply(FbxAnimCurve** pCurve, int pCount, FbxIOSettings& pIOS);
    virtual bool Apply(FbxAnimCurve& pCurve);
};

class FBXSDK_DLL FbxAnimCurveFilterGimbleKiller : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterGimbleKiller();

    virtual ~FbxAnimCurveFilterGimbleKiller();

    virtual const char* GetName() const;

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

    virtual bool NeedApply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }

    virtual bool NeedApply(FbxAnimCurveNode& pCurveNode);

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

    virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; }
    
    virtual bool Apply(FbxAnimStack* /*pAnimStack*/) { return false; }

    virtual bool Apply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }

    virtual bool Apply(FbxAnimCurveNode& pCurveNode);

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

    virtual bool Apply(FbxAnimCurve& /*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:
    FbxRotationOrder*   mRotationOrder;
    bool                mApplyKeySyncFilter;
    int                 mRotationLayerType;
#endif
};

class FBXSDK_DLL FbxAnimCurveFilterKeyReducer : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterKeyReducer();

    virtual ~FbxAnimCurveFilterKeyReducer() {};

    virtual const char* GetName() const;

    virtual bool Apply(FbxAnimStack* pAnimStack)                   { return FbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack) { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(FbxAnimCurveNode& pCurveNode)               { return FbxAnimCurveFilter::Apply(pCurveNode); }

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

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


class FBXSDK_DLL FbxAnimCurveFilterKeySync : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterKeySync();

    virtual ~FbxAnimCurveFilterKeySync() {};

    virtual const char* GetName() const;

    virtual bool NeedApply(FbxAnimStack* pAnimStack)                   { return FbxAnimCurveFilter::NeedApply(pAnimStack); }
    virtual bool NeedApply(FbxObject* pObj, FbxAnimStack* pAnimStack) { return FbxAnimCurveFilter::NeedApply(pObj, pAnimStack); }
    virtual bool NeedApply(FbxAnimCurveNode& pCurveNode)               { return FbxAnimCurveFilter::NeedApply(pCurveNode); }
    virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(FbxAnimCurveNode& pCurveNode)                   { return FbxAnimCurveFilter::Apply(pCurveNode); }

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

    virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; }

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

    virtual bool Apply(FbxAnimCurve& /*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 FBXSDK_DLL FbxAnimCurveFilterResample : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterResample();

    virtual ~FbxAnimCurveFilterResample() {};

    virtual const char* GetName() const;

    virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(FbxAnimCurveNode& pCurveNode)                   { return FbxAnimCurveFilter::Apply(pCurveNode); }
    virtual bool Apply(FbxAnimCurve** pCurve, int pCount)              { return FbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(FbxAnimCurve& pCurve);

    virtual void Reset();

    void SetKeysOnFrame(bool pKeysOnFrame);

    bool GetKeysOnFrame() const;

    FbxTime GetPeriodTime() const;

    void SetPeriodTime(FbxTime &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;
    FbxTime   mPeriod;
    bool    mIntelligent;
#endif

};


class FBXSDK_DLL FbxAnimCurveFilterScale : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterScale();

    virtual ~FbxAnimCurveFilterScale() {};

    virtual const char* GetName() const;

    virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(FbxAnimCurve** pCurve, int pCount)              { return FbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(FbxAnimCurveNode& pCurveNode);

    virtual bool Apply(FbxAnimCurve& 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 FBXSDK_DLL FbxAnimCurveFilterTSS : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterTSS();

    virtual ~FbxAnimCurveFilterTSS() {};

    virtual const char* GetName() const;

    virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    virtual bool Apply(FbxAnimCurveNode& pCurveNode)                   { return FbxAnimCurveFilter::Apply(pCurveNode); }
    virtual bool Apply(FbxAnimCurve** pCurve, int pCount)              { return FbxAnimCurveFilter::Apply(pCurve, pCount); }

    virtual bool Apply(FbxAnimCurve& pCurve);

    virtual void Reset();

    FbxTime GetShift() const;

    void SetShift(FbxTime& 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:
    FbxTime  mShift;
    double  mScale;
#endif
};

class FBXSDK_DLL FbxAnimCurveFilterUnroll : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterUnroll();

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

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

    virtual bool NeedApply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }

    virtual bool NeedApply(FbxAnimCurveNode& pCurveNode);

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

    virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; };

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

    virtual bool Apply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }

    virtual bool Apply(FbxAnimCurveNode& pCurveNode);

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

    virtual bool Apply(FbxAnimCurve& /*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.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS

    void SetRotationOrder(int pOrder);

private:
    double  InterpolationQualityFactor(FbxVector4& lV1, FbxVector4& lV2);

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

class FBXSDK_DLL FbxAnimCurveFilterMatrixConverter : public FbxAnimCurveFilter
{
public:
    FbxAnimCurveFilterMatrixConverter();

    virtual ~FbxAnimCurveFilterMatrixConverter();

    virtual const char* GetName() const;

    virtual bool NeedApply(FbxAnimCurve** pCurve, int pCount)          { return FbxAnimCurveFilter::NeedApply(pCurve, pCount); }

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

    virtual bool NeedApply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }

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

    virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; }

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

    virtual bool Apply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }

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

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

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

    virtual bool Apply(FbxAnimCurve& /*pCurve*/) { return false; };

    virtual void Reset();

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

    void GetSourceMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix) const;

    void SetSourceMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix);

    void GetDestMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix) const;

    void SetDestMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix);

    FbxTime GetResamplingPeriod () const;

    void SetResamplingPeriod (FbxTime& 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 referring to 0, 1, 2...
    enum EAxisIndex {eX, eY, eZ, eAxisCount};
        
    // Convert parameter cell.
    class Cell;
    
    bool MatricesEquivalence(FbxAMatrix pMatArrayA [eMatrixIndexCount], FbxAMatrix pMatArrayB [eMatrixIndexCount]) const;

    bool DoConvert(FbxAnimCurve** pCurve, 
                    double pT[eAxisCount], 
                    double pR[eAxisCount], 
                    double pS[eAxisCount]);

    void FindTimeInterval
    (
        FbxTime& pStart, 
        FbxTime& pEnd,
        FbxAnimCurve* pTFCurve [eAxisCount], 
        FbxAnimCurve* pRFCurve [eAxisCount], 
        FbxAnimCurve* pSFCurve [eAxisCount]
    );

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

    void ExtractTransforms
    (
        FbxVector4& pScaleVector,
        FbxVector4& pRotateVector,
        FbxVector4& pTranslateVector,
        FbxAMatrix& pGlobal,
        Cell& pDest
    );

    void SetDestFCurve(FbxAnimCurve* pCurve [eAxisCount], 
                       int pIndex, 
                       FbxTime pTime, 
                       FbxVector4 pVector,
                       FbxAnimCurveDef::EInterpolationType pInterpMode[eAxisCount], 
                       FbxAnimCurveDef::ETangentMode pTangentMode[eAxisCount]);

    void FillInterpAndTangeant(FbxTime& pTime, 
                               FbxAnimCurve* pSourceCurve[eAxisCount], 
                               FbxAnimCurveDef::EInterpolationType* pInterp, 
                               FbxAnimCurveDef::ETangentMode* pTangeant);

    void SetDestFCurveTangeant(FbxAnimCurve* pCurve [eAxisCount], 
                               int pIndex, 
                               FbxAnimCurveDef::ETangentMode pTangentMode[eAxisCount], 
                               FbxVector4 pKeyValue, 
                               FbxVector4 pNextKeyValue);

    Cell* mSource;
    Cell* mDest;

    FbxTime mResamplingPeriod;
    bool mResamplingOnFrameRateMultiple;

    bool mApplyUnroll;
    bool mApplyConstantKeyReducer;

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

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

    // Translation re-sampling flag.
    bool mResampleTranslation;

    // Force Apply
    bool mForceApply;

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

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_SCENE_ANIMATION_CURVE_FILTERS_H_ */