Babylon.js/Exporters/FBX/3rdParty/Fbx2017.0.1/include/fbxsdk/fileio/fbx/fbxreaderfbx6.h

/****************************************************************************************
 
   Copyright (C) 2015 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.
 
****************************************************************************************/

//! \file fbxreaderfbx6.h
#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;


/**	\brief Helper class to merge Class root property templates.
  * Add class id and object to the template and search object by
  * class id.
  */
class Fbx6ClassTemplateMap
{
public:

    /** Constructor
      *	
      */
    Fbx6ClassTemplateMap();

    /** Destructor
      *	
      */
    ~Fbx6ClassTemplateMap();

    // Fbx6ClassTemplateMap will own this template object.

    /** Add the template object to template map
      *	\param pId              Class Id
      * \param pTemplateObject  template object
      * \return if the object is successfully added return \c true, otherwise return \c false.
      */
    bool AddClassId( FbxClassId pId, FbxObject* pTemplateObject );

    /** Merge the properties of FbxObject with the object with the same class id
      *	\param pObject          The FbxObject to merge
      * \return if the object is merged return \c true, otherwise return \c false.
      */
    bool MergeWithTemplate( FbxObject* pObject ) const;

    /** Delete all FbxObject in template map
      *	
      */
    void Clear();

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

    /** Whether the property is modified
      *	\param lProp        The property to check
      * \return If the property has been modified return \c true, otherwise return \c false
      */
    bool HasModifiedFlags(FbxProperty lProp) const;
    inline FbxPropertyFlags::EFlags IndexToFlag( int i ) const { return static_cast<FbxPropertyFlags::EFlags>(1 << i); }
};



/**	\brief This class is the FBX v6 reader.
* The reader provide you the ability to read the global settings, objects and animation information from file.
*
*/
class FbxReaderFbx6 : public FbxReader
{
public:

    /** Constructor
      *	\param pManager        the FbxManager Object
      * \param pImporter       the FbxImporter to import the SDK objects
      * \param pID             id for current reader
      * \param pStatus         the FbxStatus object to hold error codes
      */
    FbxReaderFbx6(FbxManager& pManager, FbxImporter& pImporter, int pID, FbxStatus& pStatus);

    /** Destructor
      *
      */
    virtual ~FbxReaderFbx6();

    /** Open file with certain EFileOpenSpecialFlags
      * \param pFileName     name of the File to open
      * \param pFlags        the EFileOpenSpecialFlags to open with
      * \return if the file is open successfully return true, otherwise return false
      */
    virtual bool FileOpen(char* pFileName, EFileOpenSpecialFlags pFlags);

    /** Open file with default flag
      *	\param pFileName     name of the File to open
      * \return if the file is open successfully return \c true, otherwise return \c false
      */
    virtual bool FileOpen(char* pFileName);

    /** Open file with FbxFile handle
      *	\param pFile        the FbxFile handle
      * \return if the file is open successfully return \c true, otherwise return \c false
      */
    virtual bool FileOpen(FbxFile * pFile);

    /** Open file from stream
      */
	virtual bool FileOpen(FbxStream * pStream, void* pStreamData);

    /** Close the file stream
      * \return if the file is closed successfully return \c true, otherwise return \c false
      */
    virtual bool FileClose();

    /** Check whether the file stream is open.
      *	\return if the file stream is open return \c true, otherwise return \c false.
      */
    virtual bool IsFileOpen();

    /** \enum EImportMode File import mode.
      *
      */
    typedef enum
    {
        eASCII,     /**< Plain text mode */
        eBINARY,    /**< Binary mode */
        eENCRYPTED  /**< Encrypted mode */
    } EImportMode;

    /** Get current Import mode
      *	\return return the EImportMode value
      */
    EImportMode GetImportMode();

    /** Get file version
      *	\param pMajor       Major version
      *	\param pMinor       Minor version
      *	\param pRevision    Revision version
      */
    virtual void GetVersion(int& pMajor, int& pMinor, int& pRevision);

    /** Get axis system information from file
      *	\param pAxisSystem      axis system in file
      * \param pSystemUnits     system unit in file
      * \return if either pAxisSystem or pSystemUnits is \c NULL return \c false, otherwise return \c true.
      */
    virtual bool GetAxisInfo(FbxAxisSystem* pAxisSystem, FbxSystemUnit* pSystemUnits);

	/** Get FBX file time mode read from GlobalSettings in FBX 6.n and FBX 7.n
	  *	\param pTimeMode  ref to a FbxTime::EMode enum
	  *	\return     \c true on success, \c false otherwise.
	  *	\remarks    This function must be called after FbxImporter::Initialize().
	  *             Can be used for statistics (via GlobalSettings) before loading the whole scene from the file.
	  */
	virtual bool GetFrameRate(FbxTime::EMode &pTimeMode);	

