fbxreaderfbx6.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2019 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_FILEIO_FBX_READER_FBX6_H_
#define _FBXSDK_FILEIO_FBX_READER_FBX6_H_

#include <fbxsdk.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FbxAnimStack;
class FbxAnimLayer;
class Fbx6ObjectTypeInfo;
class Fbx6TypeReadReferences;


class Fbx6ClassTemplateMap
{
public:

    Fbx6ClassTemplateMap();

    ~Fbx6ClassTemplateMap();

    // Fbx6ClassTemplateMap will own this template object.

    bool AddClassId( FbxClassId pId, FbxObject* pTemplateObject );

    bool MergeWithTemplate( FbxObject* pObject ) const;

    void Clear();

private:
    typedef FbxMap< FbxClassId, FbxObject*, FbxClassIdCompare > MapType;
    MapType mClassMap;

    bool HasModifiedFlags(FbxProperty lProp) const;
    inline FbxPropertyFlags::EFlags IndexToFlag( int i ) const { return static_cast<FbxPropertyFlags::EFlags>(1 << i); }
};



class FbxReaderFbx6 : public FbxReader
{
public:

    FbxReaderFbx6(FbxManager& pManager, FbxImporter& pImporter, int pID, FbxStatus& pStatus);

    virtual ~FbxReaderFbx6();

    bool FileOpen(char* pFileName, EFileOpenSpecialFlags pFlags) override;

    bool FileOpen(char* pFileName) override;

    bool FileOpen(FbxFile * pFile) override;

    bool FileOpen(FbxStream * pStream, void* pStreamData) override;

    bool FileClose() override;

    bool IsFileOpen() override;

    typedef enum
    {
        eASCII,     
        eBINARY,    
        eENCRYPTED  
    } EImportMode;

    EImportMode GetImportMode();

    void GetVersion(int& pMajor, int& pMinor, int& pRevision) override;

    bool GetAxisInfo(FbxAxisSystem* pAxisSystem, FbxSystemUnit* pSystemUnits) override;

    bool GetFrameRate(FbxTime::EMode &pTimeMode) override;

    bool GetStatistics(FbxStatistics* pStats) override;

    bool GetReadOptions(bool pParseFileAsNeeded = true) override;


    bool Read(FbxDocument *pDocument) override;

    virtual bool GetReadOptions(FbxIO* pFbx, bool pParseFileAsNeeded = true);


    virtual bool Read(FbxDocument *pDocument, FbxIO* pFbx);

#ifndef FBXSDK_ENV_WINSTORE

    void PluginReadParameters(FbxObject& pParams) override;
#endif /* !FBXSDK_ENV_WINSTORE */

    FbxDocumentInfo*  GetSceneInfo() override { return mSceneInfo; }


    FbxArray<FbxTakeInfo*>* GetTakeInfo() override { return &mTakeInfo; }

    void SetProgressHandler(FbxProgress *pProgress) override;

    void SetEmbeddingExtractionFolder(const char* pExtractFolder) override;
    void SetEmbeddedFileCallback(FbxEmbeddedFileCallback* pCallback) override;
    bool SupportsStreams() const override { return true; }

private:

    FbxDocumentInfo* ReadSceneInfo();

    FbxDocumentInfo* ReadSceneInfo(FbxString& pType);

    void WriteSceneInfo(FbxDocumentInfo*);

    bool WriteThumbnail(FbxThumbnail*);


    FbxObject* CreateGenericObject(FbxDocument *pDocument, char* pObjectType, char* pObjectSubType, char* pObjectName, FbxObject::EObjectFlag pFlags=FbxObject::eSavable);

    bool ReadDescriptionSection(FbxDocument *pDocument, FbxString& pDocumentName);

    bool ReadReferenceSection(FbxDocument *pDocument, Fbx6TypeReadReferences& pDocReferences);

    bool ReadDefinitionSection(FbxDocument *pDocument, FbxArray<Fbx6ObjectTypeInfo*>& pObjectContent );

    bool ReadObjectSection(FbxDocument *pDocument, FbxArray<Fbx6ObjectTypeInfo*>& pObjectContent, Fbx6TypeReadReferences& pDocReferences );

