fbxreadercollada14.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_FILEIO_COLLADA_READER_H_
#define _FBXSDK_FILEIO_COLLADA_READER_H_

#include "fbxcolladautils.h"
#include "fbxcolladanamespace.h"

#include <fbxsdk/fbxsdk_nsbegin.h>

class FbxAnimLayer;

class FbxReaderCollada : public FbxReader 
{
public:

    FbxReaderCollada(FbxManager& pManager, int pID); 
    
    virtual ~FbxReaderCollada();
    

    
    virtual bool FileOpen(char* pFileName);
    
    virtual bool FileClose();

    virtual bool IsFileOpen();
    


    virtual bool GetReadOptions(bool pParseFileAsNeeded = true){ return true; }

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

    virtual FbxArray<FbxTakeInfo*>* GetTakeInfo();

    virtual bool Read(FbxDocument* pDocument);


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

#ifndef DOXYGEN_SHOULD_SKIP_THIS

private:


    bool ReadCollada(FbxScene &pScene, xmlNode* pXmlNode);

    bool ImportVisualScene(xmlNode* pXmlNode, FbxScene * pScene);

    bool ImportVisualSceneMax3DExtension(xmlNode * pTechniqueElement, FbxScene * pScene);

    bool ImportVisualSceneFCOLLADAExtension(xmlNode * pTechniqueElement, FbxScene * pScene);

    bool ImportVisualSceneMayaExtension(xmlNode * pTechniqueElement, FbxScene * pScene);

    bool ImportAsset(xmlNode* pXmlNode, FbxGlobalSettings & pGlobalSettings, FbxDocumentInfo &pSceneInfo);

    FbxNode * ImportNode(xmlNode* pXmlNode);

    bool ImportNodeFCOLLADAExtension(xmlNode* pTechniqueElement, FbxNode * pNode);

    bool ImportNodeXSIExtension(xmlNode* pTechniqueElement, FbxNode * pNode);

    bool ImportNodeFBXExtension(xmlNode* pTechniqueElement, FbxNode * pNode);

    FbxGeometry * ImportGeometry(const FbxString & pGeometryID, const FbxDynamicArray<FbxString> & pMaterialSequence);

    bool ImportSkin(xmlNode* pSkinElement);

    FbxGeometry * ImportMorph(xmlNode * pMorphElement, const FbxDynamicArray<FbxString> & pMaterialSequence);

    FbxGeometry * ImportController(const FbxString & pControllerID, const FbxDynamicArray<FbxString> & pMaterialSequence);

    FbxCamera * ImportCamera(xmlNode* pXmlNode);

    FbxLight * ImportLight(xmlNode* pXmlNode);

    FbxSurfaceMaterial * ImportMaterial(xmlNode* pXmlNode);

    FbxSurfaceMaterial * ImportEffect(xmlNode* pEffectElement);

    FbxSurfaceMaterial * ImportEffectNVidiaExtension(xmlNode * pEffectElement);

    FbxFileTexture * ImportTexture(xmlNode* pXmlNode);

    FbxFileTexture * ImportImage(xmlNode* pXmlNode);

    FbxGeometry * ImportMesh(xmlNode* pXmlNode, const FbxDynamicArray<FbxString> & pMaterialSequence);

    bool ImportVertices(xmlNode* pVerticesElement, FbxGeometry * pGeometry);

    bool ImportPolygons(xmlNode* pXmlNode, FbxMesh& pMesh, const FbxDynamicArray<FbxString> & pMaterialSequence);

    bool ImportTransforms(xmlNode* pXmlNode, FbxNode* pNode);

    int ImportRotationElement(xmlNode* pXmlNode, FbxVector4& pRotationVector);

    void SetRotationOrder(FbxNode * pNode, const std::vector<int> & pRotationOrder);

    bool ImportLookAt(xmlNode* pXmlNode, FbxVector4& lCameraPosition, 
                                         FbxVector4& lInterestPosition, FbxVector4& lUpVector,
                                         FbxAMatrix& lCameraTransformMatrix);



    
    bool IsNodeExportable(FbxString lId);
    
    bool CheckColladaVersion(const FbxString & pVersionString);




    void AddNotificationError( FbxString pError );

