fbxmesh.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_MESH_H_
#define _FBXSDK_SCENE_GEOMETRY_MESH_H_

#include <fbxsdk/fbxsdk_def.h>

#include <fbxsdk/scene/geometry/fbxgeometry.h>

#include <fbxsdk/core/math/fbxvector4.h>
#include <fbxsdk/core/math/fbxvector2.h>

#include <fbxsdk/core/base/fbxarray.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

class FbxMesh;
class FbxManager;

class FBXSDK_DLL FbxMesh : public FbxGeometry
{
    FBXSDK_OBJECT_DECLARE(FbxMesh,FbxGeometry);

public:
    virtual FbxNodeAttribute::EType GetAttributeType() const;


    void BeginPolygon(int pMaterial = -1, int pTexture = -1, int pGroup = -1, bool pLegacy=true);

    void BeginPolygonExt(int pMaterial, int* pTextures);

    void AddPolygon(int pIndex, int pTextureUVIndex = -1);

    void EndPolygon();

    inline int GetPolygonCount() const { return mPolygons.GetCount(); }

    inline int GetPolygonSize(int pPolygonIndex) const
    {
        return (pPolygonIndex >= 0 && pPolygonIndex < mPolygons.GetCount()) ? mPolygons[pPolygonIndex].mSize : -1;
    }

    int GetPolygonGroup(int pPolygonIndex) const;

    inline void SetPolygonGroup(int pPolygonIndex, int pGroup) const
    {
        if (pPolygonIndex >= 0 && pPolygonIndex<mPolygons.GetCount())
            mPolygons[pPolygonIndex].mGroup = pGroup;
    }

    inline int GetPolygonVertex(int pPolygonIndex, int pPositionInPolygon) const
    {
        return (pPolygonIndex >= 0 && pPolygonIndex < mPolygons.GetCount() && pPositionInPolygon >= 0 && pPositionInPolygon < mPolygons[pPolygonIndex].mSize) ?
            mPolygonVertices[mPolygons[pPolygonIndex].mIndex + pPositionInPolygon] : -1;
    }

    bool GetPolygonVertexNormal(int pPolyIndex, int pVertexIndex, FbxVector4& pNormal) const;

    bool GetPolygonVertexNormals(FbxArray<FbxVector4>& pNormals) const;

    bool GetPolygonVertexUV(int pPolyIndex, int pVertexIndex, const char* pUVSetName, FbxVector2& pUV) const;

    bool GetPolygonVertexUVs(const char* pUVSetName, FbxArray<FbxVector2>& pUVs) const;

    int* GetPolygonVertices() const;

    int GetPolygonVertexCount() const;

    int GetPolygonVertexIndex( int pPolygonIndex ) const;

    int RemovePolygon(int pPolygonIndex);

    int RemoveDuplicatedEdges(FbxArray<int>& pEdgeIndexList);



    void InitTextureUV(int pCount, FbxLayerElement::EType pTypeIdentifier=FbxLayerElement::eTextureDiffuse);

    void AddTextureUV(FbxVector2 pUV, FbxLayerElement::EType pTypeIdentifier=FbxLayerElement::eTextureDiffuse);

    int GetTextureUVCount(FbxLayerElement::EType pTypeIdentifier=FbxLayerElement::eTextureDiffuse);

    int GetUVLayerCount() const;

    FbxArray<FbxLayerElement::EType> GetAllChannelUV(int pLayer);



    void InitMaterialIndices(FbxLayerElement::EMappingMode pMappingMode);

    void InitTextureIndices(FbxLayerElement::EMappingMode pMappingMode, FbxLayerElement::EType pTextureType);

    void InitTextureUVIndices(FbxLayerElement::EMappingMode pMappingMode, FbxLayerElement::EType pTypeIdentifier=FbxLayerElement::eTextureDiffuse);

    int GetTextureUVIndex(int pPolygonIndex, int pPositionInPolygon, FbxLayerElement::EType pTypeIdentifier=FbxLayerElement::eTextureDiffuse);


    void SetTextureUVIndex(int pPolygonIndex, int pPositionInPolygon, int pIndex, FbxLayerElement::EType pTypeIdentifier/*=FbxLayerElement::eTextureDiffuse*/);



    void Reset();

    void ComputeVertexNormals(bool pCW =  false);

    bool CheckIfVertexNormalsCCW();

    class DuplicateVertex
    {
    public:
        DuplicateVertex() :
          lVertexPolyIndex(0),
          lNewVertexIndex(0),
          lNormal(0,0,0)
          {
          };

        int lVertexPolyIndex ; 
        int lNewVertexIndex;   
        FbxVector4 lNormal;    
        FbxVector2 lUV;        

