kfbxanimcurve.h

Go to the documentation of this file.

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

Copyright (C) 2010 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 FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVE_H
#define FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVE_H

#include <fbxfilesdk/components/kfcurve/kfcurve.h>
#include <fbxfilesdk/kfbxplugins/kfbxanimcurvebase.h>
#include <fbxfilesdk/kfbxplugins/kfbxobject.h>
#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFBX_DLL KFbxAnimCurveDef {

public:
    static const int   sWEIGHT_DIVIDER = 9999; // precise enough and can be divided by 3 without error
    static const float sDEFAULT_WEIGHT;
    static const float sMIN_WEIGHT;
    static const float sMAX_WEIGHT;
    static const float sDEFAULT_VELOCITY;

    typedef enum {
        eTANGENT_AUTO                     = KFCURVE_TANGEANT_AUTO,
        eTANGENT_TCB                      = KFCURVE_TANGEANT_TCB,
        eTANGENT_USER                     = KFCURVE_TANGEANT_USER,
        eTANGENT_BREAK                    = KFCURVE_TANGEANT_BREAK,
        eTANGENT_AUTO_BREAK               = KFCURVE_TANGEANT_AUTO_BREAK,
        eTANGENT_GENERIC_CLAMP            = KFCURVE_GENERIC_CLAMP,
        eTANGENT_GENERIC_CLAMP_PROGRESSIVE= KFCURVE_GENERIC_CLAMP_PROGRESSIVE,
        eTANGENT_GENERIC_TIME_INDEPENDENT = KFCURVE_GENERIC_TIME_INDEPENDENT

    } ETangentMode;

    typedef enum {
        eINTERPOLATION_CONSTANT = KFCURVE_INTERPOLATION_CONSTANT,
        eINTERPOLATION_LINEAR   = KFCURVE_INTERPOLATION_LINEAR,
        eINTERPOLATION_CUBIC    = KFCURVE_INTERPOLATION_CUBIC,
        eINTERPOLATION_ALL      = KFCURVE_INTERPOLATION_ALL
    } EInterpolationType;

    typedef enum {
        eWEIGHTED_NONE      = KFCURVE_WEIGHTED_NONE,
        eWEIGHTED_RIGHT     = KFCURVE_WEIGHTED_RIGHT,
        eWEIGHTED_NEXT_LEFT = KFCURVE_WEIGHTED_NEXT_LEFT,
        eWEIGHTED_ALL       = KFCURVE_WEIGHTED_ALL
    } EWeightedMode;

    typedef enum {
        eCONSTANT_STANDARD  = KFCURVE_CONSTANT_STANDARD,
        eCONSTANT_NEXT      = KFCURVE_CONSTANT_NEXT,
        eCONSTANT_ALL       = KFCURVE_CONSTANT_ALL
    } EConstantMode;

    typedef enum {
        eVELOCITY_NONE  =       KFCURVE_VELOCITY_NONE,
        eVELOCITY_RIGHT =       KFCURVE_VELOCITY_RIGHT,
        eVELOCITY_NEXT_LEFT =   KFCURVE_VELOCITY_NEXT_LEFT,
        eVELOCITY_ALL       =   KFCURVE_VELOCITY_ALL
    } EVelocityMode;

    typedef enum {
        eTANGENT_SHOW_NONE      = KFCURVE_TANGEANT_SHOW_NONE,
        eTANGENT_SHOW_LEFT      = KFCURVE_TANGEANT_SHOW_LEFT,
        eTANGENT_SHOW_RIGHT     = KFCURVE_TANGEANT_SHOW_RIGHT,
        eTANGENT_SHOW_BOTH      = KFCURVE_TANGEANT_SHOW_BOTH
    } ETangentVisibility;

    typedef enum {
        eRIGHT_SLOPE            = KFCURVEKEY_RIGHT_SLOPE, 
        eNEXT_LEFT_SLOPE        = KFCURVEKEY_NEXT_LEFT_SLOPE, 

        eWEIGHTS                = KFCURVEKEY_WEIGHTS, 
        eRIGHT_WEIGHT           = KFCURVEKEY_RIGHT_WEIGHT, 
        eNEXT_LEFT_WEIGHT       = KFCURVEKEY_NEXT_LEFT_WEIGHT, 

        eVELOCITY               = KFCURVEKEY_VELOCITY,
        eRIGHT_VELOCITY         = KFCURVEKEY_RIGHT_VELOCITY,
        eNEXT_LEFT_VELOCITY     = KFCURVEKEY_NEXT_LEFT_VELOCITY, 

        eTCB_TENSION            = KFCURVEKEY_TCB_TENSION, 
        eTCB_CONTINUITY         = KFCURVEKEY_TCB_CONTINUITY, 
        eTCB_BIAS               = KFCURVEKEY_TCB_BIAS,

    } EKFbxAnimCurveDataIndex;
};