    /** Get the statistics from file
      *	\param pStats statistics in file
      *	\return if fetching statistics is successfully return \c true, otherwise return \c false.
      */
    virtual bool GetStatistics(FbxStatistics* pStats);

    /** Get the file stream options
      *	\param pParseFileAsNeeded       Whether to parse file as read options
      * \return true on success, otherwise return false.
      */
    virtual bool GetReadOptions(bool pParseFileAsNeeded = true);


    /** Read file with stream options
      *	\param pDocument        FbxDocument to store the file data
      *	\return if fetching statistics is successful return \c true, otherwise return \c false.
      */
    virtual bool Read(FbxDocument *pDocument);

    /** Get the file options
      * \param pFbx                     file object to read options
      *	\param pParseFileAsNeeded       Whether to parse file as read options
      * \return true on success, otherwise return false.
      */
    virtual bool GetReadOptions(FbxIO* pFbx, bool pParseFileAsNeeded = true);


    /** Read file with stream options
      *	\param pDocument        FbxDocument to store the file data
      * \param pFbx             file object to read from
      *	\return if reading the file is successful return \c true, otherwise return \c false.
      */
    virtual bool Read(FbxDocument *pDocument, FbxIO* pFbx);


    /** Read all the properties and flags
      *	\param pParams        settings to assign properties and flags
      */
	virtual void PluginReadParameters(FbxObject& pParams);

    /** Returns the scene info from the file.
      * \return The pointer to file scene info defined by this reader.
      */
    virtual FbxDocumentInfo*  GetSceneInfo() { return mSceneInfo; }


    /** Returns the pointer to the list of TakeInfo from the file.
      * \return NULL
      */
    virtual FbxArray<FbxTakeInfo*>* GetTakeInfo() { return &mTakeInfo; }

    /** Pass a progress handler to the reader
      * \param pProgress     FbxProgress to store the progress information.
      */
    virtual void SetProgressHandler(FbxProgress *pProgress);

	virtual void SetEmbeddingExtractionFolder(const char* pExtractFolder);

	virtual bool SupportsStreams() const { return true; }

private:

    /** Read scene information
      *	\return A pointer of document info. Return \c NULL if any error exist
      */
    FbxDocumentInfo* ReadSceneInfo();

    /** Read scene information by type
      *	\param pType        the type to read
      * \return A pointer of document info. Return \c NULL if any error exist
      */
    FbxDocumentInfo* ReadSceneInfo(FbxString& pType);

    /** Write scene information
      *	
      */
    void WriteSceneInfo(FbxDocumentInfo*);

    /** Write thumbnail
      *	
      */
    bool WriteThumbnail(FbxThumbnail*);

    /**
      * \name FBX File sections
      */
    //@{

    /** Create generic object and connect with FbxIO document
      *	\param pDocument      FbxDocument to connect with the generic object 
      * \param pObjectType    type of generic object 
      * \param pObjectSubType Subtype of generic object
      * \param pObjectName    Name of generic object
      * \param pFlags         Object flag
      * \return A pointer of the generic object. Return \c NULL if creation fails.
      */
    FbxObject* CreateGenericObject(FbxDocument *pDocument, char* pObjectType, char* pObjectSubType, char* pObjectName, FbxObject::EObjectFlag pFlags=FbxObject::eSavable);

    /** Read description section and assign the document name
      *	\param pDocument        Document to read
      * \param pDocumentName    Document name to assign
      *	\return if reading description section is successful return \c true, otherwise return \c false.
      */
    bool ReadDescriptionSection(FbxDocument *pDocument, FbxString& pDocumentName);

    /** Read reference section and fill the external references
      *	\param pDocument        Document to read
      * \param pDocReferences   External references to fill
      *	\return if reading reference section is successful return \c true, otherwise return \c false.
      */
    bool ReadReferenceSection(FbxDocument *pDocument, Fbx6TypeReadReferences& pDocReferences);

    /** Read definition section and fill object type info array
      *	\param pDocument        Document to read
      * \param pObjectContent   Object type info array to fill
      *	\return if reading definition section is successful return \c true, otherwise return \c false.
      */
    bool ReadDefinitionSection(FbxDocument *pDocument, FbxArray<Fbx6ObjectTypeInfo*>& pObjectContent );

    /** Read object section and fill object type info array and external reference
      *	\param pDocument        Document to read
      * \param pObjectContent   Object type info array to fill
      * \param pDocReferences   External references to fill
      *	\return if reading object section is successful return \c true, otherwise return \c false.
      */
    bool ReadObjectSection(FbxDocument *pDocument, FbxArray<Fbx6ObjectTypeInfo*>& pObjectContent, Fbx6TypeReadReferences& pDocReferences );

