kfbxanimcurvekfcurve.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEKFCURVE_H
#define FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEKFCURVE_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/kfbxanimcurve.h>
#include <fbxfilesdk/kfbxplugins/kfbxobject.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

static void CollectAnimFromCurveNode(KFCurve **lSrc, KFCurveNode *fcn, unsigned int nbCrvs, KFbxAnimCurveNode *cn);

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

    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 modivy 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:

    float GetValue() const;

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

        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::kDEFAULT_WEIGHT,
            float pWeight1 = KFbxAnimCurveDef::kDEFAULT_WEIGHT,
            float pVelocity0 = KFbxAnimCurveDef::kDEFAULT_VELOCITY,
            float pVelocity1 = KFbxAnimCurveDef::kDEFAULT_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);

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

        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);
    void SetKFCurve(KFCurve *lKFCurve);
    KFCurve* mFCurve;

public:
    virtual bool Store(KFbx* pFileObject);
    virtual bool Retrieve(KFbx* pFileObject);

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVEKFCURVE_H