mesh.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
//**************************************************************************/
                                                    

#if defined(_MSC_VER)
#ifndef __attribute__
#define __attribute__(_a)
#endif
#endif

namespace mudbox {

class SpatialGrid;

#ifndef MB_NORMALPRECISION
#define MB_NORMALPRECISION 16
#endif

#ifndef MB_NORMALMAX
#if MB_NORMALPRECISION == 16
//typedef short int tnormal;
//typedef qint64 tnormalv;
#define MB_NORMALMAX 32767
#else
#if MB_NORMALPRECISION == 8
//typedef char tnormal;
//typedef int tnormalv;
#define MB_NORMALMAX 127
#else
#error MB_NORMALPRECISION must be either 8 or 16
#endif
#endif
#endif

#ifndef INVALID_ID
#define INVALID_ID (0xffffffff)
#endif


struct MBDLL_DECL Vertex
{
    inline Vertex( void ) { m_iStrokeID = 0; m_iStates = 0; };

    // data
    Vector m_vPos;
    mutable unsigned int m_iStrokeID;
    //union
    //{ 
    //  tnormal m_vNormal[4];
    //  tnormalv m_iNormal;
    //};
    unsigned short m_iStates;

    inline float Freeze( void ) const 
        { return ((float)(unsigned char)(m_iStates&0x7f)) * (1.0f/0x7f); };
    
    inline void SetFreeze( float fFreeze ) 
        { m_iStates = (m_iStates&0xff80)+(unsigned int)(0x7f*fFreeze); };
    
    inline float Mask( void ) const 
        { return ((float)(unsigned char)(m_iStates>>8)) * (1.0f/0xff); };
    
    inline void SetMask( float fMask ) 
        { m_iStates = (m_iStates&0xff)+(((unsigned int)(0xff*fMask))<<8); };
    
    inline bool IsSelected( void ) const { return (m_iStates&0x80) != 0; };
    
    inline void SetSelected( bool bSelected ) 
        { m_iStates = (m_iStates&0xff7f)+bSelected*0x80; };
};

struct GenericFace
{
    unsigned int GetSides( void ) { return m_aIndices.ItemCount(); };
    unsigned int Adjacency( unsigned int i) { return m_aAdjacents[i]; };
    unsigned int TCI( unsigned int i ) { return m_aTCIs[i]; };
    void Serialize( Stream &s )
    {
        m_aIndices.Serialize( s );
        m_aAdjacents.Serialize( s );
        m_aTCIs.Serialize( s );
    };
    const GenericFace & operator=(const GenericFace &rhs)
    {
        rhs.m_aIndices.Copy(m_aIndices);
        rhs.m_aAdjacents.Copy(m_aAdjacents);
        rhs.m_aTCIs.Copy(m_aTCIs);
        return *this;
    }

    Store<unsigned int> m_aIndices;
    Store<unsigned int> m_aAdjacents;
    Store<unsigned int> m_aTCIs;
};


struct MBDLL_DECL TC
{
    TC( void ) {m_fU = m_fV = 0.0f;};
    TC( float fU, float fV ) { m_fU = fU; m_fV = fV; };
    inline bool operator ==( const TC &a ) const { return m_fU == a.m_fU && m_fV == a.m_fV; };
    inline bool operator !=( const TC &a ) const { return !operator==( a ); };
    inline TC operator +( const TC &a ) const { return TC( m_fU + a.m_fU, m_fV + a.m_fV ); };
    inline TC operator -( const TC &a ) const { return TC( m_fU - a.m_fU, m_fV - a.m_fV ); };
    inline TC operator *( float f ) const { return TC( m_fU * f, m_fV * f ); };
    inline TC operator /( float f ) const { f = 1.0f/f; return TC( m_fU * f, m_fV * f ); };
    inline TC &operator +=( const TC &a ) { m_fU += a.m_fU, m_fV += a.m_fV; return *this; };
    inline TC &operator -=( const TC &a ) { m_fU -= a.m_fU, m_fV -= a.m_fV; return *this; };
    inline TC &operator *=( float f ) { m_fU *= f, m_fV *= f; return *this; };
    inline TC &operator /=( float f ) { f = 1.0f/f; m_fU *= f, m_fV *= f; return *this; };
    inline operator bool( void ) const throw() { return m_fU || m_fV; };
    inline operator Vector( void ) const throw() { return Vector( m_fU, m_fV, 0 ); };
    inline operator const float *( void ) const { return &u; };
    void Normalize( void );
    float Length( void );
    union
    {
        float m_fU;
        float u;
    };
    union
    {
        float m_fV;
        float v;
    };
};

struct VertexAdjacency
{
public:

    inline VertexAdjacency() : m_iFaceIndex(INVALID_ID), m_iCornerIndex(0xff) {};

    inline VertexAdjacency( unsigned int iFaceIndex, unsigned char iCornerIndex ) :
        m_iFaceIndex(iFaceIndex), m_iCornerIndex(iCornerIndex) {};

    inline bool IsValid() const { return m_iCornerIndex < 0xff; }

    inline unsigned int FaceIndex() const { return m_iFaceIndex; }

    inline unsigned char CornerIndex() const { return m_iCornerIndex; }

private:
    unsigned int m_iFaceIndex;
    unsigned char m_iCornerIndex;
};

class MBDLL_DECL FaceEnumerator
{
public:
    virtual void Operator(
        class Mesh *pMesh,          
        unsigned int iFaceIndex     
        );
    
    virtual bool Tester(
        class Mesh *pMesh,          
        unsigned int iFaceIndex     
        );
};




class MBDLL_DECL VertexEnumerator
{
public:
    virtual void Operator(
        class Mesh *pMesh,          
        unsigned int iVertexIndex,  
        unsigned int iFaceIndex     
        );
        
