kfbxanimcurvekfcurve.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_KFBXANIMCURVEKFCURVE_H
#define FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEKFCURVE_H

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

class KSet;

class KFBX_DLL KFbxAnimCurveKFCurveKey : public KFbxAnimCurveKeyImpl
{
private:
    KFCurveKey mKey;

public:

    static KFbxAnimCurveKeyImpl* AllocatorFct()
    {
        return FbxSdkNew<KFbxAnimCurveKFCurveKey>();
    }

    static KFbxAnimCurveKeyImpl* CopyAllocatorFct(KFbxAnimCurveKeyImpl* pImpl)
    {
        return FbxSdkNew<KFbxAnimCurveKFCurveKey>(*((KFbxAnimCurveKFCurveKey*)pImpl));
    }

    static void DeallocatorFct(KFbxAnimCurveKeyImpl* pImpl)
    {
        FbxSdkDelete<KFbxAnimCurveKFCurveKey>((KFbxAnimCurveKFCurveKey*)pImpl);
    }

    KFbxAnimCurveKFCurveKey() : KFbxAnimCurveKeyImpl()
    {
        KTime lTime = GetTime();
        SetTime(lTime);
        mKey.Set(lTime, 0.0);
    };

    virtual ~KFbxAnimCurveKFCurveKey()
    {
        // nothing specific to do!
    }

    KFbxAnimCurveKFCurveKey(KTime pTime) : KFbxAnimCurveKeyImpl()
    {
        SetTime(pTime);
        mKey.Set(pTime, 0.0);
    }

    KFbxAnimCurveKFCurveKey(KTime pTime, float pVal) : KFbxAnimCurveKeyImpl()
    {
        SetTime(pTime);
        mKey.Set(pTime, pVal);

    }

    KFbxAnimCurveKFCurveKey(KFbxAnimCurveKFCurveKey const& pFKey) : KFbxAnimCurveKeyImpl()
    {
        mKey = pFKey.mKey;
        SetTime(mKey.GetTime());
    };

    KFbxAnimCurveKFCurveKey(KFCurveKey const& pFKey) : KFbxAnimCurveKeyImpl()
    {
        mKey = pFKey;
        SetTime(mKey.GetTime());
    };

    KFbxAnimCurveKeyImpl& operator=(const KFbxAnimCurveKeyImpl& pFKey)
    {
        *this = *((KFbxAnimCurveKFCurveKey*)&pFKey);
        return *this;
    }

    KFbxAnimCurveKFCurveKey& operator=(const KFbxAnimCurveKFCurveKey& pFKey)
    {
        SetTime(pFKey.GetTime());
        mKey = pFKey.mKey;
        return *this;
    }

    operator KFCurveKey&()
    { 
        return mKey; 
    };

    KFCurveKey* GetKFCurveKey()
    {
        return &mKey;
    };

    /* \name Key time, values, data.
    */

    virtual KTime GetTime() const
    {
        return mKey.GetTime();
    };

    virtual void  SetTime(const KTime& pTime)
    {
        mKey.SetTime(pTime);
    };

    void Set(KTime pTime, float pValue)
    {
        mKey.Set(pTime, pValue);
    }

    void SetTCB(KTime pTime, float pValue, float pData0 = 0.0f, float pData1 = 0.0f, float pData2 = 0.0f)
    {
        mKey.SetTCB(pTime, pValue, pData0, pData1, pData2);
    }

    float GetValue() const
    {
        return mKey.GetValue();
    }

    void SetValue(float pValue)
    {
        mKey.SetValue(pValue);
    }

    KFbxAnimCurveDef::EInterpolationType GetInterpolation() const
    {
        return KFbxAnimCurveDef::EInterpolationType(mKey.GetInterpolation());
    }

    void SetInterpolation (KFbxAnimCurveDef::EInterpolationType pInterpolation)
    {
        mKey.SetInterpolation(pInterpolation);
    }

    KFbxAnimCurveDef::ETangentMode GetTangentMode(bool pIncludeOverrides = false) const
    {
        return KFbxAnimCurveDef::ETangentMode(mKey.GetTangeantMode(pIncludeOverrides));
    }