    /** Read object information from document
      *	\param pDocument            Document to read
      * \param pObjectType          Object type to assign
      * \param pObjectSubType       Object subtype to assign
      * \param pObjectName          Object Name
      * \param pObjectUniqueId      Object unique id
      * \param pReferencedObject    Reference object
      * \param pDocReferences       External reference
      *	\return if reading object is successful return \c true, otherwise return \c false.      
      */
    bool ReadObject(FbxDocument *pDocument, FbxString& pObjectType, FbxString& pObjectSubType, FbxString& pObjectName, FbxString& pObjectUniqueId, FbxObject* pReferencedObject, Fbx6TypeReadReferences& pDocReferences);

    /** Read the connection section from document
      *	\param pDocument        Document to read
      *	\return if reading connection section is successful return \c true, otherwise return \c false.
      */
    bool ReadConnectionSection(FbxDocument *pDocument );
    //@}

    /**
      * \name Takes and animation
      */
    //@{
    
    /** Read animation from document
      *	\param pDocument        Document to read
      *	\return if reading animation is successful return \c true, otherwise return \c false.
      */
    bool ReadDocumentAnimation(FbxDocument *pDocument);

    /** Read object animation from file object
      *	\param pFileObject      File object handle
      * \param pNode            Fill this node with animation
      * \param pAnimStack       Animation stack to read from
      * \param pExceptionFlag   Exception flag
      */
    void ReadObjectAnimation(FbxIO& pFileObject, FbxObject* pNode, FbxAnimStack& pAnimStack, int pExceptionFlag);

    /** Read property animation from file object
      *	\param pFileObject      File object handle
      * \param pProp            Fill the property with animation
      * \param pAnimStack       Animation stack to read from
      */
    void ReadPropertyAnimation(FbxIO& pFileObject, FbxProperty* pProp, FbxAnimStack& pAnimStack);

    /** Read take animation from fbx scene
      *	\param pScene           Scene to read animation
      * \param pTakeInfo        Take info to read from
      * \remarks This function will allocate the corresponding FbxAnimStack with the base animation layer.
      */
    bool ReadTakeAnimation(FbxScene& pScene, FbxTakeInfo* pTakeInfo);

    /** Read node animation from file
      * \param pFileObject      File object to read
      *	\param pScene           Scene to read animation
      * \param pAnimStack       The animation stack to read from
      * \param pTakeInfo        Take info to read from
      */
    bool ReadNodeAnimation(FbxIO& pFileObject, FbxScene& pScene, FbxAnimStack& pAnimStack, FbxTakeInfo* pTakeInfo);


    /** Read layer information from file
      *	\param pFileObject      File object to read
      * \param pTakeInfo        Take info to read from
      */
    void ReadLayers(FbxIO& pFileObject, FbxTakeInfo* pTakeInfo);

    /** Read time warps from file
      *	\param pFileObject      File object to read
      * \param pTimeWarpSet     Time warp set to fill
	  *	\param pScene           Scene holding the time warp curves.
      */
    void ReadTimeWarps(FbxIO& pFileObject, FbxMultiMap& pTimeWarpSet, FbxScene& pScene);

    /** Read thumbnail
      *	\return A pointer of thumbnail. Return \c NULL if any error exist
      */
    FbxThumbnail* ReadThumbnail();

    /** Set time shift for node animation from take information
      * \param pScene           Scene to read
      *	\param pAnimStack       The animation stack to modify
      * \param pTimeOffsetType  A value from the FbxTakeInfo::EImportOffsetType enumeration that indicates the time shift offset type
      * \param pTimeOffset      The time shift offset
      * \return if time shifting is successful return \c true, otherwise return \c false.
      */
    bool TimeShiftNodeAnimation(FbxScene& pScene, FbxAnimStack& pAnimStack, int pTimeOffsetType, FbxTime pTimeOffset);
    //@}

    /**
      * \name Camera switcher
      */
    //@{

    /** Read camera switcher from scene
      *	\param pScene       Scene to read from
      */
    void ReadCameraSwitcher(FbxScene& pScene);

    /** Fill camera switcher object with data
      *	\param pCameraSwitcher    Camera switcher to fill  
      */
    bool ReadCameraSwitcher( FbxCameraSwitcher& pCameraSwitcher );

    /** Reorder camera switcher indices in the scene
      *	\param  pScene          Scene to read from
      */
    void ReorderCameraSwitcherIndices(FbxScene& pScene);
    //@}

    /**
      * \name Global parameters
      */
    //@{