    virtual bool Tester(
        class Mesh *pMesh,          
        unsigned int iVertexIndex,  
        unsigned int iFaceIndex     
        );
};


class MBDLL_DECL AdjacentVertexEnumerator
{
public:
    virtual void ProcessAdjacentVertex(
        unsigned int iVertexIndex,  
        unsigned int iFaceIndex     
        );
        
    bool m_bEdge;  
    
    unsigned char m_iCurrentCorner;     
    unsigned char m_iVertexCorner;      

    bool m_bEnumerateFakeTriangles;     

    AdjacentVertexEnumerator();
    virtual ~AdjacentVertexEnumerator();
};

struct StoredVertexInfo
{
    Vector        m_vPosition;
    unsigned int  m_iID;
    union
    {
        tnormalv  m_iNormal;
        tnormal   m_vNormal[4];
    };
    float     m_fData;
    unsigned int  m_iVertexIndex;
    unsigned int  m_iFaceIndex;
    unsigned int  m_iLayerVertexIndex;
};



struct MBDLL_DECL SurfacePoint
{
    class Mesh   *m_pMesh;          
    unsigned int  m_iFaceIndex;     
    float         m_fRelativeRange; 
    Vector        m_vLocalPosition; 
    Vector        m_vLocalNormal;   
    bool          m_bSide;          
    class TangentGenerator *m_pTG;  

    SurfacePoint( void ) : m_pMesh(0), m_iFaceIndex(0xffffffff), m_fRelativeRange(0), m_bSide(false), m_pTG( NULL ) {}
    
    SurfacePoint(
        class Mesh   *pMesh,            
        unsigned int  iVertexIndex,     
        unsigned int  iFaceIndex        
        );
        
    class Mesh *Mesh( void ) const;
    
    unsigned int FaceIndex( void ) const;
        
    Vector LocalPosition( void ) const;
    
    Vector WorldPosition( void ) const;
    
    Vector LocalNormal( void ) const;
    
    Vector WorldNormal( void ) const;

    TC TextureCoordinate( void ) const;
    
    Base TangentBase( void ) const;

    Vector FaceCoordinates( void ) const;

    bool Fill(
        class Mesh *pMesh,  
        unsigned int iFaceIndex,    
        const Vector &vStart,       
        const Vector &vEnd,         
        bool bTwoSide = false,      
        bool bOriginalPosition = false
        );

    void Fill(
        class Mesh *pMesh,          
        unsigned int iFaceIndex,    
        float fFaceU,               
        float fFaceV                
        );

    void Fill(
        class Mesh *pMesh,          
        unsigned int iFaceIndex,        
        const Vector &vLocalPosition,   
        bool bRecalculatePosition   
        );
    
    void SetTangentGenerator( 
                             TangentGenerator *pGenerator   
                             );

    void Align( void ); 

    void Mirror( void );

    void Serialize( Stream& s );

    mutable Vector m_vFaceCoordinates;
};

class MBDLL_DECL Mesh : public Topology
{
    DECLARE_CLASS;

protected:
    Mesh(
        FaceType eFaceType = typeQuadric    
        );

public:
    virtual class Geometry *Geometry( void ) const;

    virtual class MeshRenderer *Renderer(
        float fLODLevel = 1.0f  
        );

    virtual void CopyTo( Node *pNode ) const;

    virtual class Material *Material( void ) const;

    virtual class Material *MaterialOverride( void ) const;

    inline unsigned int VertexCount( void ) const { return m_iVertexCount; };
    
    void SetVertexCount(
        unsigned int iVertexCount   
        );
    
    inline unsigned int TCCount( void ) const { return m_pTCs.ItemCount(); };

    virtual void SetTCCount( 
        unsigned int iTCCount 
        );
    
    bool HasTC( bool bIgnorePtexUV = false ) const;

    virtual unsigned int UVlessPaintingStatus( void ) const;

    virtual void SetUVlessPaintingStatus(
        unsigned int iStatus    
        );

    inline const Vertex *VertexArray( void ) const { return &m_pVertices[0]; };

    inline const Vertex &VertexData(
        unsigned int iVertexIndex   
        ) const { return m_pVertices[iVertexIndex]; };
    
    inline Vertex &VertexData(
        unsigned int iVertexIndex   
        ) { return m_pVertices[iVertexIndex]; };
        
    inline const Vector &VertexPosition(
        unsigned int iVertexIndex   
        ) const { return m_pVertices[iVertexIndex].m_vPos; };
    
    inline Vector &VertexPosition(
        unsigned int iVertexIndex   
        ) { return m_pVertices[iVertexIndex].m_vPos; };
    
    virtual const Vector &VertexOriginalPosition(
        unsigned int iVertexIndex   
        ) const { return m_pVertices[iVertexIndex].m_vPos; };
    
    inline const TC &VertexTC(
        unsigned int iVertexTCIndex 
        ) const { return m_pTCs[iVertexTCIndex]; };
    
    inline Vector VertexNormal(
        unsigned int iVertexIndex   
        ) const { return Vector( m_pVertexNormals[iVertexIndex].m_vNormal ); };
        
    inline unsigned int VertexStrokeID( unsigned int iVertexIndex ) const 
        { return m_pVertices[iVertexIndex].m_iStrokeID; };
    
    inline float VertexMask(
        unsigned int iVertexIndex   
        ) const { return m_pVertices[iVertexIndex].Mask(); };
    
    inline float VertexFreeze(
        unsigned int iVertexIndex   
        ) const { return m_pVertices[iVertexIndex].Freeze(); };
    
    virtual unsigned int FrozenVertexCount( void ) const;