    bool ReadObject(FbxDocument *pDocument, FbxString& pObjectType, FbxString& pObjectSubType, FbxString& pObjectName, FbxString& pObjectUniqueId, FbxObject* pReferencedObject, Fbx6TypeReadReferences& pDocReferences);

    bool ReadConnectionSection(FbxDocument *pDocument );

    
    bool ReadDocumentAnimation(FbxDocument *pDocument);

    void ReadObjectAnimation(FbxIO& pFileObject, FbxObject* pNode, FbxAnimStack& pAnimStack, int pExceptionFlag);

    void ReadPropertyAnimation(FbxIO& pFileObject, FbxProperty* pProp, FbxAnimStack& pAnimStack);

    bool ReadTakeAnimation(FbxScene& pScene, FbxTakeInfo* pTakeInfo);

    bool ReadNodeAnimation(FbxIO& pFileObject, FbxScene& pScene, FbxAnimStack& pAnimStack, FbxTakeInfo* pTakeInfo);


    void ReadLayers(FbxIO& pFileObject, FbxTakeInfo* pTakeInfo);

    void ReadTimeWarps(FbxIO& pFileObject, FbxMultiMap& pTimeWarpSet, FbxScene& pScene);

    FbxThumbnail* ReadThumbnail();

    bool TimeShiftNodeAnimation(FbxScene& pScene, FbxAnimStack& pAnimStack, int pTimeOffsetType, FbxTime pTimeOffset);


    void ReadCameraSwitcher(FbxScene& pScene);

    bool ReadCameraSwitcher( FbxCameraSwitcher& pCameraSwitcher );

    void ReorderCameraSwitcherIndices(FbxScene& pScene);


    void ReadGlobalLightSettings(FbxScene& pScene);

    void ReadGlobalTimeSettings(FbxScene& pScene);

    void ReadGlobalCameraSettings(FbxScene& pScene);

    void ReadShadowPlane(FbxScene& pScene);

    void ReadAmbientColor(FbxScene& pScene);

    void ReadFogOption(FbxScene& pScene);


    void ReadCharacter(FbxCharacter& pCharacter,int& pInputType, int& pInputIndex);

    void ReadCharacterLinkGroup(FbxCharacter& pCharacter, int pCharacterGroupId);

    void ReadCharacterLink(FbxCharacter& pCharacter, int pCharacterNodeId);

    void ReadCharacterLinkRotationSpace(FbxCharacterLink& pCharacterLink);

    bool ReadCharacterPose(FbxCharacterPose& pCharacterPose); // TBV

        bool ReadPose(FbxScene& pScene, FbxPose* pPose, bool pAsBindPose);

        bool ReadMedia(FbxDocument *pDocument, const char* pEmbeddedMediaDirectory = "");

        bool ReadGlobalSettings(FbxGlobalSettings& pGlobalSettings);


    bool ReadNode                       ( FbxNode& pNode, FbxString& pObjectSubType, Fbx6TypeReadReferences& pDocReferences );

    bool ReadContainer                  ( FbxContainer& pContainer );

    bool ReadGenericNode                ( FbxGenericNode& pNode );

    bool ReadNodeShading                ( FbxNode& pNode );

    bool ReadNodeCullingType            ( FbxNode& pNode ); // TBV, probablement passe tout en property

    bool ReadNodeTarget                 ( FbxNode& pNode );

    bool ReadNodeAttribute              ( FbxNode& pNode , FbxString& pObjectSubType, bool& pCreatedAttribute, Fbx6TypeReadReferences& pDocReferences);

    FbxNodeAttribute* ReadNodeAttribute( FbxString& pObjectSubType, FbxString& pObjectName, FbxString& pObjectUniqueId, FbxObject* pReferencedObject);

    bool ReadNodeProperties             ( FbxNode& pNode, bool pReadNodeAttributeProperties );

    bool ReadLayeredTexture             ( FbxLayeredTexture& pTex );

    bool ReadGeometryLinks              ( FbxGeometry& pGeometry );

    bool ReadGeometryShapes             ( FbxGeometry& pGeometry );

    bool ReadNull                       ( FbxNull& pNull );

    bool ReadMarker                     ( FbxMarker& pMarker );

    bool ReadCamera                     ( FbxCamera& pCamera );

    bool ReadCameraStereo               ( FbxCameraStereo& pCameraStereo );

