fbxcache.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_GEOMETRY_CACHE_H_
#define _FBXSDK_SCENE_GEOMETRY_CACHE_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/core/fbxobject.h>
#include <fbxsdk/core/base/fbxerror.h>
#include <fbxsdk/scene/fbxgroupname.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FbxCache_internal;
class FbxVertexCacheDeformer;

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

public:

        enum EFileFormat
        {
            eUnknownFileFormat, 
            eMaxPointCacheV2,   
            eMayaCache          
        };

        void SetCacheFileFormat(EFileFormat pFileFormat);

        EFileFormat GetCacheFileFormat() const;

        void SetCacheFileName(const char* pRelativeFileName_UTF8, const char* pAbsoluteFileName_UTF8);

        void GetCacheFileName(FbxString& pRelativeFileName_UTF8, FbxString& pAbsoluteFileName_UTF8) const;

        bool OpenFileForRead();

        bool IsOpen() const;

        bool CloseFile();

        double GetSamplingFrameRate();

        FbxTime GetCacheTimePerFrame();



        enum EMCFileCount
        {
            eMCOneFile,         
            eMCOneFilePerFrame  
        };

        enum EMCDataType
        {
            eUnknownData,       
            eDouble,            
            eDoubleArray,       
            eDoubleVectorArray, 
            eInt32Array,        
            eFloatArray,        
            eFloatVectorArray   
        };

        bool OpenFileForWrite(EMCFileCount pFileCount, double pSamplingFrameRate, const char* pChannelName, EMCDataType pMCDataType = eDoubleVectorArray, const char* pInterpretation = "Points");

        bool AddChannel(const char* pChannelName, EMCDataType pMCDataType, const char* pInterpretation, unsigned int& pChannelIndex);     

        int  GetChannelCount();

        bool GetChannelName(int pChannelIndex, FbxString& pChannelName);

        bool GetChannelDataType(int pChannelIndex, EMCDataType& pChannelType);

        int  GetChannelIndex(const char* pChannelName);

        bool Read(int pChannelIndex, FbxTime& pTime, double* pBuffer, unsigned int pPointCount);

        bool Read(int pChannelIndex, FbxTime& pTime, float* pBuffer, unsigned int pPointCount);

        bool Read(int pChannelIndex, FbxTime& pTime, int* pBuffer, unsigned int pPointCount);

        bool BeginWriteAt( FbxTime& pTime );

        bool Write(int pChannelIndex, FbxTime& pTime, double* pBuffer, unsigned int pPointCount);

        bool Write(int pChannelIndex, FbxTime& pTime, float* pBuffer, unsigned int pPointCount);

        bool Write(int pChannelIndex, FbxTime& pTime, int* pBuffer, unsigned int pPointCount);

        bool EndWriteAt();

        bool GetAnimationRange(int pChannelIndex, FbxTime &pTimeStart, FbxTime &pTimeEnd);

        bool GetCacheType(EMCFileCount& pFileCount);

        bool GetChannelInterpretation(int pChannelIndex, FbxString& pInterpretation);

        enum EMCSamplingType
        {
            eSamplingRegular,   
            eSamplingIrregular  
        };

        bool GetChannelSamplingType(int pChannelIndex, EMCSamplingType& pSamplingType);

        bool GetChannelSamplingRate(int pChannelIndex, FbxTime& pSamplingRate);

        bool GetChannelSampleCount(int pChannelIndex, unsigned int& pSampleCount);

        bool GetChannelPointCount(int pChannelIndex, FbxTime pTime, unsigned int& pPointCount);

        int  GetCacheDataFileCount() const;

        bool GetCacheDataFileName(int pIndex, FbxString& pRelativeFileName, FbxString& pAbsoluteFileName);

        bool EnableMultiChannelFetching(bool pMultiChannelFetching);
        
        bool GetNextTimeWithData(FbxTime pCurTime, FbxTime& pNextTime, int pChannelIndex = -1);
        
        int GetDataCount(int pChannelIndex);
        
        bool GetDataTime(int pChannelIndex, unsigned int pDataIndex, FbxTime& pTime);



        bool OpenFileForWrite(double pFrameStartOffset, double pSamplingFrameRate, unsigned int pSampleCount, unsigned int pPointCount);

        unsigned int GetSampleCount();

        unsigned int GetPointCount();

        double GetFrameStartOffset();

        bool Read(unsigned int pFrameIndex, double* pBuffer, unsigned int pPointCount);

        bool Write(unsigned int pFrameIndex, double* pBuffer);



        bool ConvertFromPC2ToMC(EMCFileCount pFileCount, double pSamplingFrameRate);

        bool ConvertFromMCToPC2(double pSamplingFrameRate, unsigned int pChannelIndex);



        FbxError& GetError();

        enum EErrorCode
        {
            eUnsupportedArchitecture,       
            eInvalidAbsolutePath,           
            eInvalidSamplingRate,           
            eInvalidCacheFormat,            
            eUnsupportedFileVersion,        
            eConversionFromPC2Failed,       
            eConversionFromMCFailed,        
            eCacheFileNotFound,             
            eCacheFileNotOpened,            
            eCacheFileNotCreated,           
            eInvalidOpenFlag,               
            eErrorWritingSample,            
            eErrorReadingSample,            
            eErrorDataType,                 
            eErrorInvalidChannelIndex,      
            eErrorIrregularChannelSampling, 
            eErrorChannelInterpretation,    
            eErrorChannelSampling,          
            eErrorInvalidFileIndex,         
            eErrorCacheDataFileName,        
            eErrorChannelStartTime,         
            eErrorChannelPointCount,        
            eErrorInvalidTime,              
            eErrorBeginWriteAtNotCalled,    
            eErrorCount                     
        };

        EErrorCode GetLastErrorID() const;

        const char* GetLastErrorString() const;



//
//  WARNING!
//
//  Anything beyond these lines may not be documented accurately and is
//  subject to change without notice.
//
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    
    static const char* sCacheFilePropertyName;
    static const char* sCacheFileAbsolutePathPropertyName;
    static const char* sCacheFileTypePropertyName;
    
    enum EOpenFlag
    {
        eReadOnly,
        eWriteOnly
    };

protected:
    bool OpenFile(EOpenFlag pFlag, EMCFileCount pFileCount, double pSamplingFrameRate, const char* pChannelName, const char* pInterpretation, unsigned int pSampleCount, unsigned int pPointCount, double pFrameStartOffset, EMCDataType pMCDataType = eDoubleVectorArray); 

    FbxCache(FbxManager& pManager, char const* pName);

    virtual void Construct( const FbxCache* pFrom );
    virtual bool ConstructProperties( bool pForceSet );
    virtual void Destruct(bool pRecursive, bool pDependents);

    // Cache
    FbxCache_internal* mData;

private:
    FbxPropertyT<FbxString> CacheFile;
    FbxPropertyT<FbxString> CacheFileAbsolutePath;
    FbxPropertyT<FbxEnum> CacheFileType;
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

inline EFbxType FbxTypeOf(const FbxCache::EFileFormat&){ return eFbxEnum; }

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_SCENE_GEOMETRY_CACHE_H_ */