UVMeshGrid.h

Go to the documentation of this file.

#ifndef __UV_MESH_GRID_H 
#define __UV_MESH_GRID_H 

#if defined(JAMBUILD)
#include <Mudbox/mudbox.h>
#else
#include "../../include/Mudbox/mudbox.h"
#endif

using namespace mudbox;

struct Quad
{
    Quad() :
        m_pMesh(0),
        m_iFaceIndex(0xffffffff),
        m_iSide(0xffffffff)
    {
    };

    Quad( const Mesh *pMesh, unsigned int iFaceIndex, int iSide = 0 )
    {
        m_pMesh = pMesh;
        m_iFaceIndex = iFaceIndex;
        m_iSide = iSide;
    };

    // 0 - current side
    // 1 - left
    // 2 - opposite
    // 3 - right
    // 
    bool Step( int iDirection = 0 )
    {
        unsigned int a = m_pMesh->QuadAdjacency( m_iFaceIndex, (m_iSide+iDirection)%4 );
        if ( a == 0xffffffff )
            return false;
        m_iFaceIndex = a/4;
        m_iSide = (a%4+2-iDirection)%4;
        return true;
    };
    unsigned int Corner( int iIndex ) const
    {
        return m_pMesh->QuadIndex( m_iFaceIndex, (m_iSide+iIndex)%4 );
    };
    unsigned int CornerTCI( int iIndex )
    {
        return m_pMesh->QuadTCI( m_iFaceIndex, (m_iSide+iIndex)%4 );
    };
    Vector CornerPosition( int iIndex ) const
    {
        return m_pMesh->QuadVertexPosition( m_iFaceIndex, (m_iSide+iIndex)%4 );
    };
    Vector Center( void ) const
    {
        return (CornerPosition(0)+CornerPosition(1)+CornerPosition(2)+CornerPosition(3))*0.25f;
    };
    void TurnRight( void )
    {
        m_iSide = (m_iSide+3)%4;
    };
    void TurnLeft( void )
    {
        m_iSide = (m_iSide+1)%4;
    };
    Quad& operator=( const Quad& pOther )
    {
        m_pMesh = pOther.m_pMesh;
        m_iFaceIndex = pOther.m_iFaceIndex;
        m_iSide = pOther.m_iSide;
        return *this;
    };

    const Mesh *m_pMesh;
    unsigned int m_iFaceIndex;
    int m_iSide;
};

// this is similar to the MudboxMeshGrid, 
// but different in the following ways:
// 1. dimensions of the grid do not need to be POT
// 2. grids do not need to be square
// 3. all grids do not need to be the same dimensions
// 4. vertex/faceIDs are not reordered.
// 5. works on non-quad meshes (but only quads are grouped together) 
// 6. this one probably takes more memory, not to be used on dense meshes.
class UVMeshGrid : public Node
{
    DECLARE_CLASS;

    struct GridData
    {
        QVector< unsigned int > m_iFaces;

        // TODO: only need 2 bits per face, since there are only 4 possible values.
        // the other 6 bits are wasted :(
        QVector< char > m_iOrientations;

        unsigned int m_iWidth;
        unsigned int m_iHeight;
    };

    struct Solution
    {
        QVector< GridData* > m_aGrids;
        float m_fFitness;
        ~Solution()
        {
            for( int i = 0; i < m_aGrids.size(); ++i )
                MB_SDN( m_aGrids[i] );
        };
    };

    UVMeshGrid();
    ~UVMeshGrid();

    void SetMaxGridDimension( unsigned int iMax ) { m_iMaxDimension = iMax; }
    void MeshGridDimensions( unsigned int iGrid, unsigned int& iWidth, unsigned int& iHeight ) const;
    unsigned int MeshGridCount( void ) const { return m_pSolution ? m_pSolution->m_aGrids.size() : 0; }
    unsigned int MeshGridFaceIndex( unsigned int iGrid, unsigned int iX, unsigned int iY ) const;

    // returns the bottom-left corner of the face, relative to the bottom-left corner of the grid.
    unsigned int MeshGridFaceOrientation( unsigned int iGrid, unsigned int iX, unsigned int iY ) const;

    unsigned int MeshGridBleed( unsigned int iGrid, unsigned int iDefaultBleed ) const;

    // returns the centerpoint of the grid, in local space
    Vector MeshGridCenter( unsigned int iGrid ) const;

    void SetMesh( Mesh* pMesh );

    // Clear the data.
    void Clear( void );
private:
    aptr<Mesh> m_pMesh;
    aptr<Mesh> m_pQuadMesh;
    unsigned int m_iMaxDimension;
    Solution* m_pSolution;

    
    Solution* FindGrids( int iGridSize, Quad cCorner );
    float ComputeFitness( const Solution* pSolution );
    Quad FindEV( const Mesh* pMesh ) const;
    Mesh *QuadMesh( Mesh *pSource );
    unsigned int QuadMeshIndex( unsigned int iQuadFaceIndex );
    const Vector& QuadVertexPosition( unsigned int iTriangleIndex, unsigned int iMeshCorner, unsigned int iFaceOrientation ) const;
    void AddNonQuadFaces();


    QVector<unsigned int > m_aQuadMap;
};

#endif