kfbxsdkmanager.h

Go to the documentation of this file.

#ifndef FBXFILESDK_KFBXPLUGINS_KFBXSDKMANAGER_H
#define FBXFILESDK_KFBXPLUGINS_KFBXSDKMANAGER_H

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

 Copyright (C) 2001 - 2009 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/kbaselib/kaydaradef_h.h>
#include <fbxfilesdk/components/kbaselib/kaydara.h>

#include <fbxfilesdk/components/kbaselib/kbaselib_forward.h>

#include <fbxfilesdk/kfbxplugins/kfbxmemoryallocator.h>
#include <fbxfilesdk/kfbxplugins/kfbxgeometryconverter.h>
#include <fbxfilesdk/kfbxplugins/kfbximageconverter.h>
#include <fbxfilesdk/kfbxplugins/kfbxproperty.h>
#include <fbxfilesdk/kfbxplugins/kfbxtypes.h>
#include <fbxfilesdk/kfbxplugins/kfbxlayer.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

// Forward declarations
class KFbxIOPluginRegistry;
class KFbxUserNotification;
class KFbxMessageEmitter;
class KFbxIOSettings;
class KFbxSdkManager_internal;
class KFbxPreviewManager;
class KFbxXRefManager;
class KFbxLocalizationManager;
class KFbxPlugin;

    class KFBX_DLL KFbxSdkManager
    {
    public:

            static bool SetMemoryAllocator(KFbxMemoryAllocator* pMemoryAllocator);


            static KFbxSdkManager* Create();

            virtual void Destroy();
            static void GetFileFormatVersion(int& pMajor, int& pMinor, int& pRevision);


        public:
            template <typename T1,typename T2> inline kFbxClassId RegisterFbxClass(char const *pName,T1 const *pFBX_TYPE_Class,T2 const *pFBX_TYPE_ParentClass,const char *pFbxFileTypeName=0,const char *pFbxFileSubTypeName=0) {
                T1::ClassId  = Internal_RegisterFbxClass(pName,T2::ClassId,(kFbxPlugConstructor)T1::SdkManagerCreate,pFbxFileTypeName,pFbxFileSubTypeName );
                return T1::ClassId;
            }
         
            template <typename T> inline kFbxClassId    RegisterRuntimeFbxClass(char const *pName,T const *pFBX_TYPE_ParentClass,const char *pFbxFileTypeName=0,const char *pFbxFileSubTypeName=0) {
                return Internal_RegisterFbxClass(pName,T::ClassId,(kFbxPlugConstructor)T::SdkManagerCreate,pFbxFileTypeName,pFbxFileSubTypeName );
            }
            
            inline void UnregisterRuntimeFbxClass(char const* pName)
            {
                kFbxClassId lClassId = FindClass(pName);

                if( !(lClassId == kFbxClassId()) )
                {
                    Internal_UnregisterFbxClass(lClassId);
                }
            }
            
            template <typename T1,typename T2> inline kFbxClassId OverrideFbxClass(T1 const *pFBX_TYPE_Class,T2 const *pFBX_TYPE_OverridenClass) {
                T1::ClassId  = Internal_OverrideFbxClass(T2::ClassId,(kFbxPlugConstructor)T1::SdkManagerCreate );
                return T1::ClassId;
            }

            KFbxPlug*       CreateClass(kFbxClassId pClassId, char const *pName, const char* pFBXType=0, const char* pFBXSubType=0);

            KFbxPlug*       CreateClass(KFbxObject* pContainer, kFbxClassId pClassId, const char* pName, const char* pFBXType=0, const char* pFBXSubType=0);

            kFbxClassId     FindClass(const char* pClassName);

            kFbxClassId     FindFbxFileClass(const char* pFbxFileTypeName, const char* pFbxFileSubTypeName);

            template <typename T> inline void UnregisterFbxClass( T const* pFBX_TYPE_Class )
            {
                Internal_UnregisterFbxClass( T::ClassId );
                T::ClassId = kFbxClassId();
            }


        public:
            KError& GetError();

            typedef enum
            {
                eOBJECT_NOT_FOUND,    
                eNAME_ALREADY_IN_USE, 
                eERROR_COUNT          
            } EError;

            EError GetLastErrorID() const;

            const char* GetLastErrorString() const;


            KFbxDataType CreateFbxDataType(const char *pName,EFbxType pType);

            KFbxDataType const &GetFbxDataTypeFromName(const char *pDataType);

            int GetFbxDataTypeCount();

            KFbxDataType &GetFbxDataType(int pIndex);


            KFbxUserNotification* GetUserNotification() const;

            void SetUserNotification(KFbxUserNotification* pUN);

            KFbxMessageEmitter & GetMessageEmitter();
            bool SetMessageEmitter(KFbxMessageEmitter * pMessageEmitter);

        private:
            KArrayTemplate<KFbxLocalizationManager *>   mKFbxLocalizations;
        public:
            void AddLocalization( KFbxLocalizationManager * pLocManager );
            void RemoveLocalization( KFbxLocalizationManager * pLocManager );
            bool SetLocale( const char * pLocale );
            const char * Localize( const char * pID, const char * pDefault = NULL) const;


            KFbxPreviewManager& GetPreviewManager();


            KFbxXRefManager& GetXRefManager();

            KFbxLibrary*    GetRootLibrary();
            KFbxLibrary*    GetSystemLibraries();
            KFbxLibrary*    GetUserLibraries();

            KFbxIOPluginRegistry* GetIOPluginRegistry() const;

            bool LoadPluginsDirectory (char *pFilename,char *pExtensions);

            bool LoadPlugin (char *pFilename);

            bool UnloadPlugins();

            bool EmitPluginsEvent(KFbxEventBase const &pEvent);
           
            KArrayTemplate<KFbxPlugin const*> GetPlugins() const;

            int GetPluginCount();

            KFbxPlugin* FindPlugin(char* pName, char* pVersion);

        private:
        // Add IOSettings in hierarchy from different modules
        
        void FillIOSettingsForReadersRegistered(KFbxIOSettings & pIOS);

        void FillIOSettingsForWritersRegistered(KFbxIOSettings & pIOS);

        void FillCommonIOSettings(KFbxIOSettings & pIOS, bool pImport);

        void Create_Common_Import_IOSettings_Groups(KFbxIOSettings & pIOS);

        void Create_Common_Export_IOSettings_Groups(KFbxIOSettings & pIOS);

        void Add_Common_Import_IOSettings(KFbxIOSettings & pIOS);

        void Add_Common_Export_IOSettings(KFbxIOSettings & pIOS);

        void Add_Common_RW_Import_IOSettings(KFbxIOSettings & pIOS);

        void Add_Common_RW_Export_IOSettings(KFbxIOSettings & pIOS);

        public:
        void Fill_Motion_Base_ReaderIOSettings(KFbxIOSettings& pIOS);

        void Fill_Motion_Base_WriterIOSettings(KFbxIOSettings& pIOS);

        // Temporary for Managing global objects
        protected:
            KArrayTemplate<KFbxObject *> mObjectArray;

        public:
            void RegisterObject(KFbxPlug const * pPlug);
            void UnregisterObject(KFbxPlug const * pPlug);

        private:
            KArrayTemplate<KFbxImageConverter *>    mKFbxImageConverterArray;
        public:
            inline int  GetSrcObjectCount(KFbxImageConverter const *)                                   { return mKFbxImageConverterArray.GetCount();  }
            inline KFbxImageConverter*      GetSrcObject(KFbxImageConverter const *,int pIndex=0)       { return mKFbxImageConverterArray.GetAt(pIndex); }
        private:
            KArrayTemplate<KFbxNode *>  mKFbxNodeArray;
        public:
            inline int  GetSrcObjectCount(KFbxNode const *)                         { return mKFbxNodeArray.GetCount();  }
            inline KFbxNode*        GetSrcObject(KFbxNode const *,int pIndex=0)     { return mKFbxNodeArray.GetAt(pIndex); }
        private:
            KArrayTemplate<KFbxTexture *>   mKFbxTextureArray;
        public:
            inline int  GetSrcObjectCount(KFbxTexture const *)                          { return mKFbxTextureArray.GetCount();  }
            inline KFbxTexture*     GetSrcObject(KFbxTexture const *,int pIndex=0)      { return mKFbxTextureArray.GetAt(pIndex); }
        private:
            KArrayTemplate<KFbxCluster *>   mKFbxClusterArray;
        public:
            inline int  GetSrcObjectCount(KFbxCluster const *)                          { return mKFbxClusterArray.GetCount();  }
            inline KFbxCluster*     GetSrcObject(KFbxCluster const *,int pIndex=0)      { return mKFbxClusterArray.GetAt(pIndex); }
        private:
            KArrayTemplate<KFbxScene *> mKFbxSceneArray;
        public:
            inline int  GetSrcObjectCount(KFbxScene const *)                            { return mKFbxSceneArray.GetCount();  }
            inline KFbxScene*       GetSrcObject(KFbxScene const *,int pIndex=0)        { return mKFbxSceneArray.GetAt(pIndex); }
        private:
            KArrayTemplate<KFbxDocument *>  mKFbxDocumentArray;
        public:
            inline int  GetSrcObjectCount(KFbxDocument const *)                         { return mKFbxDocumentArray.GetCount();  }
            inline KFbxDocument*        GetSrcObject(KFbxDocument const *,int pIndex=0)     { return mKFbxDocumentArray.GetAt(pIndex); }
        private:
            KArrayTemplate<KFbxSurfaceMaterial *>   mKFbxSurfaceMaterialArray;
        public:
            inline int  GetSrcObjectCount(KFbxSurfaceMaterial const *)                          { return mKFbxSurfaceMaterialArray.GetCount();  }
            inline KFbxSurfaceMaterial*     GetSrcObject(KFbxSurfaceMaterial const *,int pIndex=0)      { return mKFbxSurfaceMaterialArray.GetAt(pIndex); }

        public:
            static KString PrefixName(char const* pPrefix, char const* pName);


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

    #ifndef DOXYGEN_SHOULD_SKIP_THIS

    public:
        bool CanDestroyFbxSrcObject(KFbxObject* pObject, KFbxObject* pSrcObject, bool pRecursive, bool pDependents);

        void CreateMissingBindPoses(KFbxScene *pScene);
        int  GetBindPoseCount(KFbxScene *pScene);

        KFbxPlug*       CreateClassFrom(kFbxClassId, const char *pName, const KFbxObject* pFrom, const char* pFBXType=0, const char* pFBXSubType=0);

    private:
        kFbxClassId     Internal_RegisterFbxClass(const char* pClassName, kFbxClassId pParentClassId, kFbxPlugConstructor=0, char const* pFbxFileTypeName=0, char const* pFbxFileSubTypeName=0);
        bool            Internal_RegisterFbxClass(kFbxClassId pClassId);
        kFbxClassId     Internal_OverrideFbxClass(kFbxClassId pClassId, kFbxPlugConstructor=0);

        void            Internal_UnregisterFbxClass (kFbxClassId    pClassId);

        template< class T > void RemoveObjectsOfType( KArrayTemplate<T>& pArray, kFbxClassId pClassId );
        KArrayTemplate<KFbxObject*> mSystemLockedObjects; // objects that can only be destroyed when the manager is destroyed

        #ifdef K_FBXNEWRENAMING

            enum ERenamingMode
            {
                eMAYA_TO_FBX,
                eFBX_TO_MAYA,
                eLW_TO_FBX,
                eFBX_TO_LW,
                eXSI_TO_FBX,
                eFBX_TO_XSI,
                eMAX_TO_FBX,
                eFBX_TO_MAX,
                eMB_TO_FBX,
                eFBX_TO_MB
            };

            void RenameFor(ERenamingMode pMode);

            void ResolveNameClashing(bool pFromFbx, bool pIgnoreNS, bool pIsCaseSensitive, bool pComvertToWideChar, bool pReplaceNonAlphaNum, KString pNameSpaceSymbol);

        #endif


    protected:
        KFbxSdkManager();
        virtual ~KFbxSdkManager();

        virtual void Clear(KArrayTemplate<kFbxClassId>* pExcludeList = NULL, bool pDestroyUserNotification=true);

        // this object is destroyed when the manager is destroyed.
        KFbxUserNotification* mUserNotification;

        // this object is destroyed when the manager is destroyed.
        KFbxMessageEmitter * mMessageEmitter;

        // this object is destroyed when the manager is destroyed.
        KFbxIOPluginRegistry* mRegistry;

        mutable KError mError;

        friend class KFbxPose;

        // Class Management
        bool ClassInit();
        bool ClassRelease();

    public:
        int GetFbxClassCount() const;
        kFbxClassId GetNextFbxClass(kFbxClassId pClassId /* invalid id: first one */) const;

    private:
        KFbxSdkManager_internal* mInternal;

    #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

    };

    typedef KFbxSdkManager KFbxSdk;

    typedef KFbxSdkManager* HKFbxSdkManager;

    // Connection management
    template < class T > inline int KFbxGetSrcCount(KFbxSdkManager *pObject)                    { T const* FBXTYPE = 0; return pObject ? pObject->GetSrcObjectCount(FBXTYPE) : 0; }
    template < class T > inline int KFbxGetSrcCount(KFbxSdkManager *pObject, T const* FBXTYPE)  { return pObject ? pObject->GetSrcObjectCount(FBXTYPE) : 0; }
    template < class T > inline T*  KFbxGetSrc(KFbxSdkManager *pObject,int pIndex=0) { T const* FBXTYPE = 0; return pObject ? (T *)pObject->GetSrcObject(FBXTYPE,pIndex) : 0; }
    template < class T > inline T*  KFbxFindSrc(KFbxSdkManager *pObject,char const *pName)
    {
        for (int i=0; i<KFbxGetSrcCount<T>(pObject); i++) {
          T* lObject = KFbxGetSrc<T>(pObject,i);
            if (strcmp(lObject->GetName(),pName)==0 ){
                return lObject;
            }
        }
        return 0;
    }

    // Take index
    #define TAKE_NO_ANIMATION   0
    #define TAKE_DEFAULT        -1
    #define TAKE_INVALID        -3

    // Class Registration management

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_KFBXPLUGINS_KFBXSDKMANAGER_H