fbxproperty.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_CORE_PROPERTY_H_
#define _FBXSDK_CORE_PROPERTY_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/fbxplug.h>
#include <fbxsdk/core/fbxpropertytypes.h>
#include <fbxsdk/core/fbxdatatypes.h>
#include <fbxsdk/core/fbxpropertydef.h>
#include <fbxsdk/core/base/fbxmap.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

// Forward declarations
class FbxObject;
class FbxColor;
class FbxCriteria;
class FbxAnimLayer;
class FbxAnimCurveNode;
class FbxAnimCurve;

class FBXSDK_DLL FbxProperty
{
public:
        static FbxProperty Create(const FbxProperty& pCompoundProperty, const FbxDataType& pDataType, const char* pName, const char* pLabel="", bool pCheckForDup=true, bool* pWasFound=NULL);

        static FbxProperty Create(FbxObject* pObject, const FbxDataType& pDataType, const char* pName, const char* pLabel="", bool pCheckForDup=true, bool* pWasFound=NULL);

        static FbxProperty CreateFrom(const FbxProperty& pCompoundProperty, FbxProperty& pFromProperty, bool pCheckForDup=true);

        static FbxProperty CreateFrom(FbxObject* pObject, FbxProperty& pFromProperty, bool pCheckForDup=true);

        void Destroy();

        void DestroyRecursively();

        void DestroyChildren();

        FbxProperty();

        FbxProperty(const FbxProperty& pProperty);

        FbxProperty(const FbxPropertyHandle& pPropertyHandle);

        ~FbxProperty();

        FbxDataType GetPropertyDataType() const;

        FbxString GetName() const;

        const char* GetNameAsCStr() const;

        FbxString GetHierarchicalName() const;

        FbxString GetLabel(bool pReturnNameIfEmpty=true) const;


        void SetLabel(const FbxString& pLabel);

        FbxObject* GetFbxObject() const;

        void SetUserTag(int pTag);
            
        int GetUserTag();

        void SetUserDataPtr(void* pUserData);

        void* GetUserDataPtr();

        void ModifyFlag(FbxPropertyAttr::EFlags pFlag, bool pValue);

        bool GetFlag(FbxPropertyAttr::EFlags pFlag) const;

        FbxPropertyAttr::EInheritType GetFlagInheritType( FbxPropertyAttr::EFlags pFlag ) const;

        bool SetFlagInheritType( FbxPropertyAttr::EFlags pFlag, FbxPropertyAttr::EInheritType pType );

        bool ModifiedFlag( FbxPropertyAttr::EFlags pFlag ) const;

        FbxProperty& operator= (const FbxProperty& pProperty);

        bool operator== (const FbxProperty& pProperty) const;

        bool operator!= (const FbxProperty& pProperty) const;

        inline bool operator== (int pValue) const { return (pValue == 0) ? !IsValid() : IsValid(); }

        inline bool operator!= (int pValue) const { return (pValue != 0) ? !IsValid() : IsValid(); }

        bool CompareValue(const FbxProperty& pProperty) const;

    bool CopyValue(const FbxProperty& pProperty);

        template <class T> inline T Get() const { T lValue; Get(&lValue, FbxTypeOf(lValue)); return lValue; }

        template <class T> inline bool Set(const T& pValue){ return Set(&pValue, FbxTypeOf(pValue)); }

        bool IsValid() const;

        static bool HasDefaultValue(FbxProperty& pProperty);

        FbxPropertyAttr::EInheritType GetValueInheritType() const;

        bool SetValueInheritType( FbxPropertyAttr::EInheritType pType );

        bool Modified() const;

        void SetMinLimit(double pMin);

        bool HasMinLimit() const;

        double GetMinLimit() const;

        bool HasMaxLimit() const;

        void SetMaxLimit(double pMax);

        double GetMaxLimit() const;

        void SetLimits(double pMin, double pMax);

        int AddEnumValue(const char* pStringValue);

        void InsertEnumValue(int pIndex, const char* pStringValue);

        int GetEnumCount() const;

        void SetEnumValue(int pIndex, const char* pStringValue);

        void RemoveEnumValue(int pIndex);

        const char* GetEnumValue(int pIndex) const;

        inline bool IsRoot() const { return mPropertyHandle.IsRoot(); }

        inline bool IsChildOf(const FbxProperty& pParent) const { return mPropertyHandle.IsChildOf(pParent.mPropertyHandle); }

        inline bool IsDescendentOf(const FbxProperty& pAncestor) const { return mPropertyHandle.IsDescendentOf(pAncestor.mPropertyHandle); }