    /** Read global light settings from scene
      *	\param  pScene          Scene to read from
      */
    void ReadGlobalLightSettings(FbxScene& pScene);

    /** Read global time settings from scene
      *	\param  pScene          Scene to read from
      */
    void ReadGlobalTimeSettings(FbxScene& pScene);

    /** Read global camera settings from scene
      *	\param  pScene          Scene to read from
      */
    void ReadGlobalCameraSettings(FbxScene& pScene);

    /** Read shadow plane from scene
      *	\param  pScene          Scene to read from
      */
    void ReadShadowPlane(FbxScene& pScene);

    /** Read ambient color from scene
      *	\param  pScene          Scene to read from
      */
    void ReadAmbientColor(FbxScene& pScene);

    /** Read fog option from scene
      *	\param  pScene          Scene to read from
      */
    void ReadFogOption(FbxScene& pScene);
    //@}

    /**
      * \name Character
      */
    //@{

    /** Read character information from file
      *	\param pCharacter       Character object to fill
      *	\param pInputType       Unused.
      *	\param pInputIndex      Unused.
      */
    void ReadCharacter(FbxCharacter& pCharacter,int& pInputType, int& pInputIndex);

    /** Read character link group information from file by group id
      *	\param pCharacter           Character object to fill
      * \param pCharacterGroupId    Group id to read character link
      */
    void ReadCharacterLinkGroup(FbxCharacter& pCharacter, int pCharacterGroupId);

    /** Read character link information from file by node id
      *	\param pCharacter           Character object to fill
      * \param pCharacterNodeId     Character node id
      */
    void ReadCharacterLink(FbxCharacter& pCharacter, int pCharacterNodeId);

    /** Read character link formation in rotation space
      *	\param pCharacterLink       Character link object to fill
      */
    void ReadCharacterLinkRotationSpace(FbxCharacterLink& pCharacterLink);

    /** Read character pose from file
      *	\param pCharacterPose       Character pose to fill
      * \return if reading character pose is successful return \c true, otherwise return \c false.
      */
    bool ReadCharacterPose(FbxCharacterPose& pCharacterPose); // TBV
    //@}

    /**
      * \name Misc
      */
    //@{
		/** Read pose object from scene
		  *	\param pScene               Scene to read from
		  * \param pPose                Pose object
		  * \param pAsBindPose          whether to treat the pose as BindPose
		  * \return if reading pose is successful return \c true, otherwise return \c false.
		  */
		bool ReadPose(FbxScene& pScene, FbxPose* pPose, bool pAsBindPose);

		/** Read media data from document
		  *	\param pDocument                Document to read from
		  * \param pEmbeddedMediaDirectory  the directory path storing the embedded media
		  * \return if reading media is successful return \c true, otherwise return \c false.
		  */
		bool ReadMedia(FbxDocument *pDocument, const char* pEmbeddedMediaDirectory = "");

		/** Read global settings from file
		  *	\param pGlobalSettings          global settings object to fill
		  * \return if reading global settings is successful return \c true, otherwise return \c false.
		  */
		bool ReadGlobalSettings(FbxGlobalSettings& pGlobalSettings);
    //@}

    /**
    * \name Objects
    */
    //@{

    /** Read node data from file
      *	\param pNode            Node object to fill data
      * \param pObjectSubType   Subtype of object
      * \param pDocReferences   External reference
      * \return if reading node data is successful return \c true, otherwise return \c false.
      */
    bool ReadNode                       ( FbxNode& pNode, FbxString& pObjectSubType, Fbx6TypeReadReferences& pDocReferences );

    /** Read properties and flags for fbx container
      *	\param pContainer           container to fill data
      * \return if reading data to container is successful return \c true, otherwise return \c false.
      */
	bool ReadContainer					( FbxContainer& pContainer );

    /** Read properties and flags for fbx generic node
      *	\param pNode                generic node to fill data
      * \return if reading data to generic node is successful return \c true, otherwise return \c false.
      */
    bool ReadGenericNode                ( FbxGenericNode& pNode );

    /** Read shading information of node
      *	\param pNode                fbx node to fill shading information
      * \return if reading shading information to node is successful return \c true, otherwise return \c false.
      */
    bool ReadNodeShading                ( FbxNode& pNode );

    /** Read back-face culling type for node
      *	\param pNode                fbx node
      * \return if reading culling type to node is successful return \c true, otherwise return \c false.
      */
    bool ReadNodeCullingType            ( FbxNode& pNode ); // TBV, probablement passe tout en property

    /** Read target transform for node
      *	\param pNode                fbx node
      * \return if reading target transform to node is successful return \c true, otherwise return \c false.
      */
    bool ReadNodeTarget                 ( FbxNode& pNode );

