- Main Page
- Classes
- Files
- Directories
- Examples

- File List
- File Members

# fbxanimcurvefilters.h

Go to the documentation of this file.

    00001 /****************************************************************************************
    00002
    00003    Copyright (C) 2012 Autodesk, Inc.
    00004    All rights reserved.
    00005
    00006    Use of this software is subject to the terms of the Autodesk license agreement
    00007    provided at the time of installation or download, or which otherwise accompanies
    00008    this software in either electronic or hard copy form.
    00009
    00010 ****************************************************************************************/
    00011
    00013 #ifndef _FBXSDK_SCENE_ANIMATION_CURVE_FILTERS_H_
    00014 #define _FBXSDK_SCENE_ANIMATION_CURVE_FILTERS_H_
    00015
    00016 #include <fbxsdk/fbxsdk_def.h>
    00017
    00018 #include <fbxsdk/core/fbxobject.h>
    00019 #include <fbxsdk/scene/animation/fbxanimcurve.h>
    00020
    00021 #include <fbxsdk/core/base/fbxtime.h>
    00022 #include <fbxsdk/core/base/fbxerror.h>
    00023 #include <fbxsdk/core/math/fbxaffinematrix.h>
    00024
    00025 #include <fbxsdk/fileio/fbxiosettings.h>
    00026
    00027 #include <fbxsdk/fbxsdk_nsbegin.h>
    00028
    00029 class FbxAnimStack;
    00030 class FbxAnimCurve;
    00031 class FbxAnimCurveNode;
    00032 class FbxRotationOrder;
    00033
    00079 class FBXSDK_DLL FbxAnimCurveFilter
    00080 {
    00081 public:
    00083     FbxAnimCurveFilter();
    00084
    00086     virtual ~FbxAnimCurveFilter() {};
    00087
    00095     virtual const char* GetName() const {return NULL;}
    00096
    00101     FbxTime& GetStartTime() {return mStart;}
    00102
    00107     void SetStartTime(FbxTime& pTime) { mStart = pTime; }
    00108
    00113     FbxTime& GetStopTime() {return mStop;}
    00114
    00119     void SetStopTime(FbxTime& pTime) { mStop = pTime; }
    00120
    00126     int GetStartKey(FbxAnimCurve& pCurve) const;
    00127
    00133     int GetStopKey(FbxAnimCurve& pCurve) const;
    00134
    00139     virtual bool NeedApply(FbxAnimStack* pAnimStack);
    00140
    00146     virtual bool NeedApply(FbxObject* pObj, FbxAnimStack* pAnimStack);
    00147
    00154     virtual bool NeedApply(FbxAnimCurveNode& pCurveNode);
    00155
    00161     virtual bool NeedApply(FbxAnimCurve** pCurve, int pCount);
    00162
    00167     virtual bool NeedApply(FbxAnimCurve& pCurve);
    00168
    00173     virtual bool Apply(FbxAnimStack* pAnimStack);
    00174
    00180     virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack);
    00181
    00188     virtual bool Apply(FbxAnimCurveNode& pCurveNode);
    00189
    00195     virtual bool Apply(FbxAnimCurve** pCurve, int pCount);
    00196
    00201     virtual bool Apply(FbxAnimCurve& pCurve) = 0;
    00202
    00205     virtual void Reset()
    00206     {
    00207         mStart= FBXSDK_TIME_MINUS_INFINITE;
    00208         mStop = FBXSDK_TIME_INFINITE;
    00209     }
    00210
    00214     FbxError* GetError() { return &mError; }
    00215
    00219     int GetLastErrorID() { return mError.GetLastErrorID(); }
    00220
    00224     const char* GetLastErrorString() const { return mError.GetLastErrorString(); }
    00226
    00228 //
    00229 //  WARNING!
    00230 //
    00231 //  Anything beyond these lines may not be documented accurately and is
    00232 //  subject to change without notice.
    00233 //
    00235 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00236
    00237     static bool GetContinuousOffset(FbxRotationOrder& pOrder, FbxVector4& pOffset, FbxVector4& pNew, FbxVector4& pOld);
    00238
    00239 protected:
    00240     void GetKFCurvesFromAnimCurve(FbxAnimCurve** pSrc, int pSrcCount, KFCurve** pDst, int& pDstCount);
    00241
    00242     // Called for progress bar update, indicating what portion of work is done.
    00243     virtual void UpdateProgressInformation(FbxTime /*pStart*/, FbxTime /*pStop*/) {};
    00244
    00245     void FillError(const char* pErrorStringArray [], int pErrorCount)
    00246     {
    00247         mError.Reset(pErrorStringArray, pErrorCount);
    00248     };
    00249
    00250     // Time span for applying the filter.
    00251     FbxTime mStart, mStop;
    00252
    00253     // Error handling.
    00254     FbxError mError;
    00255 #endif
    00256 };
    00257
    00258
    00265 class FBXSDK_DLL FbxAnimCurveFilterConstantKeyReducer : public FbxAnimCurveFilter
    00266 {
    00267 public:
    00269     FbxAnimCurveFilterConstantKeyReducer();
    00270
    00272     virtual ~FbxAnimCurveFilterConstantKeyReducer() {};
    00273
    00277     virtual const char* GetName() const;
    00278
    00283     virtual bool Apply(FbxAnimStack* pAnimStack)                   { return FbxAnimCurveFilter::Apply(pAnimStack); }
    00284     virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack) { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    00285     virtual bool Apply(FbxAnimCurve** pCurve, int pCount)          { return FbxAnimCurveFilter::Apply(pCurve, pCount); }
    00287
    00294     virtual bool Apply(FbxAnimCurveNode& pCurveNode);
    00295
    00300     virtual bool Apply(FbxAnimCurve& pCurve);
    00301
    00304     virtual void Reset();
    00305
    00309     double GetDerivativeTolerance() const;
    00310
    00314     void SetDerivativeTolerance(double pValue);
    00315
    00319     double GetValueTolerance() const;
    00320
    00324     void SetValueTolerance(double pValue);
    00325
    00329     bool GetKeepFirstAndLastKeys() const;
    00330
    00334     void SetKeepFirstAndLastKeys( bool pKeepFirstAndLastKeys );
    00335
    00341     bool GetKeepOneKey() const;
    00342
    00348     void SetKeepOneKey( bool pKeepOneKey );
    00349
    00353     void SetKeepNotPureAutoKeys(bool pKeep);
    00354
    00356 //
    00357 //  WARNING!
    00358 //
    00359 //  Anything beyond these lines may not be documented accurately and is
    00360 //  subject to change without notice.
    00361 //
    00363
    00364 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00365     //
    00366     //  If ValueTolerance is default, we use the thresholds here, otherwise
    00367     //  it is the ValueTolerance that is used. (Mainly for backward compatibility)
    00368     //
    00369     void SetTranslationThreshold    ( double pTranslationThreshold );
    00370     void SetRotationThreshold       ( double pRotationThreshold );
    00371     void SetScalingThreshold        ( double pScalingThreshold );
    00372     void SetDefaultThreshold        ( double pDefaultThreshold );
    00373
    00374     void SetModes(bool pExporting, FbxIOSettings& pIOS);
    00375
    00376 private:
    00377     double  mDerTol;
    00378     double  mValTol;
    00379
    00380     double  mTranslationThreshold;
    00381     double  mRotationThreshold;
    00382     double  mScalingThreshold;
    00383     double  mDefaultThreshold;
    00384
    00385     bool   mKeepFirstAndLastKeys;
    00386     bool   mKeepOneKey;
    00387     bool   mKeepNotPureAutoKeys;
    00388
    00389     bool IsKeyConstant(FbxAnimCurve& pCurve, int pIndex, int pFirstIndex, int pLastIndex,
    00390                        double pMinValue, double pMaxValue, bool pOnlyCheckAutoKeys);
    00391 #endif
    00392 };
    00393
    00401 class FBXSDK_DLL FbxAnimCurveFilterScaleCompensate : public FbxAnimCurveFilter
    00402 {
    00403 public:
    00405     enum EErrorCode
    00406     {
    00407         eNo2Curves,
    00408         eErrorCount
    00409     };
    00410
    00412     FbxAnimCurveFilterScaleCompensate();
    00414     virtual const char* GetName() const;
    00415
    00423     virtual bool Apply(FbxAnimCurve** pCurve, int pCount, FbxIOSettings& pIOS);
    00425     virtual bool Apply(FbxAnimCurve& pCurve);
    00426 };
    00427
    00435 class FBXSDK_DLL FbxAnimCurveFilterGimbleKiller : public FbxAnimCurveFilter
    00436 {
    00437 public:
    00439     FbxAnimCurveFilterGimbleKiller();
    00440
    00442     virtual ~FbxAnimCurveFilterGimbleKiller();
    00443
    00447     virtual const char* GetName() const;
    00448
    00454     virtual bool NeedApply(FbxAnimStack* /*pAnimStack*/) { return false; }
    00455
    00462     virtual bool NeedApply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }
    00463
    00471     virtual bool NeedApply(FbxAnimCurveNode& pCurveNode);
    00472
    00481     virtual bool NeedApply(FbxAnimCurve** pCurve, int pCount);
    00482
    00486     virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; }
    00487
    00493     virtual bool Apply(FbxAnimStack* /*pAnimStack*/) { return false; }
    00494
    00501     virtual bool Apply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }
    00502
    00509     virtual bool Apply(FbxAnimCurveNode& pCurveNode);
    00510
    00519     virtual bool Apply(FbxAnimCurve** pCurve, int pCount);
    00520
    00524     virtual bool Apply(FbxAnimCurve& /*pCurve*/) { return false; }
    00525
    00528     virtual void Reset();
    00529
    00531     bool GetApplyKeySyncFilter() const;
    00532
    00536     void SetApplyKeySyncFilter(bool pFlag);
    00537
    00539 //
    00540 //  WARNING!
    00541 //
    00542 //  Anything beyond these lines may not be documented accurately and is
    00543 //  subject to change without notice.
    00544 //
    00546
    00547 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00548 private:
    00549     FbxRotationOrder*   mRotationOrder;
    00550     bool                mApplyKeySyncFilter;
    00551     int                 mRotationLayerType;
    00552 #endif
    00553 };
    00554
    00561 class FBXSDK_DLL FbxAnimCurveFilterKeyReducer : public FbxAnimCurveFilter
    00562 {
    00563 public:
    00565     FbxAnimCurveFilterKeyReducer();
    00566
    00568     virtual ~FbxAnimCurveFilterKeyReducer() {};
    00569
    00573     virtual const char* GetName() const;
    00574
    00579     virtual bool Apply(FbxAnimStack* pAnimStack)                   { return FbxAnimCurveFilter::Apply(pAnimStack); }
    00580     virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack) { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    00581     virtual bool Apply(FbxAnimCurveNode& pCurveNode)               { return FbxAnimCurveFilter::Apply(pCurveNode); }
    00583
    00589     virtual bool Apply(FbxAnimCurve** pCurve, int pCount);
    00590
    00595     virtual bool Apply(FbxAnimCurve& pCurve);
    00596
    00599     virtual void Reset();
    00600
    00602     double GetPrecision() const;
    00603
    00607     void SetPrecision(double pPrecision);
    00608
    00610     bool GetKeySync() const;
    00611
    00615     void SetKeySync(bool pKeySync);
    00616
    00618 //
    00619 //  WARNING!
    00620 //
    00621 //  Anything beyond these lines may not be documented accurately and is
    00622 //  subject to change without notice.
    00623 //
    00625
    00626 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00627 private:
    00628     bool  KeyReducer(FbxAnimCurve& pSCurve, FbxAnimCurve& pTCurve, FbxTime pStart, FbxTime pStop);
    00629     bool  Subdivise(FbxAnimCurve& pSCurve, FbxAnimCurve& pTCurve, int pLeft, int pRight);
    00630     double FindMaxError(FbxAnimCurve& pSCurve, FbxAnimCurve& pTCurve, int pLeft, int pRight, int& pSplit);
    00631
    00632     // User parameters.
    00633     double  mPrecision;
    00634     int    mProgressCurrentRecurseLevel;
    00635     bool   mKeySync;
    00636 #endif
    00637 };
    00638
    00639
    00644 class FBXSDK_DLL FbxAnimCurveFilterKeySync : public FbxAnimCurveFilter
    00645 {
    00646 public:
    00648     FbxAnimCurveFilterKeySync();
    00649
    00651     virtual ~FbxAnimCurveFilterKeySync() {};
    00652
    00656     virtual const char* GetName() const;
    00657
    00662     virtual bool NeedApply(FbxAnimStack* pAnimStack)                   { return FbxAnimCurveFilter::NeedApply(pAnimStack); }
    00663     virtual bool NeedApply(FbxObject* pObj, FbxAnimStack* pAnimStack) { return FbxAnimCurveFilter::NeedApply(pObj, pAnimStack); }
    00664     virtual bool NeedApply(FbxAnimCurveNode& pCurveNode)               { return FbxAnimCurveFilter::NeedApply(pCurveNode); }
    00665     virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    00666     virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    00667     virtual bool Apply(FbxAnimCurveNode& pCurveNode)                   { return FbxAnimCurveFilter::Apply(pCurveNode); }
    00669
    00675     virtual bool NeedApply(FbxAnimCurve** pCurve, int pCount);
    00676
    00681     virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; }
    00682
    00688     virtual bool Apply(FbxAnimCurve** pCurve, int pCount);
    00689
    00695     virtual bool Apply(FbxAnimCurve& /*pCurve*/) { return true; }
    00696
    00698 //
    00699 //  WARNING!
    00700 //
    00701 //  Anything beyond these lines may not be documented accurately and is
    00702 //  subject to change without notice.
    00703 //
    00705
    00706 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00707 #endif
    00708 };
    00709
    00710
    00715 class FBXSDK_DLL FbxAnimCurveFilterResample : public FbxAnimCurveFilter
    00716 {
    00717 public:
    00719     FbxAnimCurveFilterResample();
    00720
    00722     virtual ~FbxAnimCurveFilterResample() {};
    00723
    00727     virtual const char* GetName() const;
    00728
    00733     virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    00734     virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    00735     virtual bool Apply(FbxAnimCurveNode& pCurveNode)                   { return FbxAnimCurveFilter::Apply(pCurveNode); }
    00736     virtual bool Apply(FbxAnimCurve** pCurve, int pCount)              { return FbxAnimCurveFilter::Apply(pCurve, pCount); }
    00738
    00743     virtual bool Apply(FbxAnimCurve& pCurve);
    00744
    00747     virtual void Reset();
    00748
    00752     void SetKeysOnFrame(bool pKeysOnFrame);
    00753
    00757     bool GetKeysOnFrame() const;
    00758
    00762     FbxTime GetPeriodTime() const;
    00763
    00767     void SetPeriodTime(FbxTime &pPeriod);
    00768
    00769
    00777     bool  GetIntelligentMode() const;
    00778
    00785     void  SetIntelligentMode( bool pIntelligent );
    00786
    00788 //
    00789 //  WARNING!
    00790 //
    00791 //  Anything beyond these lines may not be documented accurately and is
    00792 //  subject to change without notice.
    00793 //
    00795 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00796 private:
    00797     bool    mKeysOnFrame;
    00798     FbxTime   mPeriod;
    00799     bool    mIntelligent;
    00800 #endif
    00801
    00802 };
    00803
    00804
    00809 class FBXSDK_DLL FbxAnimCurveFilterScale : public FbxAnimCurveFilter
    00810 {
    00811 public:
    00813     FbxAnimCurveFilterScale();
    00814
    00816     virtual ~FbxAnimCurveFilterScale() {};
    00817
    00821     virtual const char* GetName() const;
    00822
    00827     virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    00828     virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    00829     virtual bool Apply(FbxAnimCurve** pCurve, int pCount)              { return FbxAnimCurveFilter::Apply(pCurve, pCount); }
    00831
    00838     virtual bool Apply(FbxAnimCurveNode& pCurveNode);
    00839
    00844     virtual bool Apply(FbxAnimCurve& pCurve);
    00845
    00848     virtual void Reset();
    00849
    00853     double GetScale() const;
    00854
    00858     void SetScale(double pScale);
    00859
    00861 //
    00862 //  WARNING!
    00863 //
    00864 //  Anything beyond these lines may not be documented accurately and is
    00865 //  subject to change without notice.
    00866 //
    00868
    00869 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00870 private:
    00871     double mScale;
    00872 #endif
    00873 };
    00874
    00875
    00880 class FBXSDK_DLL FbxAnimCurveFilterTSS : public FbxAnimCurveFilter
    00881 {
    00882 public:
    00884     FbxAnimCurveFilterTSS();
    00885
    00887     virtual ~FbxAnimCurveFilterTSS() {};
    00888
    00892     virtual const char* GetName() const;
    00893
    00898     virtual bool Apply(FbxAnimStack* pAnimStack)                       { return FbxAnimCurveFilter::Apply(pAnimStack); }
    00899     virtual bool Apply(FbxObject* pObj, FbxAnimStack* pAnimStack)     { return FbxAnimCurveFilter::Apply(pObj, pAnimStack); }
    00900     virtual bool Apply(FbxAnimCurveNode& pCurveNode)                   { return FbxAnimCurveFilter::Apply(pCurveNode); }
    00901     virtual bool Apply(FbxAnimCurve** pCurve, int pCount)              { return FbxAnimCurveFilter::Apply(pCurve, pCount); }
    00903
    00908     virtual bool Apply(FbxAnimCurve& pCurve);
    00909
    00912     virtual void Reset();
    00913
    00917     FbxTime GetShift() const;
    00918
    00922     void SetShift(FbxTime& pShift);
    00923
    00927     double GetScale() const;
    00928
    00932     void SetScale(double pScale);
    00933
    00935 //
    00936 //  WARNING!
    00937 //
    00938 //  Anything beyond these lines may not be documented accurately and is
    00939 //  subject to change without notice.
    00940 //
    00942 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    00943 private:
    00944     FbxTime  mShift;
    00945     double  mScale;
    00946 #endif
    00947 };
    00948
    00964 class FBXSDK_DLL FbxAnimCurveFilterUnroll : public FbxAnimCurveFilter
    00965 {
    00966 public:
    00968     FbxAnimCurveFilterUnroll();
    00969
    00971     virtual ~FbxAnimCurveFilterUnroll() {};
    00972
    00976     virtual const char* GetName() const;
    00977
    00983     virtual bool NeedApply(FbxAnimStack* /*pAnimStack*/) { return false; };
    00984
    00991     virtual bool NeedApply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }
    00992
    01000     virtual bool NeedApply(FbxAnimCurveNode& pCurveNode);
    01001
    01011     virtual bool NeedApply(FbxAnimCurve** pCurve, int pCount);
    01012
    01016     virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; };
    01017
    01023     virtual bool Apply(FbxAnimStack* /*pAnimStack*/) { return false; };
    01024
    01031     virtual bool Apply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }
    01032
    01038     virtual bool Apply(FbxAnimCurveNode& pCurveNode);
    01039
    01048     virtual bool Apply(FbxAnimCurve** pCurve, int pCount);
    01049
    01053     virtual bool Apply(FbxAnimCurve& /*pCurve*/) { return false; }
    01054
    01057     virtual void Reset();
    01058
    01063     double GetQualityTolerance() const;
    01064
    01069     void SetQualityTolerance(double pQualityTolerance);
    01070
    01081     bool GetTestForPath() const;
    01082
    01093     void SetTestForPath(bool pTestForPath);
    01094
    01101     bool GetForceAutoTangents() const;
    01102
    01109     void SetForceAutoTangents(bool pForceAutoTangents);
    01110
    01112 //
    01113 //  WARNING!
    01114 //
    01115 //  Anything beyond these lines may not be documented accurately and is
    01116 //  subject to change without notice.
    01117 //
    01119 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    01120
    01121     void SetRotationOrder(int pOrder);
    01122
    01123 private:
    01124     double  InterpolationQualityFactor(FbxVector4& lV1, FbxVector4& lV2);
    01125
    01126     double          mQualityTolerance;
    01127     bool            mTestForPath;
    01128     bool            mForceAutoTangents;
    01129     int             mRotationOrder;
    01130     int             mRotationLayerType;
    01131 #endif
    01132 };
    01133
    01141 class FBXSDK_DLL FbxAnimCurveFilterMatrixConverter : public FbxAnimCurveFilter
    01142 {
    01143 public:
    01145     FbxAnimCurveFilterMatrixConverter();
    01146
    01148     virtual ~FbxAnimCurveFilterMatrixConverter();
    01149
    01153     virtual const char* GetName() const;
    01154
    01159     virtual bool NeedApply(FbxAnimCurve** pCurve, int pCount)          { return FbxAnimCurveFilter::NeedApply(pCurve, pCount); }
    01161
    01167     virtual bool NeedApply(FbxAnimStack* /*pAnimStack*/) { return false; }
    01168
    01175     virtual bool NeedApply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }
    01176
    01185     virtual bool NeedApply(FbxAnimCurveNode* pCurveNode[3]);
    01186
    01190     virtual bool NeedApply(FbxAnimCurve& /*pCurve*/) { return false; }
    01191
    01197     virtual bool Apply(FbxAnimStack* /*pAnimStack*/) { return false; }
    01198
    01205     virtual bool Apply(FbxObject* /*pObj*/, FbxAnimStack* /*pAnimStack*/) { return false; }
    01206
    01214     virtual bool Apply(FbxAnimCurveNode* pCurveNode[3]);
    01215
    01228     virtual bool Apply(FbxAnimCurve** pCurve, int pCount);
    01229
    01240     bool Apply(FbxAnimCurve** pCurve, double* pVals);
    01241
    01245     virtual bool Apply(FbxAnimCurve& /*pCurve*/) { return false; };
    01246
    01249     virtual void Reset();
    01250
    01265     enum EMatrixIndex
    01266     {
    01267         ePreGlobal,
    01268         ePreTranslate,
    01269         ePostTranslate,
    01270         ePreRotate,
    01271         ePostRotate,
    01272         ePreScale,
    01273         ePostScale,
    01274         ePostGlobal,
    01275         eScaleOffset,
    01276         eInactivePre,
    01277         eInactivePost,
    01278         eRotationPivot,
    01279         eScalingPivot,
    01280         eMatrixIndexCount
    01281     };
    01282
    01287     void GetSourceMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix) const;
    01288
    01293     void SetSourceMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix);
    01294
    01299     void GetDestMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix) const;
    01300
    01305     void SetDestMatrix(EMatrixIndex pIndex, FbxAMatrix& pMatrix);
    01306
    01310     FbxTime GetResamplingPeriod () const;
    01311
    01315     void SetResamplingPeriod (FbxTime& pResamplingPeriod);
    01316
    01321     bool GetGenerateLastKeyExactlyAtEndTime() const;
    01322
    01327     void SetGenerateLastKeyExactlyAtEndTime(bool pFlag);
    01328
    01332     bool GetResamplingOnFrameRateMultiple() const;
    01333
    01342     void SetResamplingOnFrameRateMultiple(bool pFlag);
    01343
    01349     bool GetApplyUnroll() const;
    01350
    01355     void SetApplyUnroll(bool pFlag);
    01356
    01360     bool GetApplyConstantKeyReducer() const;
    01361
    01366     void SetApplyConstantKeyReducer(bool pFlag);
    01367
    01373     bool GetResampleTranslation() const;
    01374
    01380     void SetResampleTranslation(bool pFlag);
    01381
    01385     void SetSrcRotateOrder(int pOrder);
    01386
    01390     void SetDestRotateOrder(int pOrder);
    01391
    01395     void SetForceApply(bool pVal);
    01396
    01400     bool GetForceApply() const;
    01402 //
    01403 //  WARNING!
    01404 //
    01405 //  Anything beyond these lines may not be documented accurately and is
    01406 //  subject to change without notice.
    01407 //
    01409 #ifndef DOXYGEN_SHOULD_SKIP_THIS
    01410 private:
    01411     // Nicer than referring to 0, 1, 2...
    01412     enum EAxisIndex {eX, eY, eZ, eAxisCount};
    01413
    01414     // Convert parameter cell.
    01415     class Cell;
    01416
    01417     bool MatricesEquivalence(FbxAMatrix pMatArrayA [eMatrixIndexCount], FbxAMatrix pMatArrayB [eMatrixIndexCount]) const;
    01418
    01419     bool DoConvert(FbxAnimCurve** pCurve,
    01420                     double pT[eAxisCount],
    01421                     double pR[eAxisCount],
    01422                     double pS[eAxisCount]);
    01423
    01424     void FindTimeInterval
    01425     (
    01426         FbxTime& pStart,
    01427         FbxTime& pEnd,
    01428         FbxAnimCurve* pTFCurve [eAxisCount],
    01429         FbxAnimCurve* pRFCurve [eAxisCount],
    01430         FbxAnimCurve* pSFCurve [eAxisCount]
    01431     );
    01432
    01433     void ComputeTotalMatrix
    01434     (
    01435         FbxAMatrix& pGlobal,
    01436         Cell& pCell,
    01437         FbxAMatrix& pTranslate,
    01438         FbxAMatrix& pRotate,
    01439         FbxAMatrix& pScale
    01440     );
    01441
    01442     void ExtractTransforms
    01443     (
    01444         FbxVector4& pScaleVector,
    01445         FbxVector4& pRotateVector,
    01446         FbxVector4& pTranslateVector,
    01447         FbxAMatrix& pGlobal,
    01448         Cell& pDest
    01449     );
    01450
    01451     void SetDestFCurve(FbxAnimCurve* pCurve [eAxisCount],
    01452                        int pIndex,
    01453                        FbxTime pTime,
    01454                        FbxVector4 pVector,
    01455                        FbxAnimCurveDef::EInterpolationType pInterpMode[eAxisCount],
    01456                        FbxAnimCurveDef::ETangentMode pTangentMode[eAxisCount]);
    01457
    01458     void FillInterpAndTangeant(FbxTime& pTime,
    01459                                FbxAnimCurve* pSourceCurve[eAxisCount],
    01460                                FbxAnimCurveDef::EInterpolationType* pInterp,
    01461                                FbxAnimCurveDef::ETangentMode* pTangeant);
    01462
    01463     void SetDestFCurveTangeant(FbxAnimCurve* pCurve [eAxisCount],
    01464                                int pIndex,
    01465                                FbxAnimCurveDef::ETangentMode pTangentMode[eAxisCount],
    01466                                FbxVector4 pKeyValue,
    01467                                FbxVector4 pNextKeyValue);
    01468
    01469     Cell* mSource;
    01470     Cell* mDest;
    01471
    01472     FbxTime mResamplingPeriod;
    01473     bool mResamplingOnFrameRateMultiple;
    01474
    01475     bool mApplyUnroll;
    01476     bool mApplyConstantKeyReducer;
    01477
    01478     // PP : So that the concatenation of matrices takes into account the rotation order
    01479     FbxRotationOrder* mSrcRotationOrder;
    01480     FbxRotationOrder* mDestRotationOrder;
    01481
    01482     // Set last key exactly at end time or a frame period later.
    01483     bool mGenerateLastKeyExactlyAtEndTime;
    01484
    01485     // Translation re-sampling flag.
    01486     bool mResampleTranslation;
    01487
    01488     // Force Apply
    01489     bool mForceApply;
    01490
    01491     // internal usage
    01492     FbxAnimCurveNode* mRotationCurveNode;
    01493 #endif
    01494 };
    01495
    01496 #include <fbxsdk/fbxsdk_nsend.h>
    01497
    01498 #endif /* _FBXSDK_SCENE_ANIMATION_CURVE_FILTERS_H_ */