        inline FbxProperty GetParent() const { return FbxProperty(mPropertyHandle.GetParent());  }

        bool SetParent(const FbxProperty& pOther);

        inline FbxProperty GetChild() const { return FbxProperty(mPropertyHandle.GetChild());   }

        inline FbxProperty GetSibling() const { return FbxProperty(mPropertyHandle.GetSibling()); }

        inline FbxProperty GetFirstDescendent() const { return FbxProperty(mPropertyHandle.GetFirstDescendent());   }

        inline FbxProperty GetNextDescendent(const FbxProperty& pProperty) const { return FbxProperty(mPropertyHandle.GetNextDescendent(pProperty.mPropertyHandle)); }

        inline FbxProperty Find (const char* pName, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,pCaseSensitive));  }

        inline FbxProperty Find (const char* pName, const FbxDataType& pDataType, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,pDataType.GetTypeInfoHandle(),pCaseSensitive));  }

        inline FbxProperty FindHierarchical (const char* pName, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,sHierarchicalSeparator,pCaseSensitive));  }

        inline FbxProperty FindHierarchical (const char* pName, const FbxDataType& pDataType, bool pCaseSensitive = true) const { return FbxProperty(mPropertyHandle.Find(pName,sHierarchicalSeparator,pDataType.GetTypeInfoHandle(),pCaseSensitive));  }


        inline void BeginCreateOrFindProperty(){ mPropertyHandle.BeginCreateOrFindProperty(); }

        inline void EndCreateOrFindProperty(){ mPropertyHandle.EndCreateOrFindProperty(); }

        class FbxPropertyNameCache
        {
        public:
            FbxPropertyNameCache(const FbxProperty& prop) : mProp(const_cast<FbxProperty&>(prop)){ mProp.BeginCreateOrFindProperty(); }

            ~FbxPropertyNameCache(){ mProp.EndCreateOrFindProperty(); }

        private:
            FbxProperty& mProp;
            FbxPropertyNameCache& operator=(const FbxPropertyNameCache& pOther){ mProp = pOther.mProp; mProp.BeginCreateOrFindProperty(); return *this; }
        };

    bool    SetArraySize( int pSize, bool pVariableArray );

    int     GetArraySize() const;

    FbxProperty GetArrayItem(int pIndex) const;

    inline FbxProperty operator[](int pIndex) const { return GetArrayItem(pIndex); }

    FbxAnimCurveNode* CreateCurveNode(FbxAnimLayer* pAnimLayer);

    FbxAnimCurveNode* GetCurveNode(FbxAnimLayer* pAnimLayer, bool pCreateAsNeeded=false);

    FbxAnimCurveNode* GetCurveNode(bool pCreateAsNeeded=false, const char* pAnimStackName = NULL);

    template <class T> inline T* GetCurve(FbxAnimLayer* pAnimLayer, bool pCreateAsNeeded=false)
    {
        return FbxCast<T>(GetCurve(pAnimLayer, GetName(), NULL, pCreateAsNeeded));
    }

    template <class T> inline T* GetCurve(FbxAnimLayer* pAnimLayer, const char* pChannel, bool pCreateAsNeeded=false)
    {
        return FbxCast<T>(GetCurve(pAnimLayer, GetName(), pChannel, pCreateAsNeeded));
    }

    template <class T> inline T* GetCurve(FbxAnimLayer* pAnimLayer, const char* pName, const char* pChannel, bool pCreateAsNeeded=false)
    {
        return FbxCast<T>(GetCurve(pAnimLayer, pName, pChannel, pCreateAsNeeded));
    }


    // SrcObjects
    bool    ConnectSrcObject(FbxObject* pObject,FbxConnection::EType pType=FbxConnection::eNone);

    bool    IsConnectedSrcObject(const FbxObject* pObject) const;

    bool    DisconnectSrcObject(FbxObject* pObject);

    bool    DisconnectAllSrcObject();

    bool    DisconnectAllSrcObject(const FbxCriteria& pCriteria);

    bool    DisconnectAllSrcObject(const FbxClassId& pClassId);

    bool    DisconnectAllSrcObject(const FbxClassId& pClassId, const FbxCriteria& pCriteria);

    int     GetSrcObjectCount() const;

    int     GetSrcObjectCount(const FbxCriteria& pCriteria) const;

    int     GetSrcObjectCount(const FbxClassId& pClassId) const;

    int     GetSrcObjectCount(const FbxClassId& pClassId, const FbxCriteria& pCriteria) const;

    FbxObject*      GetSrcObject(int pIndex=0) const;

    FbxObject*      GetSrcObject(const FbxCriteria& pCriteria, int pIndex=0) const;

    FbxObject*      GetSrcObject(const FbxClassId& pClassId, int pIndex=0) const;

    FbxObject*      GetSrcObject(const FbxClassId& pClassId, const FbxCriteria& pCriteria, int pIndex=0) const;

    FbxObject*      FindSrcObject(const char* pName, int pStartIndex=0) const;

    FbxObject*      FindSrcObject(const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    FbxObject*      FindSrcObject(const FbxClassId& pClassId, const char* pName, int pStartIndex=0) const;

    FbxObject*      FindSrcObject(const FbxClassId& pClassId, const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    template < class T > inline bool DisconnectAllSrcObject (const T*){ return DisconnectAllSrcObject(T::ClassId);}

    template < class T > inline bool DisconnectAllSrcObject (const T*, const FbxCriteria& pCriteria)  { return DisconnectAllSrcObject(T::ClassId,pCriteria);  }

    template < class T > inline int  GetSrcObjectCount(const T*) const{ return GetSrcObjectCount(T::ClassId); }

    template < class T > inline int  GetSrcObjectCount(const T*, const FbxCriteria& pCriteria) const { return GetSrcObjectCount(T::ClassId,pCriteria); }

    template < class T > inline T*   GetSrcObject(const T*, int pIndex=0) const { return (T*)GetSrcObject(T::ClassId,pIndex); }

    template < class T > inline T*   GetSrcObject(const T*, const FbxCriteria& pCriteria,int pIndex=0) const { return (T*)GetSrcObject(T::ClassId,pCriteria,pIndex); }

    template < class T > inline T*   FindSrcObject(const T*, const char* pName, int pStartIndex=0) const { return (T*)FindSrcObject(T::ClassId,pName,pStartIndex); }

    template < class T > inline T*   FindSrcObject(const T*, const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const { return (T*)FindSrcObject(T::ClassId,pCriteria,pName,pStartIndex); }

    // DstObjects
    bool    ConnectDstObject(FbxObject* pObject, FbxConnection::EType pType=FbxConnection::eNone);

    bool    IsConnectedDstObject(const FbxObject* pObject) const;

    bool    DisconnectDstObject(FbxObject* pObject);

    bool    DisconnectAllDstObject();

    bool    DisconnectAllDstObject(const FbxCriteria& pCriteria);

    bool    DisconnectAllDstObject(const FbxClassId& pClassId);

    bool    DisconnectAllDstObject(const FbxClassId& pClassId, const FbxCriteria& pCriteria);

    int     GetDstObjectCount() const;

    int     GetDstObjectCount(const FbxCriteria& pCriteria) const;

    int     GetDstObjectCount(const FbxClassId& pClassId) const;

    int     GetDstObjectCount(const FbxClassId& pClassId, const FbxCriteria& pCriteria) const;

    FbxObject*      GetDstObject(int pIndex=0) const;

    FbxObject*      GetDstObject(const FbxCriteria& pCriteria, int pIndex=0) const;

    FbxObject*      GetDstObject(const FbxClassId& pClassId, int pIndex=0) const;

    FbxObject*      GetDstObject(const FbxClassId& pClassId, const FbxCriteria& pCriteria, int pIndex=0) const;

    FbxObject*      FindDstObject(const char* pName, int pStartIndex=0) const;

    FbxObject*      FindDstObject(const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    FbxObject*      FindDstObject(const FbxClassId& pClassId, const char* pName, int pStartIndex=0) const;

    FbxObject*      FindDstObject(const FbxClassId& pClassId, const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    template < class T > inline bool DisconnectAllDstObject (const T*){ return DisconnectAllDstObject(T::ClassId);    }

    template < class T > inline bool DisconnectAllDstObject (const T*, const FbxCriteria& pCriteria)  { return DisconnectAllDstObject(T::ClassId,pCriteria);  }

    template < class T > inline int  GetDstObjectCount(const T*) const { return GetDstObjectCount(T::ClassId); }

    template < class T > inline int  GetDstObjectCount(const T*, const FbxCriteria& pCriteria) const { return GetDstObjectCount(T::ClassId,pCriteria); }

    template < class T > inline T*   GetDstObject(const T*, int pIndex=0) const { return (T*)GetDstObject(T::ClassId,pIndex); }

    template < class T > inline T*   GetDstObject(const T*, const FbxCriteria& pCriteria, int pIndex=0) const { return (T*)GetDstObject(T::ClassId,pCriteria,pIndex); }

    template < class T > inline T*   FindDstObject(const T*, const char* pName, int pStartIndex=0) const { return (T*)FindDstObject(T::ClassId,pName,pStartIndex); }

    template < class T > inline T*   FindDstObject(const T*, const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const { return (T*)FindDstObject(T::ClassId,pCriteria,pName,pStartIndex); }

        // Properties
        bool ConnectSrcProperty(const FbxProperty& pProperty);

        bool IsConnectedSrcProperty(const FbxProperty& pProperty);

        bool DisconnectSrcProperty(const FbxProperty& pProperty);

        int GetSrcPropertyCount() const;            

        bool ConnectDstProperty(FbxProperty const&  pProperty);

        bool IsConnectedDstProperty(const FbxProperty& pProperty);

        bool DisconnectDstProperty(const FbxProperty& pProperty);

        int GetDstPropertyCount() const;

        void ClearConnectCache();

        FbxProperty GetSrcProperty(int pIndex=0) const;

        FbxProperty FindSrcProperty(const char* pName, int pStartIndex=0) const;

        FbxProperty GetDstProperty(int pIndex=0) const;

        FbxProperty FindDstProperty(const char* pName, int pStartIndex=0) const;         

    static const char* sHierarchicalSeparator;

//  WARNING!
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
    FbxProperty(FbxObject* pObject, char const* pName, const FbxDataType& pDataType=FbxDataType(), const char* pLabel="");
    FbxProperty(const FbxProperty& pParent, const char* pName, const FbxDataType& pDataType, const char* pLabel);

    bool Set(const void* pValue, const EFbxType& pValueType, bool pCheckForValueEquality=true);
    bool Get(void* pValue, const EFbxType& pValueType) const;

private:
    inline void*    Get() const { FBX_ASSERT_NOW("Cannot get property value as void!"); return NULL; }
    inline bool     Set(const void* &){ FBX_ASSERT_NOW("Cannot set property value as void!"); return false; }

    bool            ConnectSrc(const FbxProperty& pProperty, FbxConnection::EType pType=FbxConnection::eNone);
    bool            DisconnectSrc(const FbxProperty& pProperty);
    bool            DisconnectAllSrc();
    bool            DisconnectAllSrc(const FbxCriteria& pCriteria);
    bool            IsConnectedSrc(const FbxProperty& pProperty) const;
    int             GetSrcCount() const;
    int             GetSrcCount(const FbxCriteria& pCriteria) const;
    FbxProperty     GetSrc(int pIndex=0) const;
    FbxProperty     GetSrc(const FbxCriteria& pCriteria, int pIndex=0) const;
    FbxProperty     FindSrc(const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    bool            ConnectDst(const FbxProperty& pProperty, FbxConnection::EType pType=FbxConnection::eNone);
    bool            DisconnectDst(const FbxProperty& pProperty);
    bool            DisconnectAllDst();
    bool            DisconnectAllDst(const FbxCriteria& pCriteria);
    bool            IsConnectedDst(const FbxProperty& pProperty) const;
    int             GetDstCount() const;
    int             GetDstCount(const FbxCriteria& pCriteria) const;
    FbxProperty     GetDst(int pIndex=0) const;
    FbxProperty     GetDst(const FbxCriteria& pCriteria, int pIndex=0) const;
    FbxProperty     FindDst(const FbxCriteria& pCriteria, const char* pName, int pStartIndex=0) const;

    FbxAnimCurve*   GetCurve(FbxAnimLayer* pAnimLayer, const char* pName, const char* pChannel, bool pCreateAsNeeded);

    mutable FbxPropertyHandle mPropertyHandle;

    friend class FbxObject;
    friend class FbxIOSettings;
    friend class FbxBindingOperator;
    friend class FbxAnimEvalClassic;
    friend void FbxMarkObject(FbxObject* pObject, FbxMap<FbxObject*, int>& pObjectDstDisconnectCount, FbxSet2<FbxObject*>& pObjectsToDeleted, FbxArray<FbxObject*>& pObjectToDeletedInSequence);
    friend void FbxCleanUpConnectionsAtDestructionBoundary(FbxScene* pObject, FbxArray<FbxObject*>& pObjectToDeletedInSequence);
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

template <class T> class FbxPropertyT : public FbxProperty
{
public:
        FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const T& pValue, bool pForceSet=true, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
        {
            return StaticInit(pObject, pName, FbxGetDataTypeFromEnum(FbxTypeOf(*((T*)0))), pValue, pForceSet, pFlags);
        }

        FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const FbxDataType& pDataType, const T& pValue, bool pForceSet=true, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
        {
            bool lWasFound = false;
            *this = Create(pObject, pDataType, pName, "", true, &lWasFound);
            if( pForceSet || !lWasFound )
            {
                ModifyFlag(pFlags, true);   // modify the flags before we set the value
                FbxProperty::Set(&pValue, FbxTypeOf(pValue), false);
            }
            return *this;
        }

        FbxProperty& StaticInit(FbxProperty pCompound, const char* pName, const FbxDataType& pDataType, const T& pValue, bool pForceSet=true, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
        {
            bool lWasFound = false;
            *this = Create(pCompound, pDataType, pName, "", true, &lWasFound);
            if( pForceSet || !lWasFound )
            {
                ModifyFlag(pFlags, true);   // modify the flags before we set the value
                FbxProperty::Set(&pValue, FbxTypeOf(pValue), false);
            }
            return *this;
        }

        FbxPropertyT& Set(const T& pValue){ FbxProperty::Set(&pValue, FbxTypeOf(pValue)); return *this; }

        T Get() const { T lValue; FbxProperty::Get(&lValue, FbxTypeOf(lValue)); return lValue; }

        FbxPropertyT& operator=(const T& pValue){ return Set(pValue); }

        operator T() const { return Get(); }

//  WARNING!
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    FbxPropertyT() : FbxProperty(){}
    FbxPropertyT(const FbxProperty& pProperty) : FbxProperty(pProperty){}
    ~FbxPropertyT(){}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};

//  WARNING!
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <> class FbxPropertyT<FbxReference> : public FbxProperty
{
public:
    FbxPropertyT() : FbxProperty(){}
    FbxPropertyT(const FbxProperty& pProperty) : FbxProperty(pProperty){}
    ~FbxPropertyT(){}

    const FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const FbxReference& pValue, bool pForceSet=true, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
    {
        return StaticInit(pObject, pName, FbxGetDataTypeFromEnum(FbxTypeOf(*((FbxReference*)0))), pValue, pForceSet, pFlags);
    }

    const FbxProperty& StaticInit(FbxObject* pObject, const char* pName, const FbxDataType& pDataType, const FbxReference& pValue, bool pForceSet=true, FbxPropertyAttr::EFlags pFlags=FbxPropertyAttr::eNone)
    {
        bool lWasFound = false;
        *this = Create(pObject, pDataType, pName, "", true, &lWasFound);
        if( pForceSet || !lWasFound )
        {
            ModifyFlag(pFlags, true);   // modify the flags before we set the value
            Set(pValue);            // since we will trigger callbacks in there!
        }
        return *this;
    }

    FbxPropertyT& Set(const FbxReference& pValue)
    {
        DisconnectAllSrcObject();
        ConnectSrcObject((FbxObject*)pValue);
        return *this;
    }
    FbxPropertyT& operator=(const FbxReference& pValue){ return Set(pValue); }

    FbxReference Get() const
    {
        return ( GetSrcObjectCount() > 0 ) ? (FbxReference)GetSrcObject() : NULL;
    }
    operator FbxReference() const { return Get(); }
};

class FBXSDK_DLL FbxConnectEvent
{
public:
    enum EType
    {
        eConnectRequest,
        eConnect,
        eConnected,
        eDisconnectRequest,
        eDisconnect,
        eDisconnected
    };

    enum EDirection
    {
        eSource,
        eDestination
    };

    inline FbxConnectEvent(EType pType,EDirection pDir,FbxProperty *pSrc,FbxProperty *pDst) :
        mType(pType),
        mDirection(pDir),
        mSrc(pSrc),
        mDst(pDst)
    {
    }
    inline EType GetType() const { return mType; }
    inline EDirection GetDirection() const { return mDirection; }
    inline FbxProperty& GetSrc() const { return *mSrc;  }
    inline FbxProperty& GetDst() const { return *mDst;  }
    template < class T > inline T*  GetSrcIfObject(const T*) const { return mSrc->IsRoot() ? FbxCast<T>(mSrc->GetFbxObject()) : (T*)0; }
    template < class T > inline T*  GetDstIfObject(const T*) const { return mDst->IsRoot() ? FbxCast<T>(mDst->GetFbxObject()) : (T*)0; }

private:
    EType           mType;
    EDirection      mDirection;
    FbxProperty*    mSrc;
    FbxProperty*    mDst;
};
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_CORE_PROPERTY_H_ */