    bool ReadCameraStereoPrecomp        (FbxCameraStereo& pCameraStereo);

    bool ReadLight                      ( FbxLight& pLight );

    bool ReadBindingTable               ( FbxBindingTable& pTable );

    bool ReadBindingOperator            ( FbxBindingOperator& pOperator );

    bool ReadMesh                       ( FbxMesh& pMesh );

    bool ReadMeshSmoothness               ( FbxMesh& pMesh );

    bool ReadMeshVertices               ( FbxMesh& pMesh );

    bool ReadMeshPolygonIndex           ( FbxMesh& pMesh );

    bool ReadMeshEdges                  ( FbxMesh& pMesh );

    //** Read FBX subdiv, base mesh, finest mesh, current subdiv level...
    //* \param pSubdiv                            fbx subdiv
    //* \param pObjectName                        Object Name
    //* \param pReferencedObject                  pointer of reference object
    //* \return if reading subdiv object is successful return \c true, otherwise return \c false. 
    //*/
    //bool ReadSubdiv( FbxSubDiv& pSubdiv, FbxString& pObjectName, FbxObject* pReferencedObject);

    bool ReadSubdiv( FbxSubDiv& pSubdiv);

    bool ReadDocument                   ( FbxDocument& pSubDocument );

    bool ReadCollection                 ( FbxCollection& pCollection );

    bool ReadSelectionSet                ( FbxSelectionSet& pSelectionSet);

    bool ReadSelectionNode             (FbxSelectionNode& pSelectionNode);

    bool ReadNurb                       ( FbxNurbs& pNurbs );

    bool ReadNurbsSurface               ( FbxNurbsSurface& pNurbs );

    bool ReadPatch                      ( FbxPatch& pPatch );

    int  ReadPatchType                  ( FbxPatch& pPatch );


    bool ReadNurbsCurve                 ( FbxNurbsCurve& pNurbsCurve );

    bool ReadTrimNurbsSurface           ( FbxTrimNurbsSurface& pNurbs );

    bool ReadBoundary                   ( FbxBoundary& pBoundary );

    bool ReadShape                      ( FbxShape& pShape, FbxGeometry& pGeometry);

    bool ReadImplementation             ( FbxImplementation& pImplementation );

    bool ReadFileTexture                    (FbxFileTexture& pTexture);

    FbxSurfaceMaterial* ReadSurfaceMaterial(const char* pName, const char* pMaterialType, FbxSurfaceMaterial* pReferencedMaterial);

    bool ReadVideo                      (FbxVideo& pVideo);

    bool ReadThumbnail                  (FbxThumbnail& pThumbnail);



    bool ReadLayerElements              (FbxGeometry& pGeometry);

    bool ReadLayerElementsMaterial      (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsMaterial);

    bool ReadLayerElementsNormal        (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsNormal);

    bool ReadLayerElementsTangent        (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsTangent); 

    bool ReadLayerElementsBinormal        (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsBinormal);

    bool ReadLayerElementsVertexColor   (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsVertexColor);

    bool ReadLayerElementsTexture (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsTexture, FbxLayerElement::EType pTextureType);

    bool ReadLayerElementsChannelUV (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsUV, FbxLayerElement::EType pTextureType);

    bool ReadLayerElementsPolygonGroup  (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsPolygonGroup);

    bool ReadLayerElementsSmoothing     (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsSmoothing);

    bool ReadLayerElementsUserData      (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsUserData);

    bool ReadLayerElementsVisibility    (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsVisibility);

    bool ReadLayerElementEdgeCrease     (FbxGeometry*pGeometry, FbxArray<FbxLayerElement*>& pElementsEdgeCrease);

    bool ReadLayerElementVertexCrease   (FbxGeometry*pGeometry, FbxArray<FbxLayerElement*>& pElementsVertexCrease);

    bool ReadLayerElementHole           (FbxGeometry*pGeometry, FbxArray<FbxLayerElement*>& pElementsHole);


    bool ReadGeometryWeightedMap(FbxGeometryWeightedMap& pGeometryWeightedMap);


    bool ReadLink(FbxCluster& pLink);

    bool ReadSkin(FbxSkin& pSkin);

