Show in Contents

Add to Favorites

Home: FBX SDK Programmers Guide

 

 

 

FBX SDK Reference Guide: kfbxkfcurvefilters.h Source File

Go to the documentation of this file.

#ifndef _FBXSDK_KFBXKFCURVE_FILTERS_H_
#define _FBXSDK_KFBXKFCURVE_FILTERS_H_

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

 Copyright © 2001 - 2008 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 <kaydaradef.h>
#ifndef KFBX_DLL
    #define KFBX_DLL K_DLLIMPORT
#endif

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


#include <fbxfilesdk_nsbegin.h>
class KFCurve;
class KFCurveNode;
class KFCurveFilterConstantKeyReducer;
class KFCurveFilterMatrixConverter;
class KFCurveFilterResample;
class KFCurveFilterUnroll;
class KFCurveFilter;

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

public:
    virtual const char* GetName() {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(KFCurve& pCurve){return 0;}

    virtual int GetStopKey(KFCurve& pCurve){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;}

    virtual void Reset(){return ;}

    virtual KError& GetError(){return GetError();}

    virtual int GetLastErrorID(){return -1;}

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

protected:
    KFbxKFCurveFilters(KFbxSdkManager& pManager, char const* pName);
    virtual ~KFbxKFCurveFilters();
    virtual void Destruct(bool pRecursive, bool pDependents);
    KTime mTime;
#endif
};




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

public:


    const char* GetName();

    KTime& GetStartTime();

    void SetStartTime(KTime& pTime);

    KTime& GetStopTime();

    void SetStopTime(KTime& pTime);

    int GetStartKey(KFCurve& pCurve);

    int GetStopKey(KFCurve& pCurve);

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

    bool NeedApply(KFCurve** pCurve, int pCount);

    bool NeedApply(KFCurve& pCurve);

    KError& GetError();

    int GetLastErrorID() const;

    const char* GetLastErrorString() const;

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

    bool Apply(KFCurve** pCurve, int pCount);

    bool Apply(KFCurve& pCurve);

    void Reset();

    double GetDerivativeTolerance();

    void SetDerivativeTolerance(double pValue);

    double GetValueTolerance();

    void SetValueTolerance(double pValue);

    bool GetKeepFirstAndLastKeys();

    void SetKeepFirstAndLastKeys( bool pKeepFirstAndLastKeys );

    bool GetKeepOneKey();

    void SetKeepOneKey( bool pKeepOneKey );

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

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

#endif
};




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

public:

    const char* GetName();

    KTime& GetStartTime();

    void SetStartTime(KTime& pTime);

    KTime& GetStopTime();

    void SetStopTime(KTime& pTime);

    int GetStartKey(KFCurve& pCurve);

    int GetStopKey(KFCurve& pCurve);

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

    bool NeedApply(KFCurve** pCurve, int pCount);

    bool NeedApply(KFCurve& pCurve);

    KError& GetError();

    int GetLastErrorID() const;

    const char* GetLastErrorString() const;

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

    bool Apply(KFCurve** pCurve, int pCount);

    bool Apply(KFCurve& pCurve);

    void Reset();

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

    void GetSourceMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

    void SetSourceMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

    void GetDestMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

    void SetDestMatrix(EMatrixID pIndex, KFbxXMatrix& pMatrix);

    KTime GetResamplingPeriod ();

    void SetResamplingPeriod (KTime& pResamplingPeriod);

    bool GetGenerateLastKeyExactlyAtEndTime();

    void SetGenerateLastKeyExactlyAtEndTime(bool pFlag);

    bool GetResamplingOnFrameRateMultiple();

    void SetResamplingOnFrameRateMultiple(bool pFlag);

    bool GetApplyUnroll();

    void SetApplyUnroll(bool pFlag);

    bool GetApplyConstantKeyReducer();

    void SetApplyConstantKeyReducer(bool pFlag);

    bool GetResampleTranslation();

    void SetResampleTranslation(bool pFlag);

    void SetSrcRotateOrder(int pOrder);

    void SetDestRotateOrder(int pOrder);

    void SetForceApply(bool pVal);

    bool GetForceApply();
//
//  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);
    virtual ~KFbxKFCurveFilterMatrixConverter();
    KFCurveFilterMatrixConverter *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);
#endif
};




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

public:
    const char* GetName();

    KTime& GetStartTime();

    void SetStartTime(KTime& pTime);

    KTime& GetStopTime();

    void SetStopTime(KTime& pTime);

    int GetStartKey(KFCurve& pCurve);

    int GetStopKey(KFCurve& pCurve);

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

    bool NeedApply(KFCurve** pCurve, int pCount);

    bool NeedApply(KFCurve& pCurve);

    KError& GetError();

    int GetLastErrorID() const;

    const char* GetLastErrorString() const;

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

    bool Apply(KFCurve** pCurve, int pCount);

    bool Apply(KFCurve& pCurve);

    void Reset();

    void SetKeysOnFrame(bool pKeysOnFrame);

    bool GetKeysOnFrame();

    KTime GetPeriodTime();

    void SetPeriodTime(KTime &pPeriod);


    bool  GetIntelligentMode();

    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);
    virtual ~KFbxKFCurveFilterResample();
    KFCurveFilterResample *mDataCurveFilter;
    virtual void Destruct(bool pRecursive, bool pDependents);
#endif

};

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

public:

    const char* GetName();

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

    void SetStopTime(KTime& pTime);

    int GetStartKey(KFCurve& pCurve);
    int GetStopKey(KFCurve& pCurve);

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

    bool NeedApply(KFCurve** pCurve, int pCount);

    bool NeedApply(KFCurve& pCurve);

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

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

    bool Apply(KFCurve** pCurve, int pCount);

    bool Apply(KFCurve& pCurve);

    void Reset();

    double GetQualityTolerance();

    void SetQualityTolerance(double pQualityTolerance);

    bool GetTestForPath();

    void SetTestForPath(bool pTestForPath);

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

#include <fbxfilesdk_nsend.h>

#endif // #ifndef _FBXSDK_KFXKFCURVE_FILTERS_H_