    void AddNotificationWarning( FbxString pWarning );

private:
    bool ImportScene(xmlNode * pColladaNode);

    void Preprocess(xmlNode * pColladaElement);

    void BuildUpLibraryMap();

    void BuildUpLibraryMap(xmlNode * pElement, const FbxString & pElementTag);

    bool ConnectMaterialsToNode(FbxNode * pNode, xmlNode * pElement, FbxDynamicArray<FbxString> & pMaterialSequence);

    bool ImportTransparent(xmlNode * pElement, FbxSurfaceLambert * pSurfaceMaterial);

    // Some traits with a typed element.
    struct LibraryTypeTraits
    {
        FbxString library_tag;
        FbxString element_tag;
    };

    FbxObject * GetLibrary(const LibraryTypeTraits & pTypeTraits, const FbxString & pID);
    FbxObject * GetLibrary(const LibraryTypeTraits & pTypeTraits, xmlNode * pElement);

    bool ImportMatrixAnimation(FbxNode * pNode, const FbxString & pAnimationChannelID);

    bool ImportPropertyAnimation(FbxProperty & pProperty, const FbxString & pAnimationChannelID, const char * pChannelName = NULL);

    FbxAnimLayer * GetAnimLayer(const FbxString & pAnimationID);

    double GetLocalUnitConversion(xmlNode * pElement);

    void SetProperty(xmlNode* pPropertyElement, FbxProperty & pProperty);

    void ImportPropertyValue(FbxObject * pObject, const char * pPropertyName,
                             xmlNode * pPropertyValueElement);

private:
    FbxFile*               mFileObject;
    FbxString                 mFileName;

    // XML lib stuff
    xmlDocPtr               mXmlDoc;

    FbxAnimLayer* mAnimLayer;
    FbxScene * mScene;

    // Save the global settings and document info in pre-reading
    FbxGlobalSettings * mGlobalSettings;
    FbxDocumentInfo * mDocumentInfo;
    FbxArray<FbxTakeInfo*> mTakeInfo;

    xmlNode * mColladaElement;

    struct ColladaElementData
    {
        explicit ColladaElementData(xmlNode * pElement = NULL)
            : mColladaElement(pElement), mFBXObject(NULL) {}
        xmlNode * mColladaElement;
        FbxObject * mFBXObject;
    };
    typedef std::map<FbxString, ColladaElementData> ColladaElementMapType;
    ColladaElementMapType mColladaElements;

    LibraryTypeTraits mEffectTypeTraits;
    LibraryTypeTraits mMaterialTypeTraits;
    LibraryTypeTraits mImageTypeTraits;
    LibraryTypeTraits mGeometryTypeTraits;
    LibraryTypeTraits mControllerTypeTraits;
    LibraryTypeTraits mLightTypeTraits;
    LibraryTypeTraits mCameraTypeTraits;
    LibraryTypeTraits mNodeTypeTraits;
    LibraryTypeTraits mAnimationTypeTraits;

    typedef std::map< FbxString, std::vector<xmlNode*> > AnimationMapType;
    AnimationMapType mAnimationElements;

    typedef std::map< FbxString, xmlNode* > SourceElementMapType;
    SourceElementMapType mSourceElements;

    struct AnimationClipData
    {
        AnimationClipData(const FbxString & pID) : mID(pID), mAnimLayer(NULL) {}

        FbxString mID;                                // ID of animation clip
        std::set<FbxString> mAnimationElementIDs;     // IDs of animation belong to this animation clip
        FbxAnimLayer * mAnimLayer;                 // The corresponding animation layer
    };
    std::vector<AnimationClipData> mAnimationClipData;

    // Map from skin ID to skin element.
    typedef std::map<FbxString, xmlNode *> SkinMapType;
    SkinMapType mSkinElements;

    // There are two distinct namespaces for node ID & SID mapping.
    // One with ID and the other with SID.
    typedef std::map<FbxString, FbxNode *> NodeMapType;
    NodeMapType mIDNamespaceNodes;
    NodeMapType mSIDNamespaceNodes;

    // Record the nodes which are to connect to its target node.
    // Save the ID of the target node if a node has its target
    std::map<FbxNode *, FbxString> mTargetIDs;

    FbxColladaNamespace mNamespace;

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_FILEIO_COLLADA_READER_H_ */