        int lEdgeIndex;         
    };

    class VertexNormalInfo
    {
    public:
        VertexNormalInfo():
          mTotalNormal(0,0,0),
          mNumNormal(0)
          {
          };

          FbxVector4 mTotalNormal; 
          int mNumNormal;          
    };

    bool CheckSamePointTwice() const;

    int RemoveBadPolygons();



    bool SplitPoints(FbxLayerElement::EType pTypeIdentifier=FbxLayerElement::eTextureDiffuse);

    bool BuildMergeList(FbxArray<int>& pMergeList, bool pExport=false);

    void MergePointsForPolygonVerteNormals(FbxArray<int> &pMergeList);




    void BuildMeshEdgeArray();

    int GetMeshEdgeCount() const;

    int GetMeshEdgeIndex( int pStartVertexIndex, int pEndVertexIndex, bool& pReversed, int pExistedEdgeCount = -1 );

    int GetMeshEdgeIndexForPolygon( int pPolygon, int pPositionInPolygon );

    void GetMeshEdgeVertices( int pEdgeIndex, int& pStartVertexIndex, int& pEndVertexIndex ) const;

    void BeginGetMeshEdgeVertices();

    void EndGetMeshEdgeVertices();

    void SetMeshEdgeCount( int pEdgeCount );

    inline void SetMeshEdge( int pEdgeIndex, int pValue )
    {
        if( pEdgeIndex >= 0 && pEdgeIndex < mEdgeArray.GetCount() ) mEdgeArray[pEdgeIndex] = pValue;
    }

    int AddMeshEdgeIndex( int pStartVertexIndex, int pEndVertexIndex, bool pCheckForDuplicates );

    int SetMeshEdgeIndex( int pEdgeIndex, int pStartVertexIndex, int pEndVertexIndex, bool pCheckForDuplicates, int pExistedEdgeCount=-1 );

    void BeginAddMeshEdgeIndex();

    void EndAddMeshEdgeIndex();


    int AddMeshEdgeIndexForPolygon( int pPolygonIndex, int pPositionInPolygon );

    bool SetMeshEdgeIndex( int pEdgeIndex, int pPolygonIndex, int pPositionInPolygon );


    struct ComponentMap
    {
        FbxArray<int> mData; 
        FbxArray<int> mOffsets; 

        int GetDataCount(int pIndex) { return mOffsets[pIndex + 1] - mOffsets[pIndex]; }
        int GetData(int pIndex, int pSubIndex) { return mData[ mOffsets[pIndex] + pSubIndex ]; }
        int GetComponentCount() { return mOffsets.GetCount() - 1; }
    };

    void ComputeComponentMaps( ComponentMap& pEdgeToPolyMap, ComponentMap& pPolyToEdgeMap );

    bool IsTriangleMesh() const;


    inline void ReservePolygonCount( int pCount ) { mPolygons.Reserve( pCount ); }

    inline void ReservePolygonVertexCount( int pCount ) { mPolygonVertices.Reserve( pCount ); }

    bool GetTextureUV(FbxLayerElementArrayTemplate<FbxVector2>** pLockableArray, FbxLayerElement::EType pTypeIdentifier=FbxLayerElement::eTextureDiffuse) const;
    bool GetMaterialIndices(FbxLayerElementArrayTemplate<int>** pLockableArray) const;
    bool GetTextureIndices(FbxLayerElementArrayTemplate<int>** pLockableArray, FbxLayerElement::EType pTextureType) const;



    double GetEdgeCreaseInfo(int pEdgeIndex);

    bool GetEdgeCreaseInfoArray(FbxLayerElementArrayTemplate<double>** pCreaseArray);

    double GetVertexCreaseInfo(int pVertexIndex);

    bool GetVertexCreaseInfoArray(FbxLayerElementArrayTemplate<double>** pCreaseArray);

    bool SetEdgeCreaseInfo(int pEdgeIndex, double pWeight);

    bool SetEdgeCreaseInfoArray(FbxArray<double>* pWeightArray);

    bool SetVertexCreaseInfo(int pVertexIndex, double pWeight);

    bool SetVertexCreaseInfoArray(FbxArray<double>* pWeightArray);



    enum ESmoothness
    {
        eHull,          
        eRough,         
        eMedium,        
        eFine           
    };

    enum EBoundaryRule
    {
        eLegacy,            
        eCreaseAll,     
        eCreaseEdge     
    };

    FbxMesh::ESmoothness GetMeshSmoothness() const;

    void SetMeshSmoothness(FbxMesh::ESmoothness pSmoothness);