class KFBX_DLL KFbxAnimCurveKeyImpl
{
public:
    virtual ~KFbxAnimCurveKeyImpl() {};

    virtual KFbxAnimCurveKeyImpl& operator=(const KFbxAnimCurveKeyImpl& pFKey) = 0;

    virtual void Set(KTime pTime, float pValue) = 0;

    virtual void SetTCB(KTime pTime, float pValue, float pData0 = 0.0f, float pData1 = 0.0f, float pData2 = 0.0f) = 0;

    virtual float GetValue() const = 0;

    virtual void SetValue(float pValue) = 0;

    virtual KFbxAnimCurveDef::EInterpolationType GetInterpolation() const = 0;

    virtual void SetInterpolation (KFbxAnimCurveDef::EInterpolationType pInterpolation) = 0;

    virtual KFbxAnimCurveDef::ETangentMode GetTangentMode(bool pIncludeOverrides = false) const = 0;

    virtual void SetTangentMode (KFbxAnimCurveDef::ETangentMode pTangentMode) = 0;

    virtual KFbxAnimCurveDef::EWeightedMode GetTangentWeightMode() const = 0;

    virtual void SetTangentWeightMode(KFbxAnimCurveDef::EWeightedMode pTangentWeightMode, KFbxAnimCurveDef::EWeightedMode pMask = KFbxAnimCurveDef::eWEIGHTED_ALL ) = 0;

    virtual KFbxAnimCurveDef::EVelocityMode GetTangentVelocityMode() const = 0;

    virtual void SetTangentVelocityMode(KFbxAnimCurveDef::EVelocityMode pTangentVelocityMode, KFbxAnimCurveDef::EVelocityMode pMask = KFbxAnimCurveDef::eVELOCITY_ALL ) = 0;

    virtual KFbxAnimCurveDef::EConstantMode GetConstantMode() const = 0;

    virtual void SetConstantMode(KFbxAnimCurveDef::EConstantMode pMode) = 0;

    virtual float GetDataFloat(KFbxAnimCurveDef::EKFbxAnimCurveDataIndex pIndex) const = 0;



    virtual void SetDataFloat(KFbxAnimCurveDef::EKFbxAnimCurveDataIndex pIndex, float pValue) = 0;

    virtual void    SetTangentVisibility (KFbxAnimCurveDef::ETangentVisibility pVisibility) = 0;    

    virtual KFbxAnimCurveDef::ETangentVisibility GetTangentVisibility () const = 0;

    virtual void SetBreak(bool pVal) = 0; 

    virtual bool GetBreak() const = 0; 
};

class KFBX_DLL KFbxAnimCurveKey : public KFbxAnimCurveKeyBase
{

public:

    KFbxAnimCurveKey() : KFbxAnimCurveKeyBase()
    {
        K_ASSERT(mAllocatorFct != NULL);
        mImpl = (*mAllocatorFct)();
    }

    KFbxAnimCurveKey(KTime pTime) : KFbxAnimCurveKeyBase()
    {
        K_ASSERT(mAllocatorFct != NULL);
        mImpl = (*mAllocatorFct)();
        SetTime(pTime);
    }

    KFbxAnimCurveKey(KTime pTime, float pVal) : KFbxAnimCurveKeyBase()
    {
        K_ASSERT(mAllocatorFct != NULL);
        mImpl = (*mAllocatorFct)();
        Set(pTime, pVal);
    }

