topology.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 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.
//
//**************************************************************************/
// DESCRIPTION:
// CREATED: October 2008
//**************************************************************************/

#include <memory.h>

namespace mudbox {
    
typedef short int tnormal;
typedef unsigned long long tnormalv;

struct Normal
{
    union
    {
        tnormal m_vNormal[4];
        tnormalv m_iNormal;
    };
};


class MBDLL_DECL Topology : virtual public TreeNode
{
public:
    enum FaceState
    {
        fsSelected = 0x01,
        fsVisible = 0x02,
        fsFake = 0x04,
        fsActive = 0x08,
        fsMapped = 0x10,
        // fsTemp = 0x20    // for performance reasons, the temp state is split into a seperate vector
    };

    enum FaceComponent
    {
        fcIndex = 1,
        fcAdjacency = 2,
        fcTCIndex = 4,
        fcNormal = 8,
        fcID = 16,
        fcOctree = 32,
        fcFreeze = 64,
        fcState = 128
    };
    enum FaceType
    {
        typeTriangular,
        typeQuadric
    };

private:
    Store<unsigned int>  m_pTCI;
    Store<unsigned int>  m_pAdjacency;
public:
    Store<unsigned int>  m_pIndices;
private:
    Store<unsigned char> m_pFaceState;
    Store<unsigned char> m_pFaceTemp; // this is split out from the state byte for performance reasons. -- I.A.
    Store<unsigned int>  m_pFaceIDs;

    FaceType m_eType;
    int m_eFaceComponents;
    unsigned int m_iFaceCount;

protected:
    Topology( void );
    Topology( FaceType eType );
public:

    void MoveTo( Topology *pDestination );


    void CopyTo( Topology *pDestination ) const;
    void Serialize( Stream &s );
    inline FaceType Type( void ) const { return m_eType; };
    void SetType( FaceType eType );
    int SideCount( void ) const { return Type() == typeTriangular ? 3 : 4; };

    // basic data access
    inline unsigned int FaceCount( void ) const { return m_iFaceCount; };
    virtual Vector FaceNormal( unsigned int iFaceIndex ) const;
    inline void SetFaceID( unsigned int iFaceIndex, unsigned int iID ) { m_pFaceIDs[iFaceIndex] = iID; };
    inline unsigned int FaceID( unsigned int iFaceIndex ) const { return m_pFaceIDs[iFaceIndex]; };

    virtual void SetFakeTriangleCount( unsigned int iFakeTriangleCount );

    inline unsigned int QuadIndex( unsigned int iFaceIndex, unsigned int iCornerIndex ) const { return m_pIndices[iFaceIndex*4+iCornerIndex]; };
    inline void SetQuadIndex( unsigned int iFaceIndex, unsigned int iCornerIndex, unsigned int iValue ) { m_pIndices[iFaceIndex*4+iCornerIndex] = iValue; };
    inline unsigned int QuadTCI( unsigned int iFaceIndex, unsigned int iCornerIndex ) const { return m_pTCI[iFaceIndex*4+iCornerIndex]; }
    inline void SetQuadTCI( unsigned int iFaceIndex, unsigned int iCornerIndex, unsigned int iValue ) { m_pTCI[iFaceIndex*4+iCornerIndex] = iValue; }
    virtual inline unsigned int QuadAdjacency( unsigned int iFaceIndex, unsigned int iSideIndex ) const { return m_pAdjacency[iFaceIndex*4+iSideIndex]; }
    inline unsigned int QuadAdjacency_ForcedInline( unsigned int iFaceIndex, unsigned int iSideIndex ) const { return m_pAdjacency[iFaceIndex*4+iSideIndex]; }
    virtual inline void SetQuadAdjacency( unsigned int iFaceIndex, unsigned int iSideIndex, unsigned int iValue ) 
        { m_pAdjacency[iFaceIndex*4+iSideIndex] = iValue; }
    inline bool HasAdjacentQuad( unsigned int iFaceIndex, unsigned int iSideIndex ) const { return QuadAdjacency( iFaceIndex, iSideIndex ) < 0x80000000; };

