fbxanimcurvenode.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2012 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 _FBXSDK_SCENE_ANIMATION_CURVE_NODE_H_
#define _FBXSDK_SCENE_ANIMATION_CURVE_NODE_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/fbxobject.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

//Standard curve node names
#define FBXSDK_CURVENODE_TRANSFORM      "Transform"
#define FBXSDK_CURVENODE_TRANSLATION    "T"
#define FBXSDK_CURVENODE_ROTATION       "R"
#define FBXSDK_CURVENODE_SCALING        "S"
#define FBXSDK_CURVENODE_COMPONENT_X    "X"
#define FBXSDK_CURVENODE_COMPONENT_Y    "Y"
#define FBXSDK_CURVENODE_COMPONENT_Z    "Z"
#define FBXSDK_CURVENODE_COLOR          "Color"
#define FBXSDK_CURVENODE_COLOR_RED      FBXSDK_CURVENODE_COMPONENT_X
#define FBXSDK_CURVENODE_COLOR_GREEN    FBXSDK_CURVENODE_COMPONENT_Y
#define FBXSDK_CURVENODE_COLOR_BLUE     FBXSDK_CURVENODE_COMPONENT_Z

class FbxAnimStack;
class FbxAnimCurve;
class FbxSet;
class KFCurveNode;

class FBXSDK_DLL FbxAnimCurveNode : public FbxObject
{
    FBXSDK_OBJECT_DECLARE(FbxAnimCurveNode, FbxObject);

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

        bool GetAnimationInterval(FbxTimeSpan& pTimeInterval) const;

        bool IsComposite() const;

        FbxAnimCurveNode* Find(const char* pName);

        static FbxAnimCurveNode* CreateTypedCurveNode(FbxProperty& pProperty, FbxScene* pScene);

        unsigned int GetChannelsCount() const;

        int GetChannelIndex(const char* pChannelName) const;

        FbxString GetChannelName(int pChannelId) const;

        void ResetChannels();

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

            mChannels.BeginCreateOrFindProperty();
            FbxDataType dt = FbxGetDataTypeFromEnum(FbxTypeOf(pValue));
            c = FbxProperty::Create(mChannels, dt, pChnlName);
            c.Set(pValue);
            mChannels.EndCreateOrFindProperty();
            return true;
        }

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

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

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

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

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

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

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

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

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

        FbxAnimCurve* 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 FbxObject& Copy(const FbxObject& pObject);

    void Evaluate(double* pData, FbxTime 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(FbxProperty& pProp);

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

private:
    FbxProperty GetChannel(const char* pChnl);

    FbxProperty GetChannel(unsigned int pChnlId);

protected:
    FbxAnimCurveNode(FbxManager& pManager, char const* pName);
    FbxAnimCurveNode* Find(FbxAnimCurveNode* pRoot, const FbxString& pName);
    virtual bool ConstructProperties( bool pForceSet );
    virtual void Destruct(bool pRecursive, bool pDependents);

private:
    friend class FbxObject;
    friend void CollectAnimFromCurveNode(void **lSrc, void *fcn, unsigned int nbCrvs, FbxAnimCurveNode *cn, FbxSet* pNickToAnimCurveTimeWarpsSet, FbxSet& pNickToKFCurveNodeWarpSet);
    unsigned char   mNonRemovableChannels;
    FbxProperty mChannels;
    FbxProperty*    mCurrentlyProcessed;
    KFCurveNode*    mFCurveNode;
    bool*           mOwnedKFCurve;
    int             mKFCurveNodeLayerType;
    unsigned short  mQuaternionInterpolation;
    int*            mDirectIndexes;
    int             mDirectIndexesSize;

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

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

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

FBXSDK_DLL void GetAllAnimCurves(FbxAnimStack* pAnimStack, FbxArray<FbxAnimCurve*>& pCurves);
FBXSDK_DLL void GetAllAnimCurves(FbxObject* pObj, FbxAnimStack* pAnimStack, FbxArray<FbxAnimCurve*>& pCurves);

#include <fbxsdk/fbxsdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXANIMCURVENODE_H