    int GetMeshPreviewDivisionLevels() const;

    void SetMeshPreviewDivisionLevels(int pPreviewDivisionLevels);

    int GetMeshRenderDivisionLevels() const;

    void SetMeshRenderDivisionLevels(int pRenderDivisionLevels);

    bool GetDisplaySubdivisions() const;

    void SetDisplaySubdivisions(bool pDisplySubdivisions);

    EBoundaryRule GetBoundaryRule() const;

    void SetBoundaryRule(EBoundaryRule pBoundaryRule);

    bool GetPreserveBorders() const;

    void SetPreserveBorders(bool pPreserveBorders);

    bool GetPreserveHardEdges() const;

    void SetPreserveHardEdges(bool pPreserveHardEdges);

    bool GetPropagateEdgeHardness() const;

    void SetPropagateEdgeHardness(bool pPropagateEdgeHardness);



    bool GetPolyHoleInfo(int pFaceIndex);

    bool GetPolyHoleInfoArray(FbxLayerElementArrayTemplate<bool>** pHoleArray);


    bool SetPolyHoleInfo(int pFaceIndex, bool pIsHole);

    bool SetPolyHoleInfoArray(FbxArray<bool>* pHoleArray);


private:

    bool GenerateTangentsData(FbxLayerElementUV* pUVSet, int pLayerIndex, bool pOverwrite = false);

    bool ComputeTangents(FbxVector4* pPolyVetices, FbxVector2* pUvs, int pPolySize, FbxArray<FbxVector4> &pTan1, FbxArray<FbxVector4> &pTan2);

public:

    bool GenerateTangentsData(FbxString pUVSetName = "", bool pOverwrite = false);

    bool GenerateTangentsData(int pUVSetLayerIndex, bool pOverwrite = false);

    
    bool GenerateTangentsDataForAllUVSets(bool pOverwrite = false);


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

    virtual FbxObject& Copy(const FbxObject& pObject);

protected:
    void InitTextureIndices(FbxLayerElementTexture* pLayerElementTexture, FbxLayerElement::EMappingMode pMappingMode);
    void RemoveTextureIndex(FbxLayerElementTexture* pLayerElementTextures, int pPolygonIndex, int pOffset);
    void RemoveUVIndex(FbxLayerElementUV* pLayerElementUV, int pPolygonIndex, int pOffset);
    
    bool GetBadPolyIndices(FbxArray<int>& pArrayBadPolyIndices, bool pCheckOne) const;

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

    virtual void Destruct(bool pRecursive, bool pDependents);

    struct SplitEdgeData
    {
        int mOriginalEdge;
        bool mIsNew;
    };

    //smooth mesh preview
    ESmoothness mSmoothness;
    int mPreviewDivisionLevels;
    int mRenderDivisionLevels;

    bool mDisplaySubdivisions;
    EBoundaryRule mBoundaryRule;
    bool mPreserveBorders;
    bool mPreserveHardEdges;
    bool mPropagateEdgeHardness;

public:
    //Please use GetPolygonVertexIndex and GetPolygonVertices to access these arrays.
    //DO NOT MODIFY them directly, otherwise unexpected behavior will occur.
    //These members are public only for application data copy performance reasons.
    struct PolygonDef{ int mIndex; int mSize; int mGroup; };
    FbxArray<PolygonDef> mPolygons;
    FbxArray<int> mPolygonVertices;

protected:
    struct PolygonIndexDef
    {
        int mPolygonIndex;
        int mSubPolygonIndex;
    };

    struct V2PVMap
    {
        PolygonIndexDef* mV2PV;
        int* mV2PVOffset;
        int* mV2PVCount;
        int* mPVEdge;
        bool mValid;
    };

    V2PVMap mV2PVMap;

    struct EdgeLookupDef
    {
        FbxArray<int> mPVFlags;
        bool mValid;
    };

    EdgeLookupDef mPVEndFlags;

public:
    FbxArray< int > mEdgeArray;

protected:
    // Finds the polygon index for the given edge
    int FindPolygonIndex( int pEdgeIndex );
    static int PolygonIndexCompare( const void *p1, const void *p2 );

    void PolySetTexture(FbxLayer* pLayer, int pTextureIndex,
                        FbxLayerElement::EType pTextureType);
    template<class T> bool GetPolygonVertexLayerElementValue(const FbxLayerElementTemplate<T>* pLayerElement,
            int pPolyIndex, int pVertexIndex, T& pValue) const;

    friend class FbxGeometryConverter;
    friend class FbxWriter3ds;

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

};

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_SCENE_GEOMETRY_MESH_H_ */