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_iNormal = 0; };



    // data

    Vector m_vPos;

    mutable unsigned int m_iStrokeID;

    union

    { 

        tnormal m_vNormal[4];

        int m_iNormalIndex;

        tnormalv m_iNormal;

    };









    inline float Freeze( void ) const 

        { return ((float)(unsigned char)(m_vNormal[3]&0x7f))/0x7f; };

    







    inline void SetFreeze( float fFreeze ) 

        { m_vNormal[3] = (m_vNormal[3]&0xff80)+(unsigned int)(0x7f*fFreeze); };

    



    inline float Mask( void ) const 

        { return ((float)(unsigned char)(m_vNormal[3]>>8))/0xff; };

    



    inline void SetMask( float fMask ) 

        { m_vNormal[3] = (m_vNormal[3]&0xff)+(((unsigned int)(0xff*fMask))<<8); };

    


    inline bool IsSelected( void ) const { return (m_vNormal[3]&0x80) != 0; };

    


    inline void SetSelected( bool bSelected ) 

        { m_vNormal[3] = (m_vNormal[3]&0xff7f)+bSelected*0x80; };

};












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( Mesh *pDestination ) 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_pVertices[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_pVertices[iVertexIndex].m_vNormal; };

    



    inline tnormalv VertexNormalValue(

        unsigned int iVertexIndex   

        ) const { return m_pVertices[iVertexIndex].m_iNormal; };

    

    // Do not use.  This obsolete method will be removed.

    inline unsigned int VertexNormalIndex( unsigned int iVertexIndex ) const 

        { return m_pVertices[iVertexIndex].m_iNormalIndex; };

    


    virtual AxisAlignedBoundingBox BoundingBox( void ) 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_pVertices[iVertexIndex].m_vNormal[0] = tnormal(pNormal[3]);

        m_pVertices[iVertexIndex].m_vNormal[1] = tnormal(pNormal[2]);

        m_pVertices[iVertexIndex].m_vNormal[2] = tnormal(pNormal[1]);

    };

    


    inline void SetVertexNormal(

        unsigned int iVertexIndex,  

        const Vector &vNormal       

        )

        {

            m_pVertices[iVertexIndex].m_vNormal[0] = tnormal(vNormal.x * MB_NORMALMAX);

            m_pVertices[iVertexIndex].m_vNormal[1] = tnormal(vNormal.y * MB_NORMALMAX);

            m_pVertices[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 SetVertexNormal( unsigned int iVertexIndex, int iNormal )

        { m_pVertices[iVertexIndex].m_iNormalIndex = iNormal; };

    


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





    virtual void RemoveLayer( 

        LayerMeshData* pLayer 

        );




    virtual class LayerMeshData *ActiveLayer( void ) const;




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





    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;



    Store<TC> m_pTCs;




    aevent Modified;



protected:

    Store<Vertex> m_pVertices;

    unsigned int m_iVertexCount;

};




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   

                             );



    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 

        ) const;

    


    virtual Vector SmoothNormal( 

        unsigned int iFaceIndex, 

        double fUCoordinate, 

        double fVCoordinate 

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

    };

    



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