    inline const tnormal *VertexNormalArray(
        unsigned int iVertexIndex   
        ) const { return m_pVertexNormals[iVertexIndex].m_vNormal; };
    
    inline tnormalv VertexNormalValue(
        unsigned int iVertexIndex   
        ) const { return m_pVertexNormals[iVertexIndex].m_iNormal; };
    
    inline const Normal *VertexNormalArray( void ) const { return &m_pVertexNormals[0]; };

    inline unsigned int VertexNormalCount( void ) const { return m_pVertexNormals.ItemCount(); }

    virtual AxisAlignedBoundingBox BoundingBox( bool bRecalculate = false ) const;

    virtual void SetBoundingBox( const AxisAlignedBoundingBox& cBox );

    virtual AxisAlignedBoundingBox StrokeBoundingBox() const;

    virtual void SetStrokeBoundingBox( const AxisAlignedBoundingBox& cBox );

    virtual AxisAlignedBoundingBox TCBoundingBox( void ) const;

    inline void SetVertexPosition(
        unsigned int iVertexIndex,  
        const Vector &vPosition     
        ) { m_pVertices[iVertexIndex].m_vPos = vPosition; };
        
    inline void AddVertexPosition(
        unsigned int iVertexIndex,  
        const Vector &vPosition     
        )
    { m_pVertices[iVertexIndex].m_vPos += vPosition; };
    
    inline void SetVertexNormal( unsigned int iVertexIndex, int *pNormal)
    {
        m_pVertexNormals[iVertexIndex].m_vNormal[0] = tnormal(pNormal[3]);
        m_pVertexNormals[iVertexIndex].m_vNormal[1] = tnormal(pNormal[2]);
        m_pVertexNormals[iVertexIndex].m_vNormal[2] = tnormal(pNormal[1]);
    };
    
    inline void SetVertexNormal(
        unsigned int iVertexIndex,  
        const Vector &vNormal       
        )
        {
            m_pVertexNormals[iVertexIndex].m_vNormal[0] = tnormal(vNormal.x * MB_NORMALMAX);
            m_pVertexNormals[iVertexIndex].m_vNormal[1] = tnormal(vNormal.y * MB_NORMALMAX);
            m_pVertexNormals[iVertexIndex].m_vNormal[2] = tnormal(vNormal.z * MB_NORMALMAX);
        };
        
    // Adds vNormal to the current normal of the vertex with the given index.
    //void AddVertexNormal(
    //  unsigned int iVertexIndex,  ///< [in] index of the vertex
    //  const Vector &vNormal       ///< [in] x,y,z offset to be added to the normal
    //  );
    
    inline void SetVertexTC(
        unsigned int iTCIndex,  
        const TC &tc            
        ) { m_pTCs[iTCIndex] = tc; }

    virtual void SetVertexFreeze(
        unsigned int iVertexIndex,  
        unsigned int iFaceIndex,    
        float fFreeze               
        );

    virtual void SetFreezeValues(
        Store<float> &aNewFreeze    
        );

    void SetVertexMask( unsigned int iVertexIndex, unsigned int iFaceIndex, float fFMask );
    
    inline void SetVertexStrokeID( unsigned int iVertexIndex, unsigned int iStrokeID ) const 
        { m_pVertices[iVertexIndex].m_iStrokeID = iStrokeID; };

    inline unsigned int &GetVertexID( unsigned int iIndex )
    {
        Vertex &v = m_pVertices[iIndex];
        if ( v.m_iStrokeID < m_iRestoreCount && m_aRestoreBuffer[v.m_iStrokeID].m_iVertexIndex == iIndex )
            return m_aRestoreBuffer[v.m_iStrokeID].m_iID;
        return v.m_iStrokeID;
    };

    inline void MarkVertex( unsigned int iVertexIndex )
    {
        GetVertexID( iVertexIndex ) = CollectionID();
    };

    inline bool IsVertexMarked( unsigned int iVertexIndex )
    {
        return GetVertexID( iVertexIndex ) == CollectionID();
    };


    inline void ClearVertexMarks( void )
    {
        IncreaseCollectionID();
    };


    virtual unsigned int VertexExternalIndex( 
        unsigned int iVertexIndex 
        ) const; 

    virtual void SetVertexExternalIndex( 
        unsigned int iVertexIndex, 
        unsigned int iExternalVertexIndex 
        );
    
    inline const Vector &TriangleVertexPosition(
        unsigned int iTriangleIndex,    
        unsigned int iCornerIndex       
        ) const { return VertexPosition( TriangleIndex( iTriangleIndex, iCornerIndex ) ); };

    inline const Vector &QuadVertexPosition(
        unsigned int iQuadIndex,    
        unsigned int iCornerIndex   
        ) const { return VertexPosition( QuadIndex( iQuadIndex, iCornerIndex ) ); };
        
    const TC &TriangleVertexTC(
        unsigned int iTriangleIndex,    
        unsigned int iCornerIndex       
        ) const { return VertexTC( TriangleTCI( iTriangleIndex, iCornerIndex ) ); };
        
    const TC &QuadVertexTC(
        unsigned int iQuadIndex,    
        unsigned int iCornerIndex   
        ) const { return VertexTC( QuadTCI( iQuadIndex, iCornerIndex ) ); };

    inline Vector TriangleVertexNormal(
        unsigned int iTriangleIndex,    
        unsigned int iCornerIndex       
        ) const { return VertexNormal( TriangleIndex( iTriangleIndex, iCornerIndex ) ); };

    inline Vector QuadVertexNormal(
        unsigned int iQuadIndex,    
        unsigned int iCornerIndex   
        ) const { return VertexNormal( QuadIndex( iQuadIndex, iCornerIndex ) ); };

