kfbx.h

Go to the documentation of this file.

#ifndef FBXFILESDK_COMPONENTS_KBASELIB_KFBX_KFBX_H
#define FBXFILESDK_COMPONENTS_KBASELIB_KFBX_KFBX_H

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

 Copyright (C) 2001 - 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/fbxfilesdk_def.h>

#include <fbxfilesdk/components/kbaselib/klib/kstring.h>
#include <fbxfilesdk/components/kbaselib/klib/ktime.h>
#include <fbxfilesdk/components/kbaselib/klib/kerror.h>
#include <fbxfilesdk/components/kbaselib/klib/karrayul.h>
#include <fbxfilesdk/components/kbaselib/klib/ksystemtime.h>
#include <fbxfilesdk/components/kbaselib/klib/kcharptrset.h>

#include <fbxfilesdk/fbxfilesdk_nsbegin.h>

class KFBX_DLL KFbxXRefManager;
class KFile;
class KFbxReader;
class KFbxWriter;
class KFbx;

    #define FBX_DEFAULT_VERSION_NUMBER 7200


#ifndef DOXYGEN_SHOULD_SKIP_THIS

    enum
    {
        FBX_NO_SECTION = -1,        // indicate not in a valid section
        FBX_MAIN_SECTION,           // indicate currently in the main section
        FBX_EXTENSION_SECTION_0,    // indicate currently in the extention section 0
        // FBX_EXTENSION_SECTION_1,
        // FBX_EXTENSION_SECTION_2,
        // ...
    };