    inline unsigned int TriangleIndex( unsigned int iFaceIndex, unsigned int iCornerIndex ) const { return m_pIndices[iFaceIndex*3+iCornerIndex]; };
    inline void SetTriangleIndex( unsigned int iFaceIndex, unsigned int iCornerIndex, unsigned int iValue ) { m_pIndices[iFaceIndex*3+iCornerIndex] = iValue; };
    inline unsigned int TriangleTCI( unsigned int iFaceIndex, unsigned int iCornerIndex ) const { return m_pTCI[iFaceIndex*3+iCornerIndex]; }
    inline void SetTriangleTCI( unsigned int iFaceIndex, unsigned int iCornerIndex, unsigned int iValue ) { m_pTCI[iFaceIndex*3+iCornerIndex] = iValue; }
    virtual inline unsigned int TriangleAdjacency( unsigned int iFaceIndex, unsigned int iSideIndex ) const { return m_pAdjacency[iFaceIndex*3+iSideIndex]; }
    virtual inline void SetTriangleAdjacency( unsigned int iFaceIndex, unsigned int iSideIndex, unsigned int iValue ) 
        { m_pAdjacency[iFaceIndex*3+iSideIndex] = iValue; }
    inline bool HasAdjacentTriangle( unsigned int iFaceIndex, unsigned int iSideIndex ) const 
        { return TriangleAdjacency( iFaceIndex, iSideIndex ) < 0x80000000; };

    inline unsigned char &FaceState( unsigned int iFaceIndex ) { return m_pFaceState[iFaceIndex]; };
    inline unsigned char FaceState( unsigned int iFaceIndex ) const { return m_pFaceState[iFaceIndex]; };

    inline bool IsFaceSelected( unsigned int iFaceIndex ) const { return (FaceState( iFaceIndex ) & fsSelected) != 0; };
    virtual void SetFaceSelected( unsigned int iFaceIndex, bool bSelected = true, bool bUpdateVertexSelection = false, bool bBatchSelection = false );

    virtual unsigned int SelectedFaceCount() const;

    inline bool IsFaceVisible( unsigned int iFaceIndex ) const { return (FaceState( iFaceIndex ) & fsVisible) != 0; };
    inline void SetFaceVisible( unsigned int iFaceIndex, bool bSelected = true ) 
        { if ( bSelected ) FaceState( iFaceIndex ) |= fsVisible; else FaceState( iFaceIndex ) &= 0xff-fsVisible; };
    inline bool IsFaceActive( unsigned int iFaceIndex ) const { return (FaceState( iFaceIndex ) & fsActive) != 0; };
    inline void SetFaceActive( unsigned int iFaceIndex, bool bSelected = true ) 
        { if ( bSelected ) FaceState( iFaceIndex ) |= fsActive; else FaceState( iFaceIndex ) &= 0xff-fsActive; };
    inline bool IsFaceMapped( unsigned int iFaceIndex ) const { return (FaceState( iFaceIndex ) & fsMapped) != 0; };
    inline void SetFaceMapped( unsigned int iFaceIndex, bool bSelected = true ) 
        { if ( bSelected ) FaceState( iFaceIndex ) |= fsMapped; else FaceState( iFaceIndex ) &= 0xff-fsMapped; };

    inline bool IsFakeTriangle( unsigned int iTriangleIndex ) const 
        { return iTriangleIndex < FaceCount() && (FaceState( iTriangleIndex ) & fsFake); };
    inline void SetFakeTriangle( unsigned int iTriangleIndex, bool b ) 
        { if( iTriangleIndex < FaceCount() ) { 
            if ( b ) FaceState( iTriangleIndex ) |= fsFake; 
            else     FaceState( iTriangleIndex ) &= 0xff-fsFake; 
          }; 
        };

    inline bool IsFaceTemp( unsigned int iFaceIndex ) const { return m_pFaceTemp[iFaceIndex]; };
    inline void SetFaceTemp( unsigned int iFaceIndex, bool bSelected = true ) 
        { m_pFaceTemp[iFaceIndex] = bSelected; }

    // do a fast clear of all the temp state flags for all the faces.
    inline void ClearFaceTempStates()
    {
        MB_ASSERT(m_iFaceCount <= m_pFaceTemp.ItemCount()); 
        memset(&m_pFaceTemp[0], 0, m_iFaceCount);  // memset is the fastest way to clear the array.
    }

    virtual void AddFaceComponent( FaceComponent eComponentToAdd );

    virtual void RemoveFaceComponent( FaceComponent eComponentToRemove );
    inline unsigned int FaceComponents( void ) const { return m_eFaceComponents; };
    void SetFaceCount( unsigned int iFaceCount );
    virtual bool SetAdjacencyCount( unsigned int iCount, bool bKeepContent = true, bool bForced = false );
    inline unsigned int AdjacencyCount( void ) const { return m_pAdjacency.ItemCount(); };

    virtual bool HasTShape() const;
    virtual void SetHasTShape( bool bHasTShape );

    // Used only to solve some old compatibility issues

    friend class ::XMesh;
};

}; // end of namespace mudbox