    /** Read node attribute according to object subtype
      *	\param pNode                fbx node
      * \param pObjectSubType       object subtype
      * \param pCreatedAttribute    set to true if attribute exists
      * \param pDocReferences       external reference to search
      * \return if reading node attribute is successful return \c true, otherwise return \c false.
      */
    bool ReadNodeAttribute              ( FbxNode& pNode , FbxString& pObjectSubType, bool& pCreatedAttribute, Fbx6TypeReadReferences& pDocReferences);

    /** Read node attribute according to object subtype
      * \param pObjectSubType       object subtype
      * \param pObjectName          object name
      * \param pObjectUniqueId      unique id of object
      * \param pReferencedObject    pointer of reference object
      * \return A pointer of node attribute. Return \c NULL if the attribute does not exist
      */
    FbxNodeAttribute* ReadNodeAttribute( FbxString& pObjectSubType, FbxString& pObjectName, FbxString& pObjectUniqueId, FbxObject* pReferencedObject);

    /** Read node properties , flags and update the 
      * node pivot and limits according to properties
      *	\param pNode                            FBX node
      * \param pReadNodeAttributeProperties     whether to 
      * \return if reading node properties is successful return \c true, otherwise return \c false.
      */
    bool ReadNodeProperties             ( FbxNode& pNode, bool pReadNodeAttributeProperties );

    /** Read layered texture from file
      *	\param pTex                             Layered texture to fill
      * \return if reading layered texture is successful return \c true, otherwise return \c false.
      */
    bool ReadLayeredTexture             ( FbxLayeredTexture& pTex );

    /** Read FBX links for geometry
      * \param pGeometry                        FBX geometry
      * \return if reading geometry links is successful return \c true, otherwise return \c false.
      */
    bool ReadGeometryLinks              ( FbxGeometry& pGeometry );

    /** Read FBX shapes for geometry
      *	\param pGeometry                        FBX geometry
      * \return if reading geometry shapes is successful return \c true, otherwise return \c false.
      */
    bool ReadGeometryShapes             ( FbxGeometry& pGeometry );

    /** Read the null node from file
      *	\param pNull                            Null node
      * \return if reading null node is successful return \c true, otherwise return \c false.      
      */
    bool ReadNull                       ( FbxNull& pNull );

    /** Read the marker node from file
      *	\param pMarker                            Marker node
      * \return if reading marker node is successful return \c true, otherwise return \c false.      
      */
    bool ReadMarker                     ( FbxMarker& pMarker );

    /** Read the camera node from file
      *	\param pCamera                            Camera node
      * \return if reading camera node is successful return \c true, otherwise return \c false.      
      */
    bool ReadCamera                     ( FbxCamera& pCamera );

    /** Read the stereo camera node from file
    *	\param pCameraStereo                            Stereo camera node
    * \return if reading stereo camera node is successful return \c true, otherwise return \c false.      
    */
    bool ReadCameraStereo               ( FbxCameraStereo& pCameraStereo );

    /** Read the precomp file from binary file
    *	\param pCameraStereo                            Stereo camera node
    * \return if reading precomp file is successful return \c true, otherwise return \c false.      
    */
    bool ReadCameraStereoPrecomp        (FbxCameraStereo& pCameraStereo);

    /** Read the light node from file
      *	\param pLight                            light node
      * \return if reading light node is successful return \c true, otherwise return \c false.      
      */
    bool ReadLight                      ( FbxLight& pLight );

    /** Read the binding table node from file.
      * Create all the binding table entries and fill with embedded data
      *	\param pTable                            binding table
      * \return if reading binding table is successful return \c true, otherwise return \c false.      
      */
    bool ReadBindingTable               ( FbxBindingTable& pTable );

    /** Read the binding operator from file
      *	\param pOperator                         binding operator
      * \return if reading binding operator is successful return \c true, otherwise return \c false.      
      */
    bool ReadBindingOperator            ( FbxBindingOperator& pOperator );

    /** Read vertices, polygon indices, edges, layer elements, geometry links and shapes to mesh object
      *	\param pMesh                            fbx mesh
      * \return if reading mesh object is successful return \c true, otherwise return \c false. 
      */
    bool ReadMesh                       ( FbxMesh& pMesh );

    /** Read mesh smoothness factor from mesh
      * \param pMesh                            fbx mesh
      * \return if reading mesh smoothness is successful return \c true, otherwise return \c false. 
      */
    bool ReadMeshSmoothness               ( FbxMesh& pMesh );

    /** Read vertices of mesh object
      *	\param pMesh                            fbx mesh
      * \return if reading mesh vertices is successful return \c true, otherwise return \c false. 
      */
    bool ReadMeshVertices               ( FbxMesh& pMesh );

