kfbxanimcurve.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVE_H
#define FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVE_H

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

 Copyright (C) 2009 - 2010 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 <fbxfilesdk/components/kfcurve/kfcurve.h>
#include <fbxfilesdk/kfbxplugins/kfbxanimcurvebase.h>
#include <fbxfilesdk/kfbxplugins/kfbxobject.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFbxAnimCurveDef {

public:
    static const int   kWEIGHT_DIVIDER = 9999; // precise enough and can be divided by 3 without error
    static const float kDEFAULT_WEIGHT;
    static const float kMIN_WEIGHT;
    static const float kMAX_WEIGHT;
    static const float kDEFAULT_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_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 {
        // User and Break tangent mode (data are float).
        eRIGHT_SLOPE            = KFCURVEKEY_RIGHT_SLOPE, 
        eNEXT_LEFT_SLOPE        = KFCURVEKEY_NEXT_LEFT_SLOPE, 

        // User and Break tangent break mode (data are kInt16 tokens from weight and converted to float).
        eWEIGHTS                = KFCURVEKEY_WEIGHTS, 
        eRIGHT_WEIGHT           = KFCURVEKEY_RIGHT_WEIGHT, 
        eNEXT_LEFT_WEIGHT       = KFCURVEKEY_NEXT_LEFT_WEIGHT, 

        // Velocity mode
        eVELOCITY               = KFCURVEKEY_VELOCITY,
        eRIGHT_VELOCITY         = KFCURVEKEY_RIGHT_VELOCITY,
        eNEXT_LEFT_VELOCITY     = KFCURVEKEY_NEXT_LEFT_VELOCITY, 

        // TCB tangent mode (data are floats).
        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 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::kDEFAULT_WEIGHT,float pWeight1 = KFbxAnimCurveDef::kDEFAULT_WEIGHT,float pVelocity0 = KFbxAnimCurveDef::kDEFAULT_VELOCITY,float pVelocity1 = KFbxAnimCurveDef::kDEFAULT_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 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