    KFbxAnimCurveKey(KFbxAnimCurveKey const& pFKey) : KFbxAnimCurveKeyBase()
    {
        K_ASSERT(mCopyAllocatorFct != NULL);
        SetTime(pFKey.GetTime());
        mImpl = mCopyAllocatorFct(pFKey.GetImpl());
    }

    ~KFbxAnimCurveKey()
    {
        K_ASSERT(mDeallocatorFct != NULL);
        (*mDeallocatorFct)(mImpl);
    }

    KFbxAnimCurveKey& operator=(const KFbxAnimCurveKey& pFKey)
    {
        K_ASSERT(mImpl);
        if (mImpl)
        {
            *mImpl = *(pFKey.GetImpl());
        }
        SetTime(pFKey.GetTime());
        return *this;
    }

    KTime GetTime() const
    {
        return KFbxAnimCurveKeyBase::GetTime();
    }

    void SetTime(const KTime& pTime)
    {
        KFbxAnimCurveKeyBase::SetTime(pTime);
    }

    void Set(KTime pTime, float pValue)
    {
        KFbxAnimCurveKeyBase::SetTime(pTime);
        mImpl->Set(pTime, pValue);
    }

    void SetTCB(KTime pTime, float pValue, float pData0 = 0.0f, float pData1 = 0.0f, float pData2 = 0.0f)
    {
        KFbxAnimCurveKeyBase::SetTime(pTime);
        mImpl->SetTCB(pTime, pValue, pData0, pData1, pData2);
    }

    float GetValue() const
    {
        return mImpl->GetValue();
    }

    void SetValue(float pValue)
    {
        mImpl->SetValue(pValue);
    }

    KFbxAnimCurveDef::EInterpolationType GetInterpolation()
    {
        return mImpl->GetInterpolation();
    }

    void SetInterpolation (KFbxAnimCurveDef::EInterpolationType pInterpolation)
    {
        mImpl->SetInterpolation(pInterpolation);
    }

    KFbxAnimCurveDef::ETangentMode GetTangentMode(bool pIncludeOverrides = false)
    {
        return mImpl->GetTangentMode(pIncludeOverrides);
    }

    void SetTangentMode (KFbxAnimCurveDef::ETangentMode pTangentMode)
    {
        mImpl->SetTangentMode(pTangentMode);
    }

    KFbxAnimCurveDef::EWeightedMode GetTangentWeightMode() const
    {
        return mImpl->GetTangentWeightMode();
    }

    void SetTangentWeightMode(KFbxAnimCurveDef::EWeightedMode pTangentWeightMode, KFbxAnimCurveDef::EWeightedMode pMask = KFbxAnimCurveDef::eWEIGHTED_ALL )
    {
        mImpl->SetTangentWeightMode(pTangentWeightMode, pMask);
    }


    KFbxAnimCurveDef::EVelocityMode GetTangentVelocityMode() const
    {
        return mImpl->GetTangentVelocityMode();
    }

    void SetTangentVelocityMode(KFbxAnimCurveDef::EVelocityMode pTangentVelocityMode, KFbxAnimCurveDef::EVelocityMode pMask = KFbxAnimCurveDef::eVELOCITY_ALL )
    {
        mImpl->SetTangentVelocityMode(pTangentVelocityMode, pMask);
    }

    KFbxAnimCurveDef::EConstantMode GetConstantMode() const
    {
        return mImpl->GetConstantMode();
    }

    void SetConstantMode(KFbxAnimCurveDef::EConstantMode pMode)
    {
        mImpl->SetConstantMode(pMode);
    }

    float GetDataFloat(KFbxAnimCurveDef::EKFbxAnimCurveDataIndex pIndex) const
    {
        return mImpl->GetDataFloat(pIndex);
    }

    void SetDataFloat(KFbxAnimCurveDef::EKFbxAnimCurveDataIndex pIndex, float pValue)
    {
        mImpl->SetDataFloat(pIndex, pValue);
    }

    void    SetTangentVisibility (KFbxAnimCurveDef::ETangentVisibility pVisibility)
    {
        mImpl->SetTangentVisibility(pVisibility);
    }