#endif 

    class KFBX_DLL KDefaultRenderResolution
    {
    public:
        bool    mIsOK;
        KString mCameraName;
        KString mResolutionMode;
        double mResolutionW;
        double mResolutionH;


        KDefaultRenderResolution();


        void Reset();
    };

    class KFBX_DLL KFbxFileHeaderInfo
    {
    public:

        KFbxFileHeaderInfo();

        virtual ~KFbxFileHeaderInfo();


        virtual void                Reset();

        virtual bool                ReadExtendedHeaderInformation(KFbx*);

        KDefaultRenderResolution    mDefaultRenderResolution;

        

        int                         mFileVersion;

        bool                        mCreationTimeStampPresent;

        kLocalTime                  mCreationTimeStamp;

        KString                     mCreator;               

        bool                        mIOPlugin;

        bool                        mPLE;
    };

    class KFBX_DLL KFbx
    {
    public:

        struct KFbxAutoResetXRefManager
        {
            KFbx*                   mFbx;
            const KFbxXRefManager*  mXRefManager;

            KFbxAutoResetXRefManager(KFbx* pFbx, KFbxXRefManager& pXRefManager)
            : mFbx(pFbx)
            , mXRefManager(NULL)
            {
                if( mFbx )
                {
                    mXRefManager = mFbx->ProjectGetXRefManager();
                    mFbx->ProjectSetXRefManager(&pXRefManager);
                }
            }

            ~KFbxAutoResetXRefManager()
            {
                if( mFbx )
                {
                    mFbx->ProjectSetXRefManager(mXRefManager);
                }
            }
        };

        static KFbx* KFbxObjectCreate(){ return FbxSdkNew< KFbx >(); }

        KFbx();

        virtual ~KFbx();


        bool ProjectOpen(void* pAddress, kULong pMaxLength, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectOpen(const char* pName, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

#ifndef DOXYGEN_SHOULD_SKIP_THIS

        bool ProjectOpen (KFile * pFile, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);
#endif 

        bool ProjectOpenDirect(const char* pName, KFbxReader* pReader, bool pCheckCRC = false, bool pOpenMainSection = true, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreate(void* pAddress, kUInt pSize, KFbxWriter* pWriter, bool pBinary, bool pEncrypted, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreate(const char* pName, KFbxWriter* pWriter, bool pBinary, bool pEncrypted, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreateDirect(const char* pName, KFbxWriter* pWriter, bool pBinary, bool pEncrypted, KFbxFileHeaderInfo* pFileHeaderInfo = NULL);

        bool ProjectCreateEmpty(const char* pName, KFbxWriter* pWriter, int pVersion, bool pBinary, bool pEncrypted);

        bool ProjectWrite_BeginFileHeader();

        bool ProjectWrite_BeginExtendedHeader();

        bool ProjectWrite_WriteExtendedHeader(const KFbxFileHeaderInfo* pExtendedHeader);

        bool ProjectWrite_EndExtendedHeader();

        bool ProjectWrite_EndFileHeader();

        bool ProjectClose(void** pData=0,kULong *pSize=0);

        void ProjectSetXRefManager(const KFbxXRefManager*);

        const KFbxXRefManager* ProjectGetXRefManager() const;

        bool ProjectCreateEmbeddedFolder(const KFbxXRefManager& pXRefManager, KString& pCreatedFolder, const char* pUserDefinedFolder = NULL); 

        void SetEmbedded(bool pValue);

        void SetEmbeddingExtractionFolder(const char* pExtractionFolder);

        const char* GetEmbeddingExtractionFolder();

        bool IsEmbedded() const;

        bool IsBinary() const;

        bool IsEncrypted () const;

        bool CheckCRC();

        kUInt32 GetFileVersionNumber() const; 



        bool Fbx7Support() const;

        void Fbx7Support(bool pSupport);

        bool CompressArrays() const;

        void CompressArrays(bool pCompress);

        int  CompressMinimumSize() const;

        void CompressMinimumSize(int pSize);

        int  CompressLevel() const;

        void CompressLevel(int pLevel);


        bool ProjectOpenMainSection();

        int ProjectGetExtensionSectionCount() const;

        bool ProjectOpenExtensionSection(int pExtensionSectionIndex);

        bool ProjectCreateExtensionSection(bool pOverwriteLastExtensionSection = false);

        void ProjectCloseSection();

        int ProjectGetCurrentSection() const;

        int ProjectGetCurrentSectionMode() const;

        int ProjectGetCurrentSectionVersion() const;

        int ProjectGetSectionVersion(int pSection) const;

        static void ProjectConvertVersionNumber(int pVersion, int& pMajor, int& pMinor, int& pRevision);

        bool IsPasswordProtected() const;

        bool CheckPassword(const char* pPassword);

        bool WritePassword(const char* pPassword);



        const char* GetFilename() const;

        KString GetDataDirectory(bool pAutoCreate = true);

        KString GetMediaDirectory(bool pCreate = false, const char* pUserDefinedFolder = NULL);

        KString GetContainerTemplateDirectory(const char* pTemplateName, bool pCreate);

        char* GetRelativePath(const char* pPath);

        char* GetRelativeFilePath(const char* pFilePath);

        char* GetFullPath(const char* pRelativePath);

        char* GetFullFilePath(const char* pRelativeFilePath);

        char* GetTmpProjectName(const char* pName) const;

        bool SwapFromTmpProject(const char* pName, char* pError=NULL);



        void FieldReadResetPosition();

        int FieldGetCount() const;

        const char* FieldGetName(int pFieldIndex) const;

        int FieldGetInstanceCount(const char* pFieldName) const;

        bool FieldReadBegin(int pFieldIndex, int pInstance);

        bool FieldReadBegin(const char* pFieldName);

        bool FieldReadBegin(const char* pFieldName, int pInstance);

        void FieldReadEnd();

        bool FieldReadIsBlock();

        bool FieldReadBlockBegin();

        void FieldReadBlockEnd();

        int FieldReadGetCount() const;

        int FieldReadGetRemain() const;

        char FieldReadGetType() const;

        char FieldReadCH();

        char FieldReadCH(const char* pFieldName, char pDefault=0);

        const char* FieldReadC();

        const char* FieldReadC(const char* pFieldName, const char* pDefault="");

        const char* FieldReadS();

        const char* FieldReadS(const char* pFieldName, const char* pDefault="");

        bool FieldReadB();

        bool FieldReadB(const char* pFieldName, bool pDefault = false);

        int FieldReadI();
int FieldReadI(const char* pFieldName, int pDefault=0);

        kLongLong FieldReadLL();

        kLongLong FieldReadLL(const char* pFieldName, kLongLong pDefault=0);

        float FieldReadF();

        float FieldReadF(const char* pFieldName, float pDefault=0);

        double FieldReadD();

        double FieldReadD(const char* pFieldName, double pDefault=0);

        KTime FieldReadT(const char* pFieldName);

        KTime FieldReadT();

        KTimeSpan FieldReadTS(const char* pFieldName);

        KTimeSpan FieldReadTS();

        void FieldReadFn(float* pValue, kUInt pn);

        void FieldRead3F(float* pValue);

        void FieldRead4F(float* pValue);

        void FieldReadFn(const char* pFieldName, float* pValue, const float *pDefault, kUInt pn);

        void FieldRead3F(const char* pFieldName, float* pValue, const float* pDefault=NULL);

        void FieldRead4F(const char* pFieldName, float* pValue, const float* pDefault=NULL);

        void FieldReadDn(double* pValue, kUInt pn);

        void FieldRead3D(double* pValue);

        void FieldRead4D(double* pValue);

        void FieldReadDn(const char* pFieldName, double* pValue, const double *pDefault, kUInt pn);

        void FieldRead3D(const char* pFieldName, double* pValue, const double* pDefault=NULL);

        void FieldRead4D(const char* pFieldName, double* pValue, const double* pDefault=NULL);

        void* FieldReadR(int* pByteSize);

        void* FieldReadR(const char* pFieldName,int* pByteSize);


        kByte FieldReadByte();

        kByte FieldReadByte(const char* pFieldName, kByte pDefault=0);

        kUByte FieldReadUByte();

        kUByte FieldReadUByte(const char* pFieldName, kUByte pDefault=0);

        kShort FieldReadShort();

        kShort FieldReadShort(const char* pFieldName, kShort pDefault=0);

        kUShort FieldReadUShort();

        kUShort FieldReadUShort(const char* pFieldName, kUShort pDefault=0);

        unsigned int FieldReadUI();
        
        unsigned int FieldReadUI(const char* pFieldName, unsigned int pDefault=0);

        kULongLong FieldReadULL();

        kULongLong FieldReadULL(const char* pFieldName, kULongLong pDefault=0);

        const kByte*        FieldReadArraySBytes( int &pCount );
        const kShort*       FieldReadArrayShort ( int &pCount );
        const kUShort*      FieldReadArrayUShort( int &pCount );
        const unsigned int* FieldReadArrayUI    ( int &pCount );
        const kULongLong*   FieldReadArrayULL   ( int &pCount );

        const kByte*        FieldReadArray(int &pCount, const kByte*);
        const kShort*       FieldReadArray(int &pCount, const kShort*);
        const kUShort*      FieldReadArray(int &pCount, const kUShort*);
        const unsigned int* FieldReadArray(int &pCount, const unsigned int*);
        const kULongLong*   FieldReadArray(int &pCount, const kULongLong*);

        virtual bool FieldReadEmbeddedFile (KString& pFileName, KString& pRelativeFileName, const char* pEmbeddedMediaDirectory = "", bool *pIsFileCreated=NULL);

        const double*   FieldReadArrayD( int &pCount );
        const float*    FieldReadArrayF( int &pCount );
        const int*      FieldReadArrayI( int &pCount );
        const kLongLong*FieldReadArrayLL(int &pCount );
        const bool*     FieldReadArrayB( int &pCount );
        const kUByte*   FieldReadArrayBytes( int &pCount );

        const int*    FieldReadArray(int& pCount, const int*);
        const float*  FieldReadArray(int& pCount, const float*);
        const double* FieldReadArray(int& pCount, const double*);
        const kLongLong* FieldReadArray(int& pCount, const kLongLong*);
        const bool* FieldReadArray(int& pCount, const bool*);
        const kUByte* FieldReadArray(int& pCount, const kUByte*);



        void FieldWriteBegin(const char* pFieldName);

        void FieldWriteEnd();

        void FieldWriteBlockBegin();

        void FieldWriteObjectBegin(const char* pObjectType, const char* pName, const char* pSubType=NULL);

        void FieldWriteObjectEnd();

        void FieldWriteBlockBegin(const char* pFileName);

        void FieldWriteBlockEnd ();

        void FieldWriteCH(char pValue);

        void FieldWriteCH(const char* pFieldName, char pValue);

        void FieldWriteC(const char* pValue);

        void FieldWriteC(const char* pFieldName, const char* pValue);

        void FieldWriteS(const char* pValue);

        void FieldWriteS(const KString& pValue);

        void FieldWriteS(const char* pFieldName, const char* pValue);

        void FieldWriteS(const char* pFieldName, const KString& pValue);

        void FieldWriteB(bool pValue);

        void FieldWriteB(const char* pFieldName, bool pValue);

        void FieldWriteI(int pValue);

        void FieldWriteI(const char* pFieldName, int pValue);

        void FieldWriteLL(kLongLong pValue);

        void FieldWriteLL(const char* pFieldName, kLongLong pValue);

        void FieldWriteF(float pValue);

        void FieldWriteF(const char* pFieldName, float pValue);

        void FieldWriteD(double  pValue);

        void FieldWriteD(const char* pFieldName, double pValue);

        void FieldWriteT(KTime pTime);

        void FieldWriteT(const char* pFieldName,KTime pValue);

        void FieldWriteTS(KTimeSpan pTimeSpan);

        void FieldWriteTS(const char* pFieldName,KTimeSpan pValue);

        void FieldWriteFn(const float* pValue, kUInt pn);

        void FieldWriteFn(const char* pFieldName, const float* pValue, kUInt pn);

        void FieldWrite3F(const float* pValue);

        void FieldWrite3F(const char* pFieldName, const float* pValue);

        void FieldWrite4F(const float* pValue);

        void FieldWrite4F(const char* pFieldName, const float* pValue);

        void FieldWriteDn(const double* pValue, kUInt pn);

        void FieldWriteDn(const char* pFieldName, const double* pValue, kUInt pn);

        void FieldWrite3D(const double* pValue);

        void FieldWrite3D(const char* pFieldName, const double* pValue);

        void FieldWrite4D(const double* pValue);

        void FieldWrite4D(const char* pFieldName, const double* pValue);

        // The maximum number of value entries is, in theory, 2**32.  In practice it should be a lot less than that.
        // pSize is the number of values to write from each pointer location, and stride is how much we 
        // advance to get to the next value; if the stride is zero, values are tighly packed together.
        // So in total we'll write n * pSize items.

        void FieldWriteArrayD( int n, const double*     pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayF( int n, const float*      pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayI( int n, const int*        pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayLL(int n, const kLongLong*  pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayB( int n, const bool*       pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayBytes( int n, const kUByte* pValue, int pSize = 1, int pStride = 0 );

        void FieldWriteR(const void* pRawData, int pByteSize);

        void FieldWriteR(const char* pFieldName, const void* pRawData, int pByteSize);


        void FieldWriteByte(kByte pValue);

        void FieldWriteByte(const char* pFieldName, kByte pValue);

        void FieldWriteUByte(kUByte pValue);

        void FieldWriteUByte(const char* pFieldName, kUByte pValue);

        void FieldWriteShort(kShort pValue);

        void FieldWriteShort(const char* pFieldName, kShort pValue);

        void FieldWriteUShort(kUShort pValue);

        void FieldWriteUShort(const char* pFieldName, kUShort pValue);

        void FieldWriteUI(unsigned int pValue);

        void FieldWriteUI(const char* pFieldName, unsigned int pValue);

        void FieldWriteULL(kULongLong pValue);

        void FieldWriteULL(const char* pFieldName, kULongLong pValue);

        void FieldWriteArraySBytes( int n, const kByte* pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayShort( int n, const kShort* pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayUShort( int n, const kUShort* pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayUI( int n, const unsigned int*        pValue, int pSize = 1, int pStride = 0 );
        void FieldWriteArrayULL(int n, const kULongLong*  pValue, int pSize = 1, int pStride = 0 );

        int GetFieldRMaxChunkSize() const;

        void FieldWriteObjectReference(const char* pName);

        void FieldWriteObjectReference(const char* pFieldName, const char* pName);

        bool FieldWriteEmbeddedFile (KString pFileName, KString pRelativeFileName);

        void WriteComments(const char* pFieldName);



        enum EError
        {
            eFileCorrupted,                     
            eFileVersionNotSupportedYet,        
            eFileVersionNotSupportedAnymore,    
            eFileNotOpened,                     
            eFileNotCreated,                    
            eDirectoryNotCreated,               
            eCrcCheckFailed,                    
            eNonExistingSection,                
            eOperationCanceled,                 
            eCountError,                        
            eInvalidData,                       
            eWriteError,                        
            eReadError,                         
            eErrorCount                         
        };

        KError& GetError();

        EError GetLastErrorID() const;

        const char* GetLastErrorString() const;


    #ifdef _DEBUG
        // Dump function for debugging purpose only
        void StdoutDump();
    #endif

        bool GetHaveLoadedEmbededFile() const;

        void* GetMemoryFileInfo(kULong& pSize) const;

    public:

        bool    IsBeforeVersion6() const;

        void    SetIsBeforeVersion6(bool pIsBeforeVersion6);

    private:
        struct KFbxImpl;
        KFbxImpl* mImpl;


        void ProjectClear();
        void ProjectReset();

        bool ProjectReadHeader(bool pCheckASCIIHeader, bool pCheckCRC, bool pOpenMainSection, KFbxFileHeaderInfo* pFileHeaderInfo);
        bool ProjectReadExtendedHeader(int& pExtendedHeaderEnd, KFbxFileHeaderInfo* pFileHeaderInfo);
        bool BinaryReadHeader();
        bool BinaryReadSectionPosition();
        bool ASCIIReadHeader();
        bool ASCIIReadSectionPosition();

        bool ProjectWriteHeader(KFbxFileHeaderInfo* pFileHeaderInfo);
        bool ProjectWriteExtendedHeader(KFbxFileHeaderInfo* pFileHeaderInfo);
        void BinaryWriteHeader();
        void ASCIIWriteHeader();

        void ReadEncryptionKey(char* pEncryptionKey);
        void WriteEncryptionKey(char* pEncryptionKey);


        bool ProjectClearSection();
        bool ProjectOpenSection(int pSection);
        bool BinaryReadSectionHeader();
        int BinaryReadSectionFooter(char* pSourceCheck);
        bool BinaryReadExtensionCode(kUInt32 pFollowingSectionStart, kUInt32& pSectionStart, kUInt32& pSectionVersion);
        void BinaryReadSectionPassword();

        bool ProjectWriteSectionHeader();
        void BinaryWriteSectionFooter();
        bool BinaryWriteExtensionCode(kUInt32 pSectionStart, kUInt32 pSectionVersion);

        KString GetCreationTime() const;
        void SetCreationTime(KString pCreationTime);
        void CreateSourceCheck(char* lSourceCheck);
        bool TestSourceCheck(char* pSourceCheck, char* pSourceCompany);
        KString GetMangledCreationTime();
        void EncryptSourceCheck(char* pSourceCheck, char* pEncryptionData);
        void DecryptSourceCheck(char* pSourceCheck, const char* pEncryptionData);

        void EncryptPasswordV1(KString pOriginalPassword, KString &pEncryptedPassword);
        void DecryptPasswordV1(KString pEncryptedPassword, KString &pDecryptedPassword);


        void CheckValidityOfFieldName(const char* pFieldName);
        void GetUnusedEmbeddedName(const KString& pDirectory, const KString& pName, KString& pResult, bool pCreateSubdirectory);

        KString GetDirectory(bool pAutoCreate, const char* pExtension);
    };

#include <fbxfilesdk/fbxfilesdk_nsend.h>

#endif // FBXFILESDK_COMPONENTS_KBASELIB_KFBX_KFBX_H