    bool ReadVertexCacheDeformer(FbxVertexCacheDeformer& pDeformer);

    bool ReadCluster(FbxCluster& pCluster);

    bool ReadConstraint(FbxConstraint& pPosition);

    // Cache

    bool ReadCache(FbxCache& pCache);


    bool ResolveCameraBackgrounds(FbxScene& pScene);

    void RemoveDuplicateTextures(FbxScene& pScene);

    void ReplaceTextures(FbxArray<FbxTexture*> const& pTextureDuplicate,
                         FbxArray<FbxTexture*> const& pTextureReplacement,
                         FbxGeometry* pGeometry, FbxLayerElement::EType pTextureType);

    void RemoveDuplicateMaterials(FbxScene& pScene);

    FbxString ConvertCameraName(FbxString pCameraName);

    int  FindString(const char* pString, FbxArray<FbxString*>& pStringArray);

    bool ReadPassword(FbxString pPassword);

    void PublishProperties(FbxObject& pObject);

    bool ReadProperties(FbxObject *pFbxObject, FbxIO *pFbxFileObject, bool pReadNodeAttributeProperties=true);


    bool ReadPropertiesAndFlags(FbxObject *pFbxObject, FbxIO *pFbxFileObject, bool pReadNodeAttributeProperties=true);

    bool ReadFlags(FbxObject *pFbxObject, FbxIO* pFbxFileObject);

    void RebuildTrimRegions(FbxScene& pScene) const;

    void SetSubdivision(FbxScene& pScene) const;

    void ConvertShapeDeformProperty(FbxScene& pScene) const;

    void RebuildLayeredTextureAlphas(FbxScene& pScene) const;

    //---------------- in progress -------------------------------
    void ReadOptionsInMainSection();
    void ReadTakeOptions();
    bool ReadOptionsInExtensionSection(int& pSectionIndex);
    bool WriteOptionsInExtensionSection(bool pOverwriteLastExtensionSection=false); 
    //--------------- end in progress ----------------------------

    void ReadGlobalSettingsInMainSection();

    void ReadDefinitionSectionForStats();

private:

    FbxReaderFbx6& operator=(FbxReaderFbx6 const&) { return *this; }

    FbxIO*                  mFileObject;
    FbxImporter&            mImporter;
    FbxCharPtrSet           mNodeArrayName;
    FbxObjectStringMap      mObjectMap;

    bool                    mParseGlobalSettings;
    FbxAxisSystem           mAxisSystem;
    FbxSystemUnit           mSystemUnit;
    FbxTime::EMode          mFrameRate;

    bool                    mRetrieveStats;
    FbxStatistics*          mDefinitionsStatistics;
    FbxArray<FbxTakeInfo *> mTakeInfo;
    FbxDocumentInfo*        mSceneInfo;
    FbxAnimLayer*           mAnimLayer;
    FbxMultiMap             mNickToKFCurveNodeTimeWarpsSet;
    FbxMultiMap*            mNickToAnimCurveTimeWarpsSet;

    Fbx6ClassTemplateMap    mClassTemplateMap;
    FbxProgress*            mProgress;
    bool                    mProgressPause;

    bool                    mValidateData;
    FbxSceneCheckUtility*   mCheckUtility;

    // structure used to cache the IOS_REF.GetBool(....) for when we have
    // calls of the GetBool() function inside loops that would get executed
    // often. This would speed things a little bit!
    struct CachedIOS_REF
    {
        bool mImportAnimation;
        bool mImportAudio;
        bool mImportShape;
        bool mImportNormal;
        bool mImportBinormal;
        bool mImportTangent;
        bool mImportVertexColor;
        bool mImportPolyGroup;
        bool mImportSmoothing;
        bool mImportUserData;
        bool mImportVisibility;
        bool mImportEdgeCrease;
        bool mImportVertexCrease;
        bool mImportHole;
        bool mImportCalcLegacyShapeNormal;
        bool mImportLinks;
        bool mImportConstraint;
        bool mExtractEmbedded;
    };
    CachedIOS_REF mDocFlags;

    inline void TriggerProgress(const char* label)
    {
        if (mProgress && !mProgressPause)
        {
            mProgress->Update(1.0f, label);
        }
    }
};

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_FILEIO_FBX_READER_FBX6_H_ */