    KFbxAnimCurveDef::ETangentVisibility GetTangentVisibility () const
    {
        return mImpl->GetTangentVisibility();
    }

    void SetBreak(bool pVal)
    {
        mImpl->SetBreak(pVal);
    }

    bool GetBreak() const
    {
        return mImpl->GetBreak();
    }

    KFbxAnimCurveKeyImpl* GetImpl() const
    {
        return mImpl;
    }

    static void SetAllocatorFct(KFbxAnimCurveKeyImpl* (*pAllocatorFct)());

    static void SetCopyAllocatorFct(KFbxAnimCurveKeyImpl* (*pCopyAllocatorFct)(KFbxAnimCurveKeyImpl*));

    static void SetDeallocatorFct(void (*pDeallocatorFct)(KFbxAnimCurveKeyImpl*));

private:
    static KFbxAnimCurveKeyImpl* (*mAllocatorFct)();
    static KFbxAnimCurveKeyImpl* (*mCopyAllocatorFct)(KFbxAnimCurveKeyImpl*);
    static void (*mDeallocatorFct)(KFbxAnimCurveKeyImpl*);
    KFbxAnimCurveKeyImpl* mImpl;
};


class KFbxScene;
class KFBX_DLL KFbxAnimCurve : public KFbxAnimCurveBase
{
    KFBXOBJECT_DECLARE_ABSTRACT(KFbxAnimCurve, KFbxAnimCurveBase);

public:

    static KFbxAnimCurve* Create(KFbxScene* pContainer, char const *pName);

    virtual void ResizeKeyBuffer(int pKeyCount) = 0;

    virtual void KeyModifyBegin () = 0;
        
    virtual void KeyModifyEnd () = 0;

    virtual void KeyClear () = 0;

    virtual int KeyGetCount () const = 0;

    virtual int KeyAdd (KTime pTime, KFbxAnimCurveKeyBase& pKey, int* pLast = NULL) = 0; 

    virtual int KeyAdd (KTime pTime, int* pLast = NULL) = 0;

    virtual bool KeySet(int pIndex,  KFbxAnimCurveKeyBase& pKey) = 0;
        
    virtual bool KeyRemove(int pIndex) = 0;

    virtual bool KeyRemove(int pStartIndex, int pEndIndex) = 0;

    virtual int KeyInsert ( KTime pTime, int* pLast = NULL ) = 0;
        
    virtual double KeyFind (KTime pTime, int* pLast = NULL) = 0;

    virtual bool KeyScaleValue (float pMultValue) = 0;

    virtual bool KeyScaleValueAndTangent (float pMultValue) = 0;

    virtual void KeySet(int pKeyIndex,KTime pTime, float pValue, KFbxAnimCurveDef::EInterpolationType pInterpolation = KFbxAnimCurveDef::eINTERPOLATION_CUBIC, KFbxAnimCurveDef::ETangentMode pTangentMode = KFbxAnimCurveDef::eTANGENT_AUTO, float pData0 = 0.0,float pData1 = 0.0,KFbxAnimCurveDef::EWeightedMode pTangentWeightMode = KFbxAnimCurveDef::eWEIGHTED_NONE, float pWeight0 = KFbxAnimCurveDef::sDEFAULT_WEIGHT,float pWeight1 = KFbxAnimCurveDef::sDEFAULT_WEIGHT,float pVelocity0 = KFbxAnimCurveDef::sDEFAULT_VELOCITY,float pVelocity1 = KFbxAnimCurveDef::sDEFAULT_VELOCITY) = 0;

    virtual void KeySetTCB(int pKeyIndex,KTime pTime, float pValue, float pData0 = 0.0f, float pData1 = 0.0f, float pData2 = 0.0f) = 0;

    virtual KFbxAnimCurveDef::EInterpolationType KeyGetInterpolation(int pKeyIndex) const = 0;

    virtual void KeySetInterpolation(int pKeyIndex, KFbxAnimCurveDef::EInterpolationType pInterpolation) = 0;

    virtual KFbxAnimCurveDef::EConstantMode KeyGetConstantMode(int pKeyIndex) const = 0;