    inline Vector TriangleVertexCreaseNormal(
        unsigned int iTriangleIndex,    
        unsigned int iCornerIndex       
        ) const { return VertexNormal( TriangleCreaseNormalIndex( iTriangleIndex, iCornerIndex ) ); };

    inline Vector QuadVertexCreaseNormal(
        unsigned int iQuadIndex,    
        unsigned int iCornerIndex   
        ) const { return VertexNormal( QuadCreaseNormalIndex( iQuadIndex, iCornerIndex ) ); };

    inline float TriangleVertexFreeze(
        unsigned int iTriangleIndex,    
        unsigned int iCornerIndex       
        ) const { return VertexFreeze( TriangleIndex( iTriangleIndex, iCornerIndex ) ); };

    inline float QuadVertexFreeze(
        unsigned int iQuadIndex,    
        unsigned int iCornerIndex   
        ) const { return VertexFreeze( QuadIndex( iQuadIndex, iCornerIndex ) ); };

    inline const tnormal *TriangleVertexNormalArray(
        unsigned int iTriangleIndex,    
        unsigned int iCornerIndex       
        ) const { return VertexNormalArray( TriangleIndex( iTriangleIndex, iCornerIndex ) ); };

    inline const tnormal *QuadVertexNormalArray(
        unsigned int iQuadIndex,    
        unsigned int iCornerIndex   
        ) const { return VertexNormalArray( QuadIndex( iQuadIndex, iCornerIndex ) ); };

    inline tnormalv TriangleVertexNormalValue(
        unsigned int iTriangleIndex,    
        unsigned int iCornerIndex       
        ) const { return VertexNormalValue( TriangleIndex( iTriangleIndex, iCornerIndex ) ); };

    inline tnormalv QuadVertexNormalValue(
        unsigned int iQuadIndex,    
        unsigned int iCornerIndex   
        ) const { return VertexNormalValue( QuadIndex( iQuadIndex, iCornerIndex ) ); };

    virtual void EnumerateFaces(
        unsigned int iFaceIndex,        
        FaceEnumerator *pEnumerator,    
        bool bSymmetry = false          
        );

    virtual void EnumerateNearestFaces(
        unsigned int iFaceIndex,        
        FaceEnumerator *pOperation      
        );

    virtual void EnumerateNeighboringFaces(
        unsigned int iFaceIndex,
        FaceEnumerator *pOperation
        );
    
    virtual void EnumerateFaces(
        FaceEnumerator* pEnumerator,            
        SpatialGrid* pGrid,                     
        const AxisAlignedBoundingBox& cVolume   
        );

    virtual void EnumerateVertices(
        unsigned int iFaceIndex,        
        VertexEnumerator *pEnumerator   
        );

    unsigned int EnumerateAdjacentVertices(
        AdjacentVertexEnumerator *pEnumerator,  
        unsigned int iVertexIndex,              
        unsigned int iFaceIndex                 
        );
    
    virtual void EnumerateVertices(
        VertexEnumerator* pEnumerator,          
        SpatialGrid* pGrid,                     
        const AxisAlignedBoundingBox& cVolume   
        );
    
    virtual int MeshVersion( void ) const;

    virtual void SmoothTextureCoordinates( float fStrength);

    virtual void RecalculateNormals(
        bool bKeep = false  
        );

    virtual bool RecalculateAdjacency( 
        bool bForce = true,         
        bool bCheckTShapes = true   
        );


    unsigned int CollectionID( void ) const { return m_iCollectionID; };   // this *must* be inline for performance on large meshes.

    // Obsolete method; do not use.
    void SetCollectionID(unsigned int id)   { m_iCollectionID = id;   };   // this *must* be inline for performance on large meshes.  

    void IncreaseCollectionID( void )       { ++m_iCollectionID;      };   // this *must* be inline for performance on large meshes.  


    virtual bool IsSelected( void );

    virtual void SetSelected( bool bOn = true, bool bMerge = false );

    virtual class LayerMeshData *AddLayer( Layer * pLayer = NULL );

    virtual void RemoveLayer( 
        LayerMeshData* pLayer 
        );

    virtual class LayerMeshData *ActiveLayer( void ) const;

    aptr<LayerMeshData> ActiveSculptLayer;

    virtual bool IsActiveLevel( void ) const;

    virtual bool Lock( 
        class MeshUnlocker *pUnlocker = NULL 
        );

    virtual bool Unlock( void );

    virtual bool IsLocked( void );

    virtual class MeshChange *StartChange( void );

    virtual void EndChange( bool bUndo = true, bool bMerge = false);

    virtual bool IsNSided( void ) const;
    virtual GenericFace &Face( unsigned int iIndex );
    virtual unsigned int GenericFaceCount( void );
    virtual void ClearGenericFaces();

    virtual bool HasExpandedTCs( void ) const;
    virtual void CreateExpandedTCs( void );
    virtual TC &ExpandedTC( unsigned int index );
    virtual bool SupportsTangentMirror() const;
    virtual unsigned int TangentMirroredFaceIndex( unsigned int iFaceIndex ) const;
    virtual unsigned int TangentMirroredVertexIndex( unsigned int iFaceIndex,
        unsigned int iCornerIndex, 
        unsigned int &iOppositeFaceIndex, 
        unsigned int &iOppositeCornerIndex) const;

    Store<TC> m_pTCs;

    aevent Modified;
    aevent TopologyChange;

    virtual bool InitializeTopologicalSymmetry( unsigned int iFaceIndex0, unsigned int iFaceIndex1, bool bSelectWhenFailed = true );
    virtual bool IsTopologicalSymmetryInitialized( unsigned int &iFaceIndex0, unsigned int &iFaceIndex1 ) const;
    virtual void RecalculateTopologicalSymmetry( void );
    virtual SurfacePoint MirrorSurfacePoint( const SurfacePoint &cPoint );
    virtual int TopologicalSide( unsigned int iFaceIndex );
    