    /** Read polygon indices of mesh object
      *	\param pMesh                            fbx mesh
      * \return if reading polygon indices is successful return \c true, otherwise return \c false. 
      */
    bool ReadMeshPolygonIndex           ( FbxMesh& pMesh );

    /** Read edges of mesh object
      *	\param pMesh                            fbx mesh
      * \return if reading mesh edges is successful return \c true, otherwise return \c false. 
      */
    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);

    /** Read FBX subdiv, base mesh, finest mesh, current subdiv level...
    *	\param pSubdiv                            fbx subdiv
    * \return if reading subdiv object is successful return \c true, otherwise return \c false. 
    */
    bool ReadSubdiv( FbxSubDiv& pSubdiv);

    /** Read properties and flags for fbx document
      *	\param pSubDocument                     fbx document
      * \return if reading document information is successful return \c true, otherwise return \c false.
      */
    bool ReadDocument                   ( FbxDocument& pSubDocument );

    /** Read properties and flags for fbx collection
      *	\param pCollection                      fbx collection
      * \return if reading fbx collection is successful return \c true, otherwise return \c false.
      */
    bool ReadCollection                 ( FbxCollection& pCollection );

    /** Read properties and flags for fbx selection set
    *	\param pSelectionSet                    fbx selection set
    * \return if reading fbx selection set is successful return \c true, otherwise return \c false.
    */
    bool ReadSelectionSet                ( FbxSelectionSet& pSelectionSet);

    bool ReadSelectionNode             (FbxSelectionNode& pSelectionNode);

    /** Read nurb data including surface types, nurb type, display type, steps, control points and UV.
      *	\param pNurbs                            Nurb object
      * \return if reading nurb data is successful return \c true, otherwise return \c false.
      */
    bool ReadNurb                       ( FbxNurbs& pNurbs );

    /** Read nurb surface data including surface types, surface type, display type, steps, control points and UV vectors.
      *	\param pNurbs                            Nurb surface object
      * \return if reading nurb surface data is successful return \c true, otherwise return \c false.
      */
    bool ReadNurbsSurface               ( FbxNurbsSurface& pNurbs );

    /** Read patch data including patch type, dimension, display type, steps, UV cap and control points.
      *	\param pPatch                           Patch object
      * \return if reading patch data is successful return \c true, otherwise return \c false.      
      */
    bool ReadPatch                      ( FbxPatch& pPatch );

    /** Read patch type in string and return type in enum
      *	\param pPatch                           Patch object
      * \return patch type in enum      
      */
    int  ReadPatchType                  ( FbxPatch& pPatch );


    /** Read nurb curve data including types, dimension, rational-ness, control points and knots.
      *	\param pNurbsCurve                      Nurb curve
      * \return if reading nurb curve data is successful return \c true, otherwise return \c false.  
      */
    bool ReadNurbsCurve                 ( FbxNurbsCurve& pNurbsCurve );

    /** Read trim Nurb surface objects with properties
      *	\param pNurbs                            Trim nurb surface                * \return if reading trim nurb surface is successful return \c true, otherwise return \c false.                 
      */
    bool ReadTrimNurbsSurface           ( FbxTrimNurbsSurface& pNurbs );

    /** Read properties and flags of fbx boundary
      *	\param pBoundary                        Fbx boundary object
      * \return if reading fbx boundary is successful return \c true, otherwise return \c false.   
      */
    bool ReadBoundary                   ( FbxBoundary& pBoundary );

    /** Read shape object properties from file
      *	\param pShape                           Fbx Shape
      * \param pGeometry                        Geometry contains the shape
      * \return if reading shape object properties is successful return \c true, otherwise return \c false.   
      */
    bool ReadShape                      ( FbxShape& pShape, FbxGeometry& pGeometry);

    /** Read properties and flags of fbx implementation
      *	\param pImplementation                  Fbx implementation
      * \return if reading fbx implementation is successful return \c true, otherwise return \c false.  
      */
    bool ReadImplementation             ( FbxImplementation& pImplementation );

    /** Read texture object data including name, UV transform, alpha and cropping.
      *	\param pTexture                         Fbx texture object
      * \return if reading texture object is successful return \c true, otherwise return \c false.  
      */
    bool ReadFileTexture                    (FbxFileTexture& pTexture);

    /** Read surface material from file
      *	\param pName                Material Name
      * \param pMaterialType        Material type
      * \param pReferencedMaterial  Reference material to clone from if it is not \c NULL
      * \return A pointer of read surface material
      */
    FbxSurfaceMaterial* ReadSurfaceMaterial(const char* pName, const char* pMaterialType, FbxSurfaceMaterial* pReferencedMaterial);

    /** Read video object from file
      *	\param pVideo               Fbx video object
      * \return if reading video object is successful return \c true, otherwise return \c false.  
      */
    bool ReadVideo                      (FbxVideo& pVideo);

    /** Read thumbnail object from file
      *	\param pThumbnail           Fbx thumbnail
      * \return if reading thumbnail is successful return \c true, otherwise return \c false.  
      */
    bool ReadThumbnail                  (FbxThumbnail& pThumbnail);
    //@}


    /**
    * \name Layer elements
    */
    //@{

    /** Read all layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \return if reading all layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElements              (FbxGeometry& pGeometry);

    /** Read material layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsMaterial        material layer element array
      * \return if reading material layer elements is successful return \c true, otherwise return \c false.
      */
    bool ReadLayerElementsMaterial      (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsMaterial);

    /** Read normal layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsNormal          normal layer element array
      * \return if reading normal layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsNormal        (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsNormal);

    /** Read Tangent layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsTangent          Tangent layer element array
      * \return if reading Tangent layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsTangent        (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsTangent); 

    /** Read Binormal layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsBinormal          Binormal layer element array
      * \return if reading Binormal layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsBinormal        (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsBinormal);

    /** Read vertex color layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsVertexColor     vertex color layer element array
      * \return if reading vertex color layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsVertexColor   (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsVertexColor);

    /** Read texture layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsTexture         texture layer element array
      * \param pTextureType             the type of elements to read
      * \return if reading texture layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsTexture (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsTexture, FbxLayerElement::EType pTextureType);

    /** Read UV layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsUV              UV layer element array
      * \param pTextureType             the type of elements to read
      * \return if reading UV layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsChannelUV (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsUV, FbxLayerElement::EType pTextureType);

    /** Read polygon group layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsPolygonGroup    polygon group layer element array
      * \return if reading polygon group layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsPolygonGroup  (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsPolygonGroup);

    /** Read smoothing layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsSmoothing       Smoothing group layer element array
      * \return if reading smoothing layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsSmoothing     (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsSmoothing);

    /** Read user data layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsUserData        User data layer element array
      * \return if reading user data layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsUserData      (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsUserData);

    /** Read visibility layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsVisibility      visibility layer element array
      * \return if reading visibility layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementsVisibility    (FbxGeometry* pGeometry, FbxArray<FbxLayerElement*>& pElementsVisibility);

    /** Read edge crease layer elements for geometry
      *	\param pGeometry                geometry to fill
      * \param pElementsEdgeCrease      edge crease layer element array
      * \return if reading edge crease layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementEdgeCrease     (FbxGeometry*pGeometry, FbxArray<FbxLayerElement*>& pElementsEdgeCrease);

    /** Read vertex crease layer elements for geometry
      * \param pGeometry                geometry to fill
      * \param pElementsVertexCrease    vertex crease layer element array
      * \return if reading vertex crease layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementVertexCrease   (FbxGeometry*pGeometry, FbxArray<FbxLayerElement*>& pElementsVertexCrease);

    /** Read hole layer elements for geometry
      * \param pGeometry                geometry to fill
      * \param pElementsHole            hole layer element array
      * \return if reading hole layer elements is successful return \c true, otherwise return \c false.        
      */
    bool ReadLayerElementHole           (FbxGeometry*pGeometry, FbxArray<FbxLayerElement*>& pElementsHole);
    //@}

    /**
    * \name Geometry weighted maps
    */
    //@{

    /** Read geometry weight map from file
      *	\param pGeometryWeightedMap     geometry weighted
      * \return if reading geometry weight map is successful return \c true, otherwise return \c false.
      */
    bool ReadGeometryWeightedMap(FbxGeometryWeightedMap& pGeometryWeightedMap);
    //@}

    /**
    * \name Deformers / Constraints
    */
    //@{

    /** Read link object from file
      *	\param pLink            fbx link object
      * \return if reading link object is successful return \c true, otherwise return \c false.
      */
    bool ReadLink(FbxCluster& pLink);

    /** Read SDK skin from file
      *	\param pSkin            SDK skin object
      * \return if reading skin object is successful return \c true, otherwise return \c false.
      */
    bool ReadSkin(FbxSkin& pSkin);

    /** Read properties and flags for vertex cache deformer from file
      *	\param pDeformer            fbx vertex cache deformer
      * \return if reading vertex cache deformer is successful return \c true, otherwise return \c false.
      */
    bool ReadVertexCacheDeformer(FbxVertexCacheDeformer& pDeformer);

    /** Read cluster object data from file
      *	\param pCluster            fbx cluster object
      * \return if reading cluster object is successful return \c true, otherwise return \c false.
      */
    bool ReadCluster(FbxCluster& pCluster);

    /** Read constraint object from file
      *	\param pPosition            fbx constraint object
      * \return if reading constraint object is successful return \c true, otherwise return \c false.
      */
    bool ReadConstraint(FbxConstraint& pPosition);
    //@}

    // Cache

    /** Read fbx cache file
      *	\param pCache       fbx cache
      * \return if reading cache data is successful return \c true, otherwise return \c false.
      */
    bool ReadCache(FbxCache& pCache);

    /**
    * \name Post-processing / utility functions
    */
    //@{

	/** Make sure the Camera's background textures are properly connected
	  * \param pScene			fbx scene
	  * \remarks This function only applies when it detects older file versions in 
	  * which the background texture is connected directly to the object instead of
	  * the corresponding property.
	 */
	bool ResolveCameraBackgrounds(FbxScene& pScene);

    /** Remove duplicate textures in the same scene
      *	\param pScene           fbx scene
      */
    void RemoveDuplicateTextures(FbxScene& pScene);

    /** Replace textures in the geometry
      *	\param pTextureDuplicate    texture array
      * \param pTextureReplacement  texture array to replace
      * \param pGeometry            geometry owns these textures
      * \param pTextureType         layer element type
      */
    void ReplaceTextures(FbxArray<FbxTexture*> const& pTextureDuplicate,
                         FbxArray<FbxTexture*> const& pTextureReplacement,
                         FbxGeometry* pGeometry, FbxLayerElement::EType pTextureType);

    /** Remove duplicated materials in the same scene
      *	\param pScene       FBX scene
      */    
    void RemoveDuplicateMaterials(FbxScene& pScene);

    /** convert camera name for naming convention
      *	\param pCameraName  original camera name
      * \return new name for the camera
      */
    FbxString ConvertCameraName(FbxString pCameraName);

    /** Search string in a string array
      *	\param pString      the string to search
      * \param pStringArray string array
      * \return return the index of the array if the string is found, otherwise return \c -1
      */
    int  FindString(FbxString pString, FbxArray<FbxString*>& pStringArray);

    /** Read password from string
      *	\param pPassword        password in string
      * \return if the password is valid return \c true, otherwise return \c false
      */
    bool ReadPassword(FbxString pPassword);

    /** Publish properties
      *	\param pObject      fbx object
      */
    void PublishProperties(FbxObject& pObject);

    /** Read properties for fbx object from file object
      *	\param pFbxObject                   fbx object
      * \param pFbxFileObject               fbx file object
      * \param pReadNodeAttributeProperties whether to read properties for node attributes
      */
    bool ReadProperties(FbxObject *pFbxObject, FbxIO *pFbxFileObject, bool pReadNodeAttributeProperties=true);


    /** Read properties and flags for fbx object from file object
      *	\param pFbxObject                   fbx object
      * \param pFbxFileObject               fbx file object
      * \param pReadNodeAttributeProperties whether to read properties for node attributes
      * \return if reading properties and flags is successful return \c true, otherwise return \c false.
      */
    bool ReadPropertiesAndFlags(FbxObject *pFbxObject, FbxIO *pFbxFileObject, bool pReadNodeAttributeProperties=true);

    /** Read flags for fbx object from file object
      *	\param pFbxObject               object to set flags
      * \param pFbxFileObject           file to read
      * \return if reading flags is successful return \c true, otherwise return \c false.  
      */
    bool ReadFlags(FbxObject *pFbxObject, FbxIO* pFbxFileObject);

    /** Rebuild trim regions indices from the boundary connections
      *	\param pScene           Fbx scene
      */
    void RebuildTrimRegions(FbxScene& pScene) const;

    /** Rebuild subdivision object from subdiv-mesh connections
    *	\param pScene           Fbx scene
    */
    void SetSubdivision(FbxScene& pScene) const;

	/** Convert shape deform property to DeformPercent property of FbxBlendShapeChannel
	*	\param pScene           Fbx scene
	*/
	void ConvertShapeDeformProperty(FbxScene& pScene) const;

    /** Rebuild layered texture alphas from sub texture connections.
      *	\param pScene           Fbx scene
      */
    void RebuildLayeredTextureAlphas(FbxScene& pScene) const;

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

    /** Read global settings, axis system, system unit from main section of file
      *
      */
    void ReadGlobalSettingsInMainSection();

    /** Read statistic data from definition section 
      *	
      */
    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;
};

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_FILEIO_FBX_READER_FBX6_H_ */