    void SetTangentMode (KFbxAnimCurveDef::ETangentMode pTangentMode)
    {
        bool lTI = (pTangentMode&KFbxAnimCurveDef::eTANGENT_GENERIC_TIME_INDEPENDENT)==KFbxAnimCurveDef::eTANGENT_GENERIC_TIME_INDEPENDENT;
        mKey.SetTangeantMode(pTangentMode, lTI==false);
    }

    KFbxAnimCurveDef::EWeightedMode GetTangentWeightMode() const
    {
        return KFbxAnimCurveDef::EWeightedMode(mKey.GetTangeantWeightMode());
    }

    void SetTangentWeightMode(KFbxAnimCurveDef::EWeightedMode pTangentWeightMode, KFbxAnimCurveDef::EWeightedMode pMask = KFbxAnimCurveDef::eWEIGHTED_ALL )
    {
        mKey.SetTangeantWeightMode(pTangentWeightMode, pMask);
    }


    KFbxAnimCurveDef::EVelocityMode GetTangentVelocityMode() const
    {
        return KFbxAnimCurveDef::EVelocityMode(mKey.GetTangeantVelocityMode());
    }

    void SetTangentVelocityMode(KFbxAnimCurveDef::EVelocityMode pTangentVelocityMode, KFbxAnimCurveDef::EVelocityMode pMask = KFbxAnimCurveDef::eVELOCITY_ALL )
    {
        mKey.SetTangeantVelocityMode(pTangentVelocityMode, pMask);
    }

    KFbxAnimCurveDef::EConstantMode GetConstantMode() const
    {
        return KFbxAnimCurveDef::EConstantMode(mKey.GetConstantMode());
    }

    void SetConstantMode(KFbxAnimCurveDef::EConstantMode pMode)
    {
        mKey.SetConstantMode(pMode);
    }

    float GetDataFloat(KFbxAnimCurveDef::EKFbxAnimCurveDataIndex pIndex) const
    {
        // VR: The way KFCurveKey::GetDataFloat() and GetDataDouble() are implemented are different.
        // GetDataDouble() works for cases USER, AUTO, BREAK, etc, which have 2 or 4 float values to store.
        // GetDataFloat() works for the TCB case which has 3 float values (Tension, Continuity and Bias).
        // It is not my purpose to modify KFCurveKey at this point, so we use GetDataDouble in general,
        // and GetDataFloat in the case of a TCB.

        if (GetTangentMode() == KFbxAnimCurveDef::eTANGENT_TCB)
        {
            return mKey.GetDataFloat(EKFCurveDataIndex(pIndex));
        }

        return (float)mKey.GetDataDouble(EKFCurveDataIndex(pIndex));
    }

    void SetDataFloat(KFbxAnimCurveDef::EKFbxAnimCurveDataIndex pIndex, float pValue)
    {
        // VR: The way KFCurveKey::SetDataFloat() and SetDataDouble() are implemented are different.
        // SetDataDouble() works for cases USER, AUTO, BREAK, etc, which have 2 or 4 float values to store.
        // SetDataFloat() works for the TCB case which has 3 float values (Tension, Continuity and Bias).
        // It is not my purpose to modivy KFCurveKey at this point, so we use SetDataDouble in general,
        // and SetDataFloat in the case of a TCB.

        if (GetTangentMode() == KFbxAnimCurveDef::eTANGENT_TCB)
        {
            mKey.SetDataFloat(EKFCurveDataIndex(pIndex), pValue);
        }

        mKey.SetDataDouble(EKFCurveDataIndex(pIndex), (kFCurveDouble)pValue);
    }

    void    SetTangentVisibility (KFbxAnimCurveDef::ETangentVisibility pVisibility)
    {
        mKey.SetTangeantVisibility(pVisibility);
    }

    KFbxAnimCurveDef::ETangentVisibility GetTangentVisibility () const
    {
        return KFbxAnimCurveDef::ETangentVisibility(mKey.GetTangeantVisibility());
    }

    void SetBreak(bool pVal)
    {
        mKey.SetBreak(pVal);
    }

    bool GetBreak() const
    {
        return mKey.GetBreak();
    }
};


class KFBX_DLL KFbxAnimCurveKFCurve : public KFbxAnimCurve
{
    KFBXOBJECT_DECLARE(KFbxAnimCurveKFCurve, KFbxAnimCurve);

public:

        void ResizeKeyBuffer(int pKeyCount);