    virtual unsigned int PrimaryCount(bool bNeedToUseTC);
    virtual unsigned int QuadPrimaryIndex(bool bNeedToUseTC, unsigned int iFaceIndex, unsigned int iCornerIndex);
    virtual unsigned int TrianglePrimaryIndex(bool bNeedToUseTC, unsigned int iFaceIndex, unsigned int iCornerIndex);
    
    virtual bool RecalculateVertexAdjacency( 
        bool bForce = true 
        );

    inline void SetVertexAdjacency( 
        unsigned int iVertexIndex,      
        unsigned int iFaceIndex,        
        unsigned int iCornerIndex       
        ) 
    { 
        m_aVertexAdjacency[iVertexIndex] = mudbox::VertexAdjacency( iFaceIndex, iCornerIndex );
    };

    inline struct mudbox::VertexAdjacency VertexAdjacency( unsigned int iVertexIndex ) const { return m_aVertexAdjacency[iVertexIndex]; }

    virtual void Transform( const Matrix &mMatrix );

    virtual void CheckValidity( DiagnosticLevel iLevel = dgnLevel2 ) const;

protected:
    unsigned int                    m_iVertexCount;
    mutable unsigned int            m_iCollectionID;
    Store<Vertex>                   m_pVertices;
    Store<Normal>                   m_pVertexNormals;
    Store<mudbox::VertexAdjacency>  m_aVertexAdjacency;
    bool                            m_bHasVertexAdjacency;
    bool                            m_bBuildVertexAdjacency;

    unsigned int            m_iRestoreCount;   // referenced and modified by the MeshChange class
    Store<StoredVertexInfo> m_aRestoreBuffer;  // referenced and modified by the MeshChange class 

public:
    unsigned int             GetRestoreCount() const { return m_iRestoreCount; }           

    const StoredVertexInfo  & GetRestoreVertexInfo(unsigned int i) const { return m_aRestoreBuffer[i]; } 

    // The following two are only used for creating a MeshChange object. They give
    // write access to the restore buffer and count. Do not use them anywhere else.

    unsigned int            & GetRestoreCountRef()  { return m_iRestoreCount;  }           
    Store<StoredVertexInfo> & GetRestoreBufferRef() { return m_aRestoreBuffer; }
    
protected:
    mutable SpatialGrid*                    m_pGrid;

public:
    SpatialGrid* Grid();
};


class MBDLL_DECL MeshFreezer : public Node
{
    DECLARE_CLASS;
public:
    virtual void Freeze( Mesh *pMesh, Store<float> aFreezeData, bool bMerge = false );
};

class MBDLL_DECL MeshSelector : public Node
{
    DECLARE_CLASS;
public:
    virtual void Select( Mesh *pMesh, bool bState, const Store<unsigned int> &aSelectionData, bool bMerge = false );
};

class MBDLL_DECL TangentGenerator : public TreeNode
{
    DECLARE_CLASS;
public:
    virtual Vector ConvertToTangent(
        unsigned int iVertexIndex,  
        const Vector &vVector       
        ) const;
    
    virtual Vector ConvertToObject(
        unsigned int iVertexIndex,  
        const Vector &vVector       
        ) const;
        
    virtual Base LocalBase(
        unsigned int iFaceIndex,    
        unsigned int iCornerIndex   
        );
    
    virtual void SetNormalization(
        bool bNormalize     
        );
};


class MBDLL_DECL Picker : public TreeNode
{
    DECLARE_CLASS;

public:
    virtual void SetMesh(
        Mesh *m_pMesh       
        );
    
    virtual void SetTolerance( 
        float fTolerance    
        );

    virtual bool Pick(
        const Vector &vLocalStart,  
        const Vector &vLocalEnd,    
        bool bBothSides,            
        SurfacePoint &cResult,      
        float fTarget = 0.5f        
        );
};

class MBDLL_DECL ScreenSpacePicker : public TreeNode
{
    DECLARE_CLASS;

public:
    virtual void SetFramebufferSize(
        unsigned int iWidth,    
        unsigned int iHeight    
        );
    
    virtual bool Pick(
        const class Camera *pCamera,        
        float fXPosition,                   
        float fYPosition,                   
        SurfacePoint &sResult,              
        bool bForceRedrawBuffer = false 
        );
};

class MBDLL_DECL MeshGrid : public TreeNode
{
    DECLARE_CLASS;

public:
    virtual unsigned int MeshGridCount( void ) const;
    
    virtual unsigned int MeshGridLevel( 
        unsigned int iMeshGridIndex 
        ) const;
    
    virtual unsigned int MeshGridFaceIndex( 
        unsigned int iMeshGridIndex, 
        unsigned int iX,            
        unsigned int iY         
        ) const;
    
    virtual unsigned int MeshGridVertexIndex( 
        unsigned int iMeshGridIndex, 
        unsigned int iX,            
        unsigned int iY         
        ) const;
    
    virtual unsigned int MeshGridTCIndex( 
        unsigned int iMeshGridIndex, 
        unsigned int iX,            
        unsigned int iY         
        ) const;
    
    virtual unsigned int MeshGridIndexByFaceIndex( 
        unsigned int iFaceIndex     
        ) const;
};

class MBDLL_DECL SpatialGrid : public TreeNode
{
    DECLARE_CLASS;

public:
    struct MBDLL_DECL Coord
    {
        Coord() { a[0] = a[1] = a[2] = 0; }
        Coord( unsigned int x, unsigned int y, unsigned int z )
        {
            a[0] = x; a[1] = y; a[2] = z;
        }

