fbxmesh.h

Go to the documentation of this file.

/****************************************************************************************
 
   Copyright (C) 2017 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/core/base/fbxarray.h>
#include <fbxsdk/core/base/fbxset.h>
#include <fbxsdk/scene/geometry/fbxgeometry.h>

#include <fbxsdk/fbxsdk_nsbegin.h>

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

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

        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, bool& pUnmapped) const;

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

        int* GetPolygonVertices() const;

        inline int GetPolygonVertexCount() const { return mPolygonVertices.Size(); }

        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);

        void Reset();

        bool GenerateNormals(bool pOverwrite=false, bool pByCtrlPoint = false, bool pCW=false);

        bool CheckIfVertexNormalsCCW();

        class DuplicateVertex
        {
        public:
            DuplicateVertex() :
                lVertexPolyIndex(0),
                lNewVertexIndex(0),
                lNormal(0, 0, 0),
                lUV(0, 0),
                lEdgeIndex(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);

        void MergePointsForPolygonVerteNormals(FbxArray<int> &pMergeList);

        void BuildMeshEdgeArray();

        int GetMeshEdgeCount() const;

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

        void BeginGetMeshEdgeIndexForPolygon();

        void EndGetMeshEdgeIndexForPolygon();

        int GetMeshEdgeIndexForPolygon(int pPolygon, int pPositionInPolygon);

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

        void BeginGetMeshEdgeVertices();

        void EndGetMeshEdgeVertices();

        void SetMeshEdgeCount(int pEdgeCount);

        inline bool SetMeshEdge(int pEdgeIndex, int pValue)
        { 
            if (pEdgeIndex >= 0 && pEdgeIndex < mEdgeArray.GetCount())
            {
                FBX_ASSERT(pValue >= 0 && pValue < mPolygonVertices.GetCount());

                if (pValue < 0 || pValue >= mPolygonVertices.GetCount())
                {
                    pValue = 0;
                    return false;
                }

                mEdgeArray[pEdgeIndex] = pValue;
            }
            return true;
        }

        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);

        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);

        bool GenerateTangentsData(const char* pUVSetName=NULL, bool pOverwrite=false, bool pIgnoreTangentFlip = false);

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

    
        bool GenerateTangentsDataForAllUVSets(bool pOverwrite=false, bool pIgnoreTangentFlip=false);

/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    FbxObject& Copy(const FbxObject& pObject) override;
    void Compact() override;

    //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;
    FbxArray<int>           mEdgeArray;

    //These are only used in context of triangulation to backup original polygon layout necessary for handling mesh cache after triangulation
    FbxArray<PolygonDef>*   mOriginalPolygons;
    FbxArray<int>*          mOriginalPolygonVertices;
    int                     mOriginalControlPointsCount;

    //Internal structure used to keep the mapping information between edges and polygons.
    struct ComponentMap
    {
        FbxArray<int> mData; // The array to store data.
        FbxArray<int> mOffsets; // The array to store the offsets of the data in mData.

        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);

    // Internal structure used to keep the mapping information between the control points and the
    // vertices referencing them
    class FBXSDK_DLL ControlPointToVerticesMap
    {
    public:
        bool Valid();

        void FillWithControlPointInfo(FbxMesh* pMesh);
        bool FillWithAdjacencyInfo(FbxMesh* pMesh, int pNbControlPoints);

        int  GetCount();
        void Clear();

        int GetCount(int pControlPoint) const;
        int GetVertex(int pControlPoint, int pVertex) const;

    private:
        FbxArray<int> mStartIndices;
        FbxArray<int> mVertexIndices;
    };
    void ComputeControlPointToVerticesMap(ControlPointToVerticesMap& pMap);

    // this function will compare the vertex normals with the corresponding ones in pMesh and 
    // make them similar (i.e: if pMesh(NVi) == pMesh(NVj) then make this(NVi) == this(NVj))
    bool ConformNormalsTo(const FbxMesh* pMesh);

protected:
    void Construct(const FbxObject* pFrom) override;
    void Destruct(bool pRecursive) override;
    void ContentClear() override;

    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;

    struct SplitEdgeData { int mOriginalEdge; bool mIsNew; };

    ESmoothness     mSmoothness;
    int             mPreviewDivisionLevels;
    int             mRenderDivisionLevels;

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

    struct PolygonIndexDef { int mPolygonIndex; int mSubPolygonIndex; };

    struct V2PVMap
    {
        struct EdgeCompare
        {
            inline int operator()(FbxPair<int, int> const& pKeyA, FbxPair<int, int> const& pKeyB) const
            {
                int lResult = pKeyA.mSecond - pKeyB.mSecond;
                if (lResult == 0) return pKeyA.mFirst - pKeyB.mFirst;
                else return lResult;
            }
        };

        PolygonIndexDef* mV2PV;
        int* mV2PVOffset;
        int* mV2PVCount;
        FbxSet<FbxPair<int, int>, EdgeCompare, FbxHungryAllocator> mPVEdges;
        bool mValid;

        //Used for fast search in GetMeshEdgeIndexForPolygon this array does not follow the same allocation as the above ones because
        //it is not used in the normal BeginAddMeshEdgeIndex(). It is filled only by the call to BeginGetMeshEdgeIndexForPolygon().
        FbxArray<int> mV2Edge;
    } mV2PVMap;

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

    //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  GetPolygonVertexLayerElementIndex(const FbxLayerElementTemplate<T>* pLayerElement, int pPolyIndex, int pVertexIndex, int& pIndex) const;
    template<class T> bool  GetPolygonVertexLayerElementValue(const FbxLayerElementTemplate<T>* pLayerElement, int pPolyIndex, int pVertexIndex, T& pValue, bool pAllowUnmapped) const;

    friend class FbxGeometryConverter;

private:
    bool GenerateTangentsData(FbxLayerElementUV* pUVSet, int pLayerIndex, bool pOverwrite=false, bool pIgnoreTangentFlip = false);
    void FillMeshEdgeTable(FbxArray<int>& pTable, int* pValue, void (*FillFct)(FbxArray<int>& pTable, int pIndex, int* pValue));
    void ComputeNormalsPerCtrlPoint(FbxArray<VertexNormalInfo>& lNormalInfo, bool pCW=false);
    void ComputeNormalsPerPolygonVertex(FbxArray<VertexNormalInfo>& lNormalInfo, bool pCW=false);
    void GenerateNormalsByCtrlPoint(bool pCW);

    int GetIndex(int index, int capacity) const;

#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};

#include <fbxsdk/fbxsdk_nsend.h>

#endif /* _FBXSDK_SCENE_GEOMETRY_MESH_H_ */