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

namespace mudbox {

#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



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))/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))/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 { 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 ) { 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;
    };
};

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;  

};


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 
        );
    
    inline bool HasTC( void ) const { return (FaceComponents() & fcTCIndex) != 0 && TCCount() > 0; };

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

    virtual void MarkVertex(
        unsigned int iVertexIndex   
        );
        
    virtual bool IsVertexMarked(
        unsigned int iVertexIndex   
        );
    
    virtual void ClearVertexMarks( void );

    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 EnumerateVertices(
        unsigned int iFaceIndex,        
        VertexEnumerator *pEnumerator   
        );

    unsigned int EnumerateAdjacentVertices(
        AdjacentVertexEnumerator *pEnumerator,  
        unsigned int iVertexIndex,              
        unsigned int iFaceIndex                 
        );

    virtual int MeshVersion( void ) const;

    virtual void SmoothTextureCoordinates( float fStrength);

    virtual void RecalculateNormals(
        bool bKeep = false  
        );

    virtual void RecalculateAdjacency( 
        bool bForce = true  
        );

    virtual unsigned int CollectionID( void ) const;

    virtual void IncreaseCollectionID( void );

    virtual bool IsSelected( void );

    virtual void SetSelected( bool bOn = true );

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

    class MeshChange *StartChange( void );

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

    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;

    virtual bool InitializeTopologicalSymmetry( unsigned int iFaceIndex0, unsigned int iFaceIndex1 );
    virtual bool IsTopologicalSymmetryInitialized( unsigned int &iFaceIndex0, unsigned int &iFaceIndex1 ) const;
    virtual void RecalculateTopologicalSymmetry( void );
    
    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 void Transform( const Matrix &mMatrix );

    virtual void CheckValidity( DiagnosticLevel iLevel = dgnLevel2 ) const;

protected:
    Store<Vertex> m_pVertices;
    unsigned int m_iVertexCount;
    Store<Normal> m_pVertexNormals;
};

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



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

    SurfacePoint( void );
    
    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 ); 

    mutable Vector m_vFaceCoordinates;
};

class MBDLL_DECL Picker : public TreeNode
{
    DECLARE_CLASS;

public:
    virtual void SetMesh(
        Mesh *m_pMesh       
        );
    
    virtual bool Pick(
        const Vector &vLocalStart,  
        const Vector &vLocalEnd,    
        bool bBothSides,            
        SurfacePoint &cResult,      
        float fTarget = 0.5f        
        );
};

class MBDLL_DECL ScreenSpacePicker : public Node
{
    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           
        );
};

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

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

public:
    struct VertexChange
    {
        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;
    };
    
    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;
    };
    
    inline Vector OriginalNormal( 
        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_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 );

    public:
    inline VertexChange &Add( 
        unsigned int iVertexIndex, 
        unsigned int iFaceIndex,   
        bool bPrecalculateLayerIndex = false 

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

    void Finish( 
        bool bUndo = true,  

        bool bMerge = false 
        );

private:
    Mesh *m_pMesh;

    Store<VertexChange> &m_pArray;
    unsigned int &m_iVertexCount;

    friend class Mesh;
};

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

}; // end of namespace mudbox