        unsigned int& operator[](unsigned int i) { return a[i]; };
        unsigned int operator[](unsigned int i) const { return a[i]; };
        
        bool operator==(const Coord& other)
        {   
            return a[0] == other.a[0] && a[1] == other.a[1] && a[2] == other.a[2];
        }

        unsigned int a[3];      
    };

    class MBDLL_DECL VoxelIterator
    {
    public:
        VoxelIterator( const ExtendableStore<unsigned int>& data ): fData(data), fIndex(0)
        {
            if( fData.ItemCount() > 0 && fData[fIndex] == INVALID_ID )
                next();
        }

        void next() { while( ++fIndex < fData.ItemCount() && fData[fIndex] == INVALID_ID ); }
        bool isDone() const { return fIndex >= fData.ItemCount(); }
        unsigned int value() const { return fData[fIndex]; }

    private:
        unsigned int                            fIndex;
        const ExtendableStore<unsigned int>&    fData;
    };

    static Coord computeDimensions( const mudbox::Mesh* mesh,       
                                       unsigned int facesPerVoxel,  
                                       const Coord& minVoxels,      
                                       const Coord& maxVoxels);     

    virtual void initialize( mudbox::Mesh* mesh,                    
                            const AxisAlignedBoundingBox& bounds,   
                            const Coord& gridDimensions );          
    
    virtual AxisAlignedBoundingBox  gridBounds() const;
    
    virtual void voxelRange( const AxisAlignedBoundingBox& cBox,    
                            Coord& cMinCoords,                      
                            Coord& cMaxCoords                       
                            ) const; 
    
    virtual VoxelIterator voxelIterator( const Coord& cCoord );     

    virtual void setDirty( const AxisAlignedBoundingBox& cBox );    

    virtual void update(); 
    
    virtual void extend();

    virtual bool closestPoint( mudbox::SurfacePoint &surfacePt,     
                            mudbox::Mesh *pMesh,                    
                            const mudbox::Vector& vPoint,           
                            const mudbox::Vector& vDirection,       
                            bool bothDirections = false );          
}; 

class MBDLL_DECL SurfaceSmoother : public TreeNode
{
    DECLARE_CLASS;

public:
    virtual Vector SmoothPosition( 
        unsigned int iFaceIndex, 
        double fUCoordinate, 
        double fVCoordinate, 
        bool bConsiderCrease = true, 
        bool bConsiderHarden = true  
        ) const;
    
    virtual Vector SmoothNormal( 
        unsigned int iFaceIndex, 
        double fUCoordinate, 
        double fVCoordinate, 
        bool bConsiderCrease = true, 
        bool bConsiderHarden = true  
        ) const;
    
    virtual Vector SmoothTextureCoordinate( 
        unsigned int iFaceIndex, 
        double fUCoordinate, 
        double fVCoordinate 
        ) const;

    virtual Base SmoothTangent( 
        unsigned int iFaceIndex, 
        double fUCoordinate, 
        double fVCoordinate, 
        bool bConsiderCrease = true, 
        bool bConsiderHarden = true  
        ) const;
};

class MBDLL_DECL MeshChange : public Node
{
    MeshChange( Mesh *m_pMesh );

public:
    typedef StoredVertexInfo VertexChange;
    
    inline float Data(
        unsigned int iVertexIndex 
        ) const
    {
        Vertex &v = m_pMesh->VertexData( iVertexIndex );
        if ( v.m_iStrokeID < m_iVertexCount && m_pArray[v.m_iStrokeID].m_iVertexIndex == iVertexIndex )
            return m_pArray[v.m_iStrokeID].m_fData;
        else
            return 0.0f;
    };

    inline const Vector &OriginalPosition( 
        unsigned int iVertexIndex 
        ) const
    {
        Vertex &v = m_pMesh->VertexData( iVertexIndex );
        if ( v.m_iStrokeID < m_iVertexCount && m_pArray[v.m_iStrokeID].m_iVertexIndex == iVertexIndex )
            return m_pArray[v.m_iStrokeID].m_vPosition;
        else
            return v.m_vPos;
    };
    
    __forceinline Vector OriginalNormal( 
        unsigned int iVertexIndex 
        ) const __attribute__((always_inline))
    {
        Vertex &v = m_pMesh->VertexData( iVertexIndex );
        if ( v.m_iStrokeID < m_iVertexCount && m_pArray[v.m_iStrokeID].m_iVertexIndex == iVertexIndex )
            return m_pArray[v.m_iStrokeID].m_vNormal;
        else
            //return v.m_vNormal;
            return m_pMesh->VertexNormal(iVertexIndex);
    };
    

    // this function is not being inlined as it is too big, si it is split into a small inlined part,
    // and the larger not inlined part...
    private:
    VertexChange &Add_uncached(     // see arg list of Add just below....
        unsigned int  iVertexIndex, 
        unsigned int  iFaceIndex,
        Vertex       &v, 
        bool          bPrecalculateLayerIndex = false,
        float         fDataInitialValue = 0.0f  );

    public:
    __forceinline VertexChange &Add( 
        unsigned int iVertexIndex, 
        unsigned int iFaceIndex,   
        bool bPrecalculateLayerIndex = false, 
        float fDataInitialValue = 0.0f 
        ) __attribute__((always_inline))
    {
        Vertex &v = m_pMesh->VertexData( iVertexIndex );
        if ( v.m_iStrokeID < m_iVertexCount && 
             m_pArray[v.m_iStrokeID].m_iVertexIndex == iVertexIndex )
            return m_pArray[v.m_iStrokeID]; // 80% of the time it hits this...
        else {
            return Add_uncached(iVertexIndex, iFaceIndex, v, bPrecalculateLayerIndex, fDataInitialValue );
        }
    };

