simplemesh.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/

#ifndef SIMPLEMESH_INCLUDED
#define SIMPLEMESH_INCLUDED

#include "../grinliz/gldebug.h"
#include "../grinliz/glvector.h"
#include "../grinliz/glcontainer.h"

#include "lilith3dgl.h"

#include <vector>

namespace lilith3d {

class Texture;
class Tri;

class SimpleMesh
{
public:

        SimpleMesh( const Texture* tex, bool smooth ) : 
                texture( tex ), 
                smoothing( smooth ),
                nIndex( 0 ),
                nTri( 0 ), 
                nVertex( 0 ),
                vbo( 0 ),
                flatVertexSet( 0 ), smoothVertexSet( 0 ), triAtVertex( 0 ),
            index( 0 ),  tri( 0 ), vertex( 0 ) 
        {}

        ~SimpleMesh();

        const Texture* GetTexture() const { return texture; }

        const U16* PIndex() const                                       { return index; }
        const Tri* PTri() const                                         { return tri; }
        const Vertex* PVertex() const                           { return vertex; }

        const Vertex& GetVertex( unsigned i ) const     {       GLASSERT( i>=0 && i<nVertex );
                                                                                                                                return vertex[i]; }
        const Tri& GetTri( unsigned i ) const;
                

        U32 NIndex() const              {       GLASSERT( nIndex % 3 == 0 );
                                                                GLASSERT( nIndex / 3 == nTri );
                                                                return nIndex; }
        U32 NTri() const                {       GLASSERT( nIndex % 3 == 0 );
                                                                GLASSERT( nIndex / 3 == nTri );
                                                                return nTri; }
        U32     NVertex() const         {       return nVertex; }

        const std::vector< int >& TriAtVertex( int vIndex ) const 
        {
                GLASSERT( vIndex >= 0 && vIndex < (int)nVertex );
                GLASSERT( triAtVertex );
                GLASSERT( triAtVertex->size() == nVertex );
                return (*triAtVertex)[vIndex];
        }

        void Validate() const;

        // Add a vertex (if new) or return the existing
        void AddVertex( const Vertex& vertex );
        void InitImport();
        void EndImport();
        void ConnectTri();
        void FreeImport();

        void GenerateVBO();
        bool HasVBO() const;
        void BindVBO() const;

private:
        void AllocateMax();
        void Trim();
        void NormalizeVertices();
        void FreeMem();

        SimpleMesh( const SimpleMesh& rhs );
        void operator=( const SimpleMesh& rhs );

        const Texture* texture;
        bool smoothing;

        U32  nIndex;    // every 3 indices is a tri.
        U32      nTri;          // always nIndex/3
        U32  nVertex;   // tris are made of vertices
        U32      vbo;

        // Used when the MeshObject is set up, and then deleted.
        grinliz::PtrHashTable< Vertex, VertexEqual >                    *flatVertexSet;
        grinliz::PtrHashTable< Vertex, VertexEqualWONormal >    *smoothVertexSet;
        std::vector< std::vector<int> >                                                 *triAtVertex;

        U16*    index;
        Tri*    tri;
        Vertex* vertex;

};
};

#endif

---