    virtual KFbxAnimCurveDef::ETangentMode KeyGetTangentMode(int pKeyIndex, bool pIncludeOverrides = false ) const = 0;

    virtual void KeySetConstantMode(int pKeyIndex, KFbxAnimCurveDef::EConstantMode pMode) = 0;

    virtual void KeySetTangentMode(int pKeyIndex, KFbxAnimCurveDef::ETangentMode pTangent) = 0;

    virtual KFbxAnimCurveKey KeyGet(int pIndex) const = 0;

    virtual float KeyGetValue(int pKeyIndex) const = 0;

    virtual void KeySetValue(int pKeyIndex, float pValue) = 0;

    virtual void KeyIncValue(int pKeyIndex, float pValue) = 0;

    virtual void KeyMultValue(int pKeyIndex, float pValue) = 0;

    virtual void KeyMultTangent(int pKeyIndex, float pValue) = 0;

    virtual KTime KeyGetTime(int pKeyIndex) const = 0;

    virtual void KeySetTime(int pKeyIndex, KTime pTime) = 0;

    virtual void KeySetBreak(int pKeyIndex, bool pVal) = 0; 

    virtual bool KeyGetBreak(int pKeyIndex) const = 0; 

    virtual float KeyGetLeftDerivative(int pIndex) = 0;

    virtual void KeySetLeftDerivative(int pIndex, float pValue) = 0;

    virtual float KeyGetLeftAuto(int pIndex, bool pApplyOvershootProtection = false) = 0;

    virtual KFCurveTangeantInfo KeyGetLeftDerivativeInfo(int pIndex) = 0;

    virtual void KeySetLeftDerivativeInfo(kFCurveIndex pIndex, KFCurveTangeantInfo pValue, bool pForceDerivative = false) = 0;

    virtual float KeyGetRightDerivative(int pIndex) = 0;

    virtual void KeySetRightDerivative(int pIndex, float pValue) = 0;

    virtual float KeyGetRightAuto(int pIndex, bool pApplyOvershootProtection = false) = 0;

    virtual KFCurveTangeantInfo KeyGetRightDerivativeInfo(int pIndex) = 0;

    virtual void KeySetRightDerivativeInfo(kFCurveIndex pIndex, KFCurveTangeantInfo pValue, bool pForceDerivative = false) = 0;

    virtual bool KeyIsLeftTangentWeighted(int pIndex) const = 0;

    virtual bool KeyIsRightTangentWeighted(int pIndex) const = 0;

    virtual float KeyGetLeftTangentWeight(int pIndex) const = 0;

    virtual float KeyGetRightTangentWeight(int pIndex) const = 0;

    virtual void   KeySetLeftTangentWeight( int pIndex, float pWeight, bool pAdjustTan = false ) = 0;

    virtual void   KeySetRightTangentWeight( int pIndex, float pWeight, bool pAdjustTan = false  ) = 0;

    virtual float KeyGetLeftTangentVelocity( int pIndex) const = 0;

    virtual float KeyGetRightTangentVelocity( int pIndex) const = 0;


    virtual float Evaluate (KTime pTime, int* pLast = NULL) = 0;

    virtual float EvaluateIndex( double pIndex) = 0;
        
    virtual float EvaluateLeftDerivative (KTime pTime, int* pLast = NULL) = 0;
        
    virtual float EvaluateRightDerivative (KTime pTime, int* pLast = NULL) = 0;

    virtual bool GetTimeInterval(KTime& pStart, KTime& pStop) = 0;

    virtual bool GetTimeInterval(KTimeSpan& pTimeInterval) = 0;


    virtual KFCurve* GetKFCurve() = 0;

    virtual void CopyFrom(KFbxAnimCurve& pSource, bool pWithKeys = true) = 0;

#ifndef DOXYGEN_SHOULD_SKIP_THIS

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

    virtual bool Store(KFbx* pFileObject) = 0;
    virtual bool Retrieve(KFbx* pFileObject) = 0;

protected:
    KFbxAnimCurve(KFbxSdkManager& pManager, char const* pName);

    virtual void Construct(const KFbxAnimCurveBase* pFrom);
    virtual void Destruct(bool pRecursive, bool pDependents);

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVE_H