    void Finish( 
        bool bUndo = true,  
        bool bMerge = false 
        );

private:
    Mesh *m_pMesh;

    Store<VertexChange> &m_pArray;        // these reference the count and RestoreArray in the Mesh class
    unsigned int        &m_iVertexCount;

    friend class Mesh;
    friend class ::XMesh;
};

//-----------------------------------------------------------------------------
class MBDLL_DECL MeshUnlocker
{
public:
    virtual bool Unlock( 
        Mesh *pMesh 
        );
};




//-----------------------------------------------------------------------------

class MBDLL_DECL MeshPartitioning : public TreeNode
{
DECLARE_CLASS;

public:
    enum QualityHint {
        eNone = 0,     //<-- mesh has not partitioning computed yet.
        eFastest,      //<-- order n partitioning -- may not be spatially coherent.  
        eGood,         //<-- no worse than order n log n. Mostly spatially coherent. default
        eBest          //<-- slower than eGood, but better coherence
    };

private:

    // Partition represents an individual partition in the mesh partitioning.
    class Partition 
    {
        friend class MeshPartitioning;
        private:
            Store<unsigned int>     m_aFaceIDs;      // list of face ids in this partition
            Store<unsigned int>     m_aInvalidIDs;   // LIFO indexes of invalid IDs within the FaceID list
            AxisAlignedBoundingBox  m_AABB;          // bounding box of this partition - only valid in point mode.
            unsigned int            m_MinFaceID;
            unsigned int            m_MaxFaceID;                                         
            unsigned int            m_BlindInt;      // Blind data
            bool                    m_bDirty;        // is this partition dirty since last used by the renderer.
            unsigned int            m_iVersion;

            // Adds a face to this partition. Does not check if it is already in the partition,
            // that would create an invalid partitioning, so don't do it.
            // returns the index in the partition of the specified face.
            // does not update the bounding box.
            unsigned int AddFace(unsigned int faceID);

            // Delete the face at the specified index within this partition.
            // does not update the bounding box.
            void         DelFace(unsigned int index) 
            { 
                if (index < m_aFaceIDs.ItemCount() && m_aFaceIDs[index] != INVALID_ID) {
                    m_aFaceIDs[index] = INVALID_ID;
                    m_aInvalidIDs.Add(index);
                    m_bDirty = true;
                }
            }

            // returns true if any changes were made.....
            bool Consolidate(bool force);

        public:
            Partition() : m_aFaceIDs("Mesh Partition Faces"),
                          m_aInvalidIDs("Mesh Partition Unused Entries"),
                          m_MinFaceID(0xFFFFFFFF),
                          m_MaxFaceID(0),
                          m_BlindInt(0),
                          m_iVersion(0),
                          m_bDirty(false) { m_AABB.Reset(); }

            ~Partition() { Clear(); }

            void Clear() 
            { m_aFaceIDs.Clear(); m_aInvalidIDs.Clear(); 
              m_MinFaceID = 0xffffffff; m_MaxFaceID = m_BlindInt = 0; 
              m_bDirty = false; m_AABB.Reset(); m_iVersion = 0; }

            void Serialize( Stream &s )
            {
                Consolidate(true);
                m_aFaceIDs.Serialize(s);
                m_aInvalidIDs.Serialize(s);
                m_AABB.Serialize(s);
                s == m_MinFaceID;
                s == m_MaxFaceID;
                s == m_BlindInt;
                s == m_bDirty;
            }

            Partition(const Partition &p) : m_aFaceIDs(p.m_aFaceIDs), 
                                            m_aInvalidIDs(p.m_aInvalidIDs),
                                            m_AABB(p.m_AABB),
                                            m_BlindInt(p.m_BlindInt),
                                            m_bDirty(p.m_bDirty) {}

            Partition & operator = (const Partition &p) {
                m_aFaceIDs     = p.m_aFaceIDs;            
                m_aInvalidIDs  = p.m_aInvalidIDs;      
                m_AABB         = p.m_AABB;
                m_MinFaceID    = p.m_MinFaceID;
                m_MaxFaceID    = p.m_MaxFaceID;
                m_BlindInt     = p.m_BlindInt;            
                m_bDirty       = p.m_bDirty;
                return *this;              
            }

            const AxisAlignedBoundingBox &getBoundingBox() const { return m_AABB; }
    };

    class InverseMapping {
        public:
        unsigned int m_iPartition;  // the partition this face belongs to
        unsigned int m_iIndex;      // and it's index in that partition.

        InverseMapping() : m_iPartition(INVALID_ID), m_iIndex(INVALID_ID) {}
        InverseMapping(const InverseMapping &m) : m_iPartition(m.m_iPartition), m_iIndex(m.m_iIndex) {}

        InverseMapping & operator = (const InverseMapping &m) 
            { m_iPartition = m.m_iPartition; m_iIndex = m.m_iIndex; return *this; }

        void Serialize( Stream &s )
        {
            s == m_iPartition;
            s == m_iIndex;
        }
    };

    // regenerate the inverse mapping for all partitions
    void RegenInverseMapping();

    // regen the inverse mapping for one partition
    void RegenInverseMapping(int Part);

    void SetPartitionCount(unsigned int count);

    // merge two partitions, leaving src partition empty.
    void MergePartitions(unsigned int src, unsigned int target);

    // splits a partition into 2 roughly equal (in face count) partitions
    void SplitPartition(unsigned int part);

    // tries to even out the size (face count) of the partitions somewhat
    void RebalancePartitions(QualityHint hint);