        void KeyModifyBegin ();
        
        void KeyModifyEnd ();

        void KeyShrink();

        virtual void KeyClear (); 
       
        virtual int KeyGetCount () const;
  
        int KeyAdd (KTime pTime, KFbxAnimCurveKeyBase& pKey, int* pLast = NULL); 

        int KeyAdd (KTime pTime, int* pLast = NULL) 
        {   
            KFbxAnimCurveKFCurveKey key(pTime);
            return KeyAdd(pTime, key, pLast); 
        }

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

        bool KeyRemove(int pStartIndex, int pEndIndex);

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

        bool KeyScaleValue (float pMultValue);

        bool KeyScaleValueAndTangent (float pMultValue);

        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
        );

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

        KFbxAnimCurveDef::EInterpolationType KeyGetInterpolation(int pKeyIndex) const;

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

        KFbxAnimCurveDef::EConstantMode KeyGetConstantMode(int pKeyIndex) const;

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

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

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

        KFbxAnimCurveKey KeyGet(int pIndex) const;

        float KeyGetValue(int pKeyIndex) const;

        void KeySetValue(int pKeyIndex, float pValue);

        void KeyIncValue(int pKeyIndex, float pValue);

        void KeyMultValue(int pKeyIndex, float pValue);

        void KeyMultTangent(int pKeyIndex, float pValue);

        virtual KTime KeyGetTime(int pKeyIndex) const;

        virtual void KeySetTime(int pKeyIndex, KTime pTime);

        void KeySetBreak(int pKeyIndex, bool pVal); 

        bool KeyGetBreak(int pKeyIndex) const; 

        float KeyGetLeftDerivative(int pIndex);

        void KeySetLeftDerivative(int pIndex, float pValue);

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

        KFCurveTangeantInfo KeyGetLeftDerivativeInfo(kFCurveIndex pIndex);

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

        float KeyGetRightDerivative(int pIndex);

        void KeySetRightDerivative(int pIndex, float pValue);

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

        KFCurveTangeantInfo KeyGetRightDerivativeInfo(kFCurveIndex pIndex);

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

        bool KeyIsLeftTangentWeighted(int pIndex) const;

        bool KeyIsRightTangentWeighted(int pIndex) const;

        float KeyGetLeftTangentWeight(int pIndex) const;

        float KeyGetRightTangentWeight(int pIndex) const;

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

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

        float KeyGetLeftTangentVelocity( int pIndex) const;

        float KeyGetRightTangentVelocity( int pIndex) const;


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

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

        float GetValue() const;

        K_DEPRECATED virtual bool GetTimeInterval(KTime& pStart, KTime& pStop);

        virtual bool GetTimeInterval(KTimeSpan& pTimeInterval);

        void SetColor(float *pColor);

        float* GetColor();

        KFCurve* GetKFCurve();

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

#ifndef DOXYGEN_SHOULD_SKIP_THIS

    //  WARNING!
    //    Anything beyond these lines may not be documented accurately and is 
    //     subject to change without notice.
    virtual int KeyAdd (KTime pTime, KFbxAnimCurveKFCurveKey& pKey, int* pLast = 0);
    virtual bool KeySet(int pIndex, KFbxAnimCurveKFCurveKey& pKey);

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

    virtual void Construct(const KFbxAnimCurve* pFrom);
    virtual void Destruct(bool pRecursive, bool pDependents);
 
    friend void CollectAnimFromCurveNode(KFCurve **lSrc, KFCurveNode *fcn, unsigned int nbCrvs, KFbxAnimCurveNode *cn, KSet* pNickToAnimCurveTimeWarpsSet, KSet& pNickToKFCurveNodeWarpSet);
    friend void TransferTimeWarp(int lNickNumber, KFCurveNode* lTimeWarp, KSet& mNickToKFCurveNodeTimeWarpsSet, KSet& pTimeWarpSet, KFbxScene& pScene);
    
    void SetKFCurve(KFCurve *lKFCurve);
    KFCurve* mFCurve;

public:
    virtual bool Store(KFbx* pFileObject);
            bool LegacyStore(KFbx* pFileObject); // this one can only exist in this class and should not be inherited!
    virtual bool Retrieve(KFbx* pFileObject);
 
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEKFCURVE_H