kfbxanimcurvenode.h

Go to the documentation of this file.

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

Copyright (C) 2011 Autodesk, Inc.
All rights reserved.

This computer source code and related instructions and comments are the unpublished
confidential and proprietary information of Autodesk, Inc. and are protected under
applicable copyright and trade secret law.  They may not be disclosed to, copied or
used by any third party without the prior written consent of Autodesk, Inc.

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

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVENODE_H
#define FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVENODE_H

#include <fbxfilesdk/fbxfilesdk_def.h>

#include <fbxfilesdk/kfbxplugins/kfbxobject.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>
class KFbxAnimStack;
class KFbxAnimCurve;
class KSet;

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

public:
        bool IsAnimated(bool pRecurse=false) const;

        K_DEPRECATED bool GetAnimationInterval(KTime& pStart, KTime& pStop) const;

        bool GetAnimationInterval(KTimeSpan& pTimeInterval) const;

        bool IsComposite() const;

        KFbxAnimCurveNode* Find(const char* pName);

        static KFbxAnimCurveNode* CreateTypedCurveNode(KFbxProperty& pProperty, KFbxScene* pScene);

        unsigned int GetChannelsCount() const;

        int GetChannelIndex(const char* pChannelName) const;

        KString GetChannelName(int pChannelId) const;

        void ResetChannels();

        template <class T> bool AddChannel(const char* pChnlName, T const &pValue)
        {
            if (!pChnlName || strlen(pChnlName)==0) return false;
            KFbxProperty c = GetChannel(pChnlName);
            if (c.IsValid()) 
            {
                return false;
            }

            mChannels.BeginCreateOrFindProperty();
            KFbxDataType dt = GetFbxDataType(FbxTypeOf(pValue));
            c = KFbxProperty::Create(mChannels, dt, pChnlName);
            KFbxSet<T>(c, pValue);
            mChannels.EndCreateOrFindProperty();
            return true;
        }

        template <class T> void SetChannelValue(const char* pChnlName, T pValue)
        {
            KFbxProperty c = GetChannel(pChnlName);
            if (c.IsValid()) KFbxSet<T>(c, pValue);
        }

        template <class T> void SetChannelValue(unsigned int pChnlId, T pValue)
        {
            KFbxProperty c = GetChannel(pChnlId);
            if (c.IsValid()) KFbxSet<T>(c, pValue);
        }

        template <class T> T GetChannelValue(const char* pChnlName, T pInitVal)
        {
            T v = pInitVal;
            KFbxProperty c = GetChannel(pChnlName);
            if (c.IsValid()) KFbxGet<T>(c, v);
            return v;
        }

        template <class T> T GetChannelValue(unsigned int pChnlId, T pInitVal)
        {
            T v = pInitVal;
            KFbxProperty c = GetChannel(pChnlId);
            if (c.IsValid()) KFbxGet<T>(c, v);
            return v;
        }

        bool DisconnectFromChannel(KFbxAnimCurve* pCurve, unsigned int pChnlId);

        bool ConnectToChannel(KFbxAnimCurve* pCurve, const char* pChnl, bool pInFront = false);

        bool ConnectToChannel(KFbxAnimCurve* pCurve, unsigned int pChnlId, bool pInFront = false);

        KFbxAnimCurve* CreateCurve(const char* pCurveNodeName, const char* pChannel);

        KFbxAnimCurve* CreateCurve(const char* pCurveNodeName, unsigned int pChannelId = 0);
        
        int GetCurveCount(unsigned int pChannelId, const char* pCurveNodeName = NULL);

        KFbxAnimCurve* GetCurve(unsigned int pChannelId, unsigned int pId = 0, const char* pCurveNodeName = NULL);


#ifndef DOXYGEN_SHOULD_SKIP_THIS

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

    virtual KFbxObject& Copy(const KFbxObject& pObject);

    void Evaluate(double* pData, KTime pTime);

        
    KFCurveNode* GetKFCurveNode(bool pNoCreate=false);

    void ReleaseKFCurveNode();

    void SyncChannelsWithKFCurve();

    inline bool UseQuaternionInterpolation() {return mQuaternionInterpolation != 0;}; 

    bool SetQuaternionInterpolation(unsigned short pVal); 
    unsigned short GetQuaternionInterpolation() { return mQuaternionInterpolation; };

    // sync the KFCurveNodeLayerType based on the property Datatype (see the source code for details)
    void SetKFCurveNodeLayerType(KFbxProperty& pProp);

    static const char* CurveNodeNameFrom(const char* pName);

private:
    KFbxProperty GetChannel(const char* pChnl);

    KFbxProperty GetChannel(unsigned int pChnlId);

protected:
    KFbxAnimCurveNode(KFbxSdkManager& pManager, char const* pName);
    KFbxAnimCurveNode* Find(KFbxAnimCurveNode* pRoot, const KString& pName);
    virtual bool ConstructProperties( bool pForceSet );
    virtual void Destruct(bool pRecursive, bool pDependents);

private:
    friend class KFbxObject;
    friend void CollectAnimFromCurveNode(KFCurve **lSrc, KFCurveNode *fcn, unsigned int nbCrvs, KFbxAnimCurveNode *cn, KSet* pNickToAnimCurveTimeWarpsSet, KSet& pNickToKFCurveNodeWarpSet);
    unsigned char   mNonRemovableChannels;
    KFbxProperty    mChannels;
    KFbxProperty*   mCurrentlyProcessed;
    KFCurveNode*    mFCurveNode;
    bool*           mOwnedKFCurve;
    int             mKFCurveNodeLayerType;
    unsigned short  mQuaternionInterpolation;
    int*            mDirectIndexes;
    int             mDirectIndexesSize;

    KFbxAnimCurve* GetCurve(unsigned int pChannelId, unsigned int pId, KFbxAnimCurveNode* pCurveNode);
    bool ConnectToChannel(KFbxProperty& p, KFbxAnimCurve* pCurve, bool pInFront);
    void ResetKFCurveNode();
    void SyncKFCurveValue(KFbxAnimCurve* pCurve, double pVal);
    void ReleaseOwnershipOfKFCurve(int pIndex);

    template <class T> KFbxAnimCurve* CreateCurveGeneral(const char* pCurveNodeName, T pChannel);

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};
typedef KFbxAnimCurveNode* HKKFbxAnimCurveNode;

KFBX_DLL void GetAllAnimCurves(KFbxAnimStack* pAnimStack, KArrayTemplate<KFbxAnimCurve*>& pCurves);
KFBX_DLL void GetAllAnimCurves(KFbxObject* pObj, KFbxAnimStack* pAnimStack, KArrayTemplate<KFbxAnimCurve*>& pCurves);

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVENODE_H