    Store<Partition>        m_aPartitions;               // indexed by partition ID
    Store<InverseMapping>   m_aFaces;                    // indexed by faceID.
    AxisAlignedBoundingBox  m_TotalAABB;                 // bounding box of this partitioning.
                                                        
    QualityHint             m_eCurrentPartitionQuality;  // quality of this partitioning
    bool                    m_UseFaces;
                                                        
    static QualityHint      m_sDefaultQuality;           // used when linked to its parent node
    static unsigned int     m_sPreferredPartitionCount;  // used when computing a partitioning. Default is 2048.
    static unsigned int     m_sMaxPartitionSize;         // Partitions will not exceed this size. Default 64K - 1. 
    static bool             m_sBaseMesh;                 // go to the base level before partitioning. Default is true.
    static bool             m_sUseFaces;                 // Use the face centers, or partition vertices...

public:

    static void SetBaseMeshMode(bool b = true) { m_sBaseMesh = b;    }
    static bool IsInBaseMeshMode()             { return m_sBaseMesh; }


    static void SetFaceMode(bool b = true)     { m_sUseFaces = b;    }
    static bool IsInFaceMode()                 { return m_sUseFaces; }

    bool IsCurrentPartitioningFaceBased() const { return m_UseFaces; }

    static void         SetDefaultQuality(QualityHint hint) { m_sDefaultQuality = hint; }

    static QualityHint  GetDefaultQuality()                 { return m_sDefaultQuality; }

    static unsigned int GetDefaultPartitionCount()          { return m_sPreferredPartitionCount; }

    static void         SetDefaultPartitionCount(unsigned int pc) { m_sPreferredPartitionCount = pc; }


    MeshPartitioning();

    ~MeshPartitioning() { Clear(); }

    void Clear();

    virtual void OnLinked(const TreeNode *pOldParent);

    void RePartition(QualityHint hint = eGood);

    void RecomputePartitionAABB(unsigned int pIdx);

    void RecomputePartitionAABBs(void);

    const AxisAlignedBoundingBox &GetTotalAABB() const { return m_TotalAABB; }

    const AxisAlignedBoundingBox &GetPartitionAABB(unsigned int pIdx) const
        { return m_aPartitions[pIdx].m_AABB; }

    unsigned int GetPartitionMinFaceID(unsigned int pIdx) const
    { return m_aPartitions[pIdx].m_MinFaceID; }

    unsigned int GetPartitionMaxFaceID(unsigned int pIdx) const
    { return m_aPartitions[pIdx].m_MaxFaceID; }

    bool IsPartitionCloseToPoint(unsigned int pIdx, const Vector &pt, float dist) const
    {
        if (dist > 0) {
            AxisAlignedBoundingBox bBox = m_aPartitions[pIdx].m_AABB;
            bBox.ExpandBy(dist);
            return bBox.IsContaining(pt);
        } else {
            return m_aPartitions[pIdx].m_AABB.IsContaining(pt);
        }
    }

    QualityHint GetCurrentPartitioningQuality() const { return m_eCurrentPartitionQuality; }

    void Consolidate(bool force);

    void Serialize( Stream &s );

    bool IsPartitionDirty(unsigned int pIdx) const { return m_aPartitions[pIdx].m_bDirty;  } 

    void SetPartitionDirty(unsigned int pIdx)      { m_aPartitions[pIdx].m_bDirty = true; }

    bool AnyPartitionsDirty() 
    {
        bool b = false;
        for (unsigned int i = 0; i < m_aPartitions.ItemCount(); ++i) 
            b |= m_aPartitions[i].m_bDirty;
        return b;
    }

    void ContentChanged( void )
    {
        for (unsigned int i = 0; i < m_aPartitions.ItemCount(); ++i) 
            if( m_aPartitions[i].m_bDirty ) 
            {
                m_aPartitions[i].m_bDirty = false;
                m_aPartitions[i].m_iVersion++;
            }

        TreeNode::ContentChanged();
    }

    void SetFaceCount(unsigned int faceCount, bool noOvergrowth = false);

    unsigned int GetFaceCount() const { return m_aFaces.ItemCount(); }

    unsigned int GetPartitionCount() const { return m_aPartitions.ItemCount(); }

    unsigned int GetPartitionFaceCount(unsigned int pIdx) const 
        { return m_aPartitions[pIdx].m_aFaceIDs.ItemCount(); }

    unsigned int GetPartitionFace(unsigned int pIdx, unsigned int fIdx) const
        { return m_aPartitions[pIdx].m_aFaceIDs[fIdx]; }

    unsigned int GetPartitionBlindInt(unsigned int pIdx) const 
        { return m_aPartitions[pIdx].m_BlindInt; }

    void         SetPartitionBlindInt(unsigned int pIdx, unsigned int ii) 
        { m_aPartitions[pIdx].m_BlindInt = ii; }

    unsigned int GetPartitionVersion( unsigned int pIdx ) const
        { return m_aPartitions[pIdx].m_iVersion; }

    unsigned int GetFacePartition(unsigned int faceID) const
        { return faceID < m_aFaces.ItemCount() ? m_aFaces[faceID].m_iPartition : INVALID_ID; }

    unsigned int GetFacePartitionIndex(unsigned int faceID) const 
        { return faceID < m_aFaces.ItemCount() ? m_aFaces[faceID].m_iIndex : INVALID_ID; }

    void AddFaceToPartition(unsigned int faceID, unsigned int partitionID);

    unsigned int GetPartitionID(unsigned int faceID) const 
        { return (faceID < GetFaceCount()) ? m_aFaces[faceID].m_iPartition : INVALID_ID; }

    void DebugLog();

    void SetBlindIntsAsColors();

    virtual void CheckValidity( Node::DiagnosticLevel iLevel  = dgnLevel2 ) const;
};


}; // end of namespace mudbox