glc_mesh.h

Go to the documentation of this file.

/****************************************************************************

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 Version 2.0.0 Beta 1, packaged on April 2010.

 http://glc-lib.sourceforge.net

 GLC-lib 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.

 GLC-lib 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 GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*****************************************************************************/


#ifndef GLC_MESH_H_
#define GLC_MESH_H_

#include <QHash>
#include <QList>
#include "../maths/glc_vector2df.h"
#include "../maths/glc_vector3df.h"
#include "../glc_global.h"
#include "../shading/glc_material.h"
#include "glc_meshdata.h"
#include "glc_geometry.h"
#include "glc_primitivegroup.h"
#include "../glc_state.h"
#include "../shading/glc_selectionmaterial.h"

#include "../glc_config.h"



class GLC_LIB_EXPORT GLC_Mesh : public GLC_Geometry
{
        friend QDataStream &operator<<(QDataStream &, const GLC_Mesh &);
        friend QDataStream &operator>>(QDataStream &, GLC_Mesh &);

public:
        typedef QHash<GLC_uint, GLC_PrimitiveGroup*> LodPrimitiveGroups;
        typedef QHash<const int, LodPrimitiveGroups*> PrimitiveGroupsHash;



public:
        GLC_Mesh();

        GLC_Mesh(const GLC_Mesh&);

        GLC_Mesh& operator=(const GLC_Mesh&);

        virtual ~GLC_Mesh();



public:
        static quint32 chunckID();

        virtual unsigned int faceCount() const;

        virtual unsigned int VertexCount() const;

        inline unsigned int numberOfNormals() const
        { return m_NumberOfNormals;}

        virtual const GLC_BoundingBox& boundingBox(void);

        virtual GLC_Geometry* clone() const;

        inline bool ColorPearVertexIsAcivated() const
        {return m_ColorPearVertex;}

        inline int lodCount() const
        {return m_MeshData.lodCount();}

        inline GLfloatVector positionVector() const
        {return m_MeshData.positionVector();}

        inline GLfloatVector normalVector() const
        {return m_MeshData.normalVector();}

        inline GLfloatVector texelVector() const
        {return m_MeshData.texelVector();}

        bool containsTriangles(int lod, GLC_uint materialId) const;


        QVector<GLuint> getTrianglesIndex(int lod, GLC_uint materialId) const;

        int numberOfTriangles(int lod, GLC_uint materialId) const;

        bool containsStrips(int lod, GLC_uint materialId) const;


        QList<QVector<GLuint> > getStripsIndex(int lod, GLC_uint materialId) const;

        int numberOfStrips(int lod, GLC_uint materialId) const;

        bool containsFans(int lod, GLC_uint materialId) const;


        QList<QVector<GLuint> > getFansIndex(int lod, GLC_uint materialId) const;

        int numberOfFans(int lod, GLC_uint materialId) const;

        inline bool containsLod(int lod) const
        {return (NULL != m_MeshData.getLod(lod));}

        inline bool lodContainsMaterial(int lod, GLC_uint materialId) const
        {
                if (!m_PrimitiveGroups.contains(lod))return false;
                else return m_PrimitiveGroups.value(lod)->contains(materialId);
        }


        inline double getLodAccuracy(int lod) const
        {
                Q_ASSERT(containsLod(lod));
                return m_MeshData.getLod(lod)->accuracy();
        }

        inline GLC_uint nextPrimitiveLocalId() const
        {return m_NextPrimitiveLocalId;}

        inline bool isEmpty() const
        {return m_MeshData.isEmpty();}

        inline QColor wireColor() const
        {return m_WireColor;}





public:

        virtual void clear();

        void clearMeshWireAndBoundingBox();

        inline void addVertice(const GLfloatVector& vertices)
        {
                *(m_MeshData.positionVectorHandle())+= vertices;
                m_NumberOfVertice+= vertices.size() / 3;
        }

        inline void addNormals(const GLfloatVector& normals)
        {
                *(m_MeshData.normalVectorHandle())+= normals;
                m_NumberOfNormals+= normals.size() / 3;
        }

        inline void addTexels(const GLfloatVector& texels)
        {*(m_MeshData.texelVectorHandle())+= texels;}

        inline void addColors(const GLfloatVector& colors)
        {*(m_MeshData.colorVectorHandle())+= colors;}

        GLC_uint addTriangles(GLC_Material*, const IndexList&, const int lod= 0, double accuracy= 0.0);

        GLC_uint addTrianglesStrip(GLC_Material*, const IndexList&, const int lod= 0, double accuracy= 0.0);

        GLC_uint addTrianglesFan(GLC_Material*, const IndexList&, const int lod= 0, double accuracy= 0.0);

        void reverseNormals();

        inline void setColorPearVertex(bool flag)
        {m_ColorPearVertex= flag;}

        void finish();

        virtual void setCurrentLod(const int);

        virtual void replaceMasterMaterial(GLC_Material*);

        void replaceMaterial(const GLC_uint, GLC_Material*);

        inline void setNextPrimitiveLocalId(GLC_uint id)
        {m_NextPrimitiveLocalId= id;}

        inline void setWireColor(const QColor& color)
        {m_WireColor= color;}




public:

        void loadFromDataStream(QDataStream&, const MaterialHash&, const QHash<GLC_uint, GLC_uint>&);

        void saveToDataStream(QDataStream&) const;




protected:


        virtual void glDraw(const GLC_RenderProperties&);




private:
        GLC_uint setCurrentMaterial(GLC_Material*, const int, double);

        void fillVbosAndIbos();

        void finishSerialized();

        void finishVbo();

        void finishNonVbo();

        inline void vboDrawPrimitivesOf(GLC_PrimitiveGroup*);

        inline void vertexArrayDrawPrimitivesOf(GLC_PrimitiveGroup*);

        inline void vboDrawInSelectionModePrimitivesOf(GLC_PrimitiveGroup*);

        inline void vertexArrayDrawInSelectionModePrimitivesOf(GLC_PrimitiveGroup*);

        inline void vboDrawPrimitivesGroupOf(GLC_PrimitiveGroup*, GLC_Material*, bool, bool, QHash<GLC_uint, GLC_Material*>*);

        inline void vertexArrayDrawPrimitivesGroupOf(GLC_PrimitiveGroup*, GLC_Material*, bool, bool, QHash<GLC_uint, GLC_Material*>*);

        inline void vboDrawSelectedPrimitivesGroupOf(GLC_PrimitiveGroup*, GLC_Material*, bool, bool, const GLC_RenderProperties&);

        inline void vertexArrayDrawSelectedPrimitivesGroupOf(GLC_PrimitiveGroup*, GLC_Material*, bool, bool, const GLC_RenderProperties&);

        inline void activateVboAndIbo();

        inline void activateVertexArray();

        void normalRenderLoop(const GLC_RenderProperties&, bool);

        void OverwriteMaterialRenderLoop(const GLC_RenderProperties&, bool);

        void OverwriteTransparencyRenderLoop(const GLC_RenderProperties&, bool);

        void bodySelectionRenderLoop(bool);

        void primitiveSelectionRenderLoop(bool);

        void primitiveRenderLoop(const GLC_RenderProperties&, bool);

        void primitiveSelectedRenderLoop(const GLC_RenderProperties&, bool);



// Private members
private:
        GLC_uint m_NextPrimitiveLocalId;

        PrimitiveGroupsHash m_PrimitiveGroups;

        GLC_uint m_DefaultMaterialId;

        unsigned int m_NumberOfFaces;

        unsigned int m_NumberOfVertice;

        unsigned int m_NumberOfNormals;

        bool m_ColorPearVertex;

        GLC_MeshData m_MeshData;

        int m_CurrentLod;

        static quint32 m_ChunkId;

};

// Inline functions

// Use VBO to Draw triangles from the specified GLC_PrimitiveGroup
void GLC_Mesh::vboDrawPrimitivesOf(GLC_PrimitiveGroup* pCurrentGroup)
{
        // Draw triangles
        if (pCurrentGroup->containsTriangles())
        {
                glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSize(), GL_UNSIGNED_INT, pCurrentGroup->trianglesIndexOffset());
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStrip())
        {
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffset().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->stripsOffset().at(i));
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFan())
        {
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffset().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->fansOffset().at(i));
                }
        }
}
// Use Vertex Array to Draw triangles from the specified GLC_PrimitiveGroup
void GLC_Mesh::vertexArrayDrawPrimitivesOf(GLC_PrimitiveGroup* pCurrentGroup)
{
        // Draw triangles
        if (pCurrentGroup->containsTriangles())
        {
                GLvoid* pOffset= &(m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->trianglesIndexOffseti()]);
                glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSize(), GL_UNSIGNED_INT, pOffset);
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStrip())
        {
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffseti().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->stripsOffseti().at(i)];
                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pOffset);
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFan())
        {
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffseti().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->fansOffseti().at(i)];
                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pOffset);
                }
        }
}

// Use VBO to Draw primitives in selection mode from the specified GLC_PrimitiveGroup
void GLC_Mesh::vboDrawInSelectionModePrimitivesOf(GLC_PrimitiveGroup* pCurrentGroup)
{
        GLubyte colorId[4];
        // Draw triangles
        if (pCurrentGroup->containsTrianglesGroupId())
        {
                const GLsizei trianglesGroupCount= static_cast<GLsizei>(pCurrentGroup->trianglesGroupOffset().size());
                for (GLint i= 0; i < trianglesGroupCount; ++i)
                {
                        glc::encodeRgbId(pCurrentGroup->triangleGroupId(i), colorId);
                        glColor3ubv(colorId);
                        glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->trianglesGroupOffset().at(i));
                }
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStripGroupId())
        {
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffset().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        glc::encodeRgbId(pCurrentGroup->stripGroupId(i), colorId);
                        glColor3ubv(colorId);
                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->stripsOffset().at(i));
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFanGroupId())
        {
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffset().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        glc::encodeRgbId(pCurrentGroup->fanGroupId(i), colorId);
                        glColor3ubv(colorId);

                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->fansOffset().at(i));
                }
        }

}

// Use Vertex Array to Draw primitives in selection mode from the specified GLC_PrimitiveGroup
void GLC_Mesh::vertexArrayDrawInSelectionModePrimitivesOf(GLC_PrimitiveGroup* pCurrentGroup)
{
        GLubyte colorId[4];
        // Draw triangles
        if (pCurrentGroup->containsTrianglesGroupId())
        {
                const GLsizei trianglesGroupCount= static_cast<GLsizei>(pCurrentGroup->trianglesGroupOffseti().size());
                for (GLint i= 0; i < trianglesGroupCount; ++i)
                {
                        glc::encodeRgbId(pCurrentGroup->triangleGroupId(i), colorId);
                        glColor3ubv(colorId);

                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->trianglesGroupOffseti().at(i)];
                        glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pOffset);
                }

                GLvoid* pOffset= &(m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->trianglesIndexOffseti()]);
                glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSize(), GL_UNSIGNED_INT, pOffset);
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStripGroupId())
        {
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffseti().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        glc::encodeRgbId(pCurrentGroup->stripGroupId(i), colorId);
                        glColor3ubv(colorId);

                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->stripsOffseti().at(i)];
                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pOffset);
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFanGroupId())
        {
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffseti().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        glc::encodeRgbId(pCurrentGroup->fanGroupId(i), colorId);
                        glColor3ubv(colorId);

                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->fansOffseti().at(i)];
                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pOffset);
                }
        }
}

// Use VBO to Draw primitives with specific materials from the specified GLC_PrimitiveGroup
void GLC_Mesh::vboDrawPrimitivesGroupOf(GLC_PrimitiveGroup* pCurrentGroup, GLC_Material* pCurrentMaterial, bool materialIsRenderable
                , bool isTransparent,  QHash<GLC_uint, GLC_Material*>* pMaterialHash)
{
        GLC_Material* pCurrentLocalMaterial= pCurrentMaterial;
        // Draw triangles
        if (pCurrentGroup->containsTriangles())
        {
                Q_ASSERT(pCurrentGroup->containsTrianglesGroupId());
                const GLsizei trianglesGroupCount= static_cast<GLsizei>(pCurrentGroup->trianglesGroupOffset().size());
                for (GLint i= 0; i < trianglesGroupCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->triangleGroupId(i);
                        if (pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pCurrentLocalMaterial != pMaterialHash->value(currentPrimitiveId))
                                {
                                        pCurrentLocalMaterial= pMaterialHash->value(currentPrimitiveId);
                                        if (pCurrentLocalMaterial->isTransparent() == isTransparent) pCurrentLocalMaterial->glExecute();
                                }
                        }
                        else if (pCurrentLocalMaterial != pCurrentMaterial)
                        {
                                pCurrentLocalMaterial= pCurrentMaterial;
                                if (materialIsRenderable) pCurrentLocalMaterial->glExecute();
                        }
                        if (pCurrentLocalMaterial->isTransparent() == isTransparent)
                        {
                                glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->trianglesGroupOffset().at(i));
                        }
                }
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStrip())
        {
                Q_ASSERT(pCurrentGroup->containsStripGroupId());
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffset().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->stripGroupId(i);
                        if (pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pCurrentLocalMaterial != pMaterialHash->value(currentPrimitiveId))
                                {
                                        pCurrentLocalMaterial= pMaterialHash->value(currentPrimitiveId);
                                        if (pCurrentLocalMaterial->isTransparent() == isTransparent) pCurrentLocalMaterial->glExecute();
                                }
                        }
                        else if (pCurrentLocalMaterial != pCurrentMaterial)
                        {
                                pCurrentLocalMaterial= pCurrentMaterial;
                                if (materialIsRenderable) pCurrentLocalMaterial->glExecute();
                        }
                        if (pCurrentLocalMaterial->isTransparent() == isTransparent)
                        {
                                glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->stripsOffset().at(i));
                        }
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFan())
        {
                Q_ASSERT(pCurrentGroup->containsFanGroupId());
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffset().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->fanGroupId(i);
                        if (pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pCurrentLocalMaterial != pMaterialHash->value(currentPrimitiveId))
                                {
                                        pCurrentLocalMaterial= pMaterialHash->value(currentPrimitiveId);
                                        if (pCurrentLocalMaterial->isTransparent() == isTransparent) pCurrentLocalMaterial->glExecute();
                                }
                        }
                        else if (pCurrentLocalMaterial != pCurrentMaterial)
                        {
                                pCurrentLocalMaterial= pCurrentMaterial;
                                if (materialIsRenderable) pCurrentLocalMaterial->glExecute();
                        }
                        if (pCurrentLocalMaterial->isTransparent() == isTransparent)
                        {
                                glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->fansOffset().at(i));
                        }
                }
        }

}

// Use Vertex Array to Draw primitives with specific materials from the specified GLC_PrimitiveGroup
void GLC_Mesh::vertexArrayDrawPrimitivesGroupOf(GLC_PrimitiveGroup* pCurrentGroup, GLC_Material* pCurrentMaterial, bool materialIsRenderable
                , bool isTransparent, QHash<GLC_uint, GLC_Material*>* pMaterialHash)
{
        GLC_Material* pCurrentLocalMaterial= pCurrentMaterial;
        // Draw triangles
        if (pCurrentGroup->containsTriangles())
        {
                Q_ASSERT(pCurrentGroup->containsTrianglesGroupId());
                const GLsizei trianglesGroupCount= static_cast<GLsizei>(pCurrentGroup->trianglesGroupOffseti().size());
                for (GLint i= 0; i < trianglesGroupCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->triangleGroupId(i);
                        if (pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pCurrentLocalMaterial != pMaterialHash->value(currentPrimitiveId))
                                {
                                        pCurrentLocalMaterial= pMaterialHash->value(currentPrimitiveId);
                                        if (pCurrentLocalMaterial->isTransparent() == isTransparent) pCurrentLocalMaterial->glExecute();
                                }
                        }
                        else if (pCurrentLocalMaterial != pCurrentMaterial)
                        {
                                pCurrentLocalMaterial= pCurrentMaterial;
                                if (materialIsRenderable) pCurrentLocalMaterial->glExecute();
                        }
                        if (pCurrentLocalMaterial->isTransparent() == isTransparent)
                        {
                                GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->trianglesGroupOffseti().at(i)];
                                glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pOffset);
                        }
                }
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStrip())
        {
                Q_ASSERT(pCurrentGroup->containsStripGroupId());
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffseti().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->stripGroupId(i);
                        if (pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pCurrentLocalMaterial != pMaterialHash->value(currentPrimitiveId))
                                {
                                        pCurrentLocalMaterial= pMaterialHash->value(currentPrimitiveId);
                                        if (pCurrentLocalMaterial->isTransparent() == isTransparent) pCurrentLocalMaterial->glExecute();
                                }
                        }
                        else if (pCurrentLocalMaterial != pCurrentMaterial)
                        {
                                pCurrentLocalMaterial= pCurrentMaterial;
                                if (materialIsRenderable) pCurrentLocalMaterial->glExecute();
                        }
                        if (pCurrentLocalMaterial->isTransparent() == isTransparent)
                        {
                                GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->stripsOffseti().at(i)];
                                glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pOffset);
                        }
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFan())
        {
                Q_ASSERT(pCurrentGroup->containsFanGroupId());
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffseti().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->fanGroupId(i);
                        if (pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pCurrentLocalMaterial != pMaterialHash->value(currentPrimitiveId))
                                {
                                        pCurrentLocalMaterial= pMaterialHash->value(currentPrimitiveId);
                                        if (pCurrentLocalMaterial->isTransparent() == isTransparent) pCurrentLocalMaterial->glExecute();
                                }
                        }
                        else if (pCurrentLocalMaterial != pCurrentMaterial)
                        {
                                pCurrentLocalMaterial= pCurrentMaterial;
                                if (materialIsRenderable) pCurrentLocalMaterial->glExecute();
                        }
                        if (pCurrentLocalMaterial->isTransparent() == isTransparent)
                        {
                                GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->fansOffseti().at(i)];
                                glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pOffset);
                        }
                }
        }

}

// Use VBO to Draw primitives with specific materials from the specified GLC_PrimitiveGroup
void GLC_Mesh::vboDrawSelectedPrimitivesGroupOf(GLC_PrimitiveGroup* pCurrentGroup, GLC_Material* pCurrentMaterial, bool materialIsRenderable
                , bool isTransparent, const GLC_RenderProperties& renderProperties)
{
        QSet<GLC_uint>* pSelectedPrimitive= renderProperties.setOfSelectedPrimitivesId();
        Q_ASSERT(NULL != pSelectedPrimitive);

        QHash<GLC_uint, GLC_Material*>* pMaterialHash= NULL;
        if (!renderProperties.hashOfOverwritePrimitiveMaterialsIsEmpty())
        {
                pMaterialHash= renderProperties.hashOfOverwritePrimitiveMaterials();
        }

        GLC_Material* pCurrentLocalMaterial= pCurrentMaterial;
        // Draw triangles
        if (pCurrentGroup->containsTriangles())
        {
                Q_ASSERT(pCurrentGroup->containsTrianglesGroupId());
                const GLsizei trianglesGroupCount= static_cast<GLsizei>(pCurrentGroup->trianglesGroupOffset().size());
                for (GLint i= 0; i < trianglesGroupCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->triangleGroupId(i);
                        if (pSelectedPrimitive->contains(currentPrimitiveId))
                        {
                                if (!isTransparent)
                                {
                                        GLC_SelectionMaterial::glExecute();
                                        pCurrentLocalMaterial= NULL;
                                        glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->trianglesGroupOffset().at(i));
                                }
                        }
                        else if ((NULL != pMaterialHash) && pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pMaterialHash->value(currentPrimitiveId)->isTransparent() == isTransparent)
                                {
                                        GLC_Material* pMat= pMaterialHash->value(currentPrimitiveId);
                                        if (pMat != pCurrentLocalMaterial)
                                        {
                                                pCurrentLocalMaterial= pMat;
                                                pCurrentLocalMaterial->glExecute();
                                        }
                                        glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->trianglesGroupOffset().at(i));
                                }

                        }
                        else if (materialIsRenderable)
                        {
                                if (pCurrentLocalMaterial != pCurrentMaterial)
                                {
                                        pCurrentLocalMaterial= pCurrentMaterial;
                                        pCurrentLocalMaterial->glExecute();
                                }
                                glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->trianglesGroupOffset().at(i));
                        }
                }
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStrip())
        {
                Q_ASSERT(pCurrentGroup->containsStripGroupId());
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffset().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->stripGroupId(i);
                        if (pSelectedPrimitive->contains(currentPrimitiveId))
                        {
                                if (!isTransparent)
                                {
                                        GLC_SelectionMaterial::glExecute();
                                        pCurrentLocalMaterial= NULL;
                                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->stripsOffset().at(i));
                                }
                        }
                        else if ((NULL != pMaterialHash) && pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pMaterialHash->value(currentPrimitiveId)->isTransparent() == isTransparent)
                                {
                                        GLC_Material* pMat= pMaterialHash->value(currentPrimitiveId);
                                        if (pMat != pCurrentLocalMaterial)
                                        {
                                                pCurrentLocalMaterial= pMat;
                                                pCurrentLocalMaterial->glExecute();
                                        }
                                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->stripsOffset().at(i));
                                }

                        }
                        else if (materialIsRenderable)
                        {
                                if (pCurrentLocalMaterial != pCurrentMaterial)
                                {
                                        pCurrentLocalMaterial= pCurrentMaterial;
                                        pCurrentLocalMaterial->glExecute();
                                }
                                glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->stripsOffset().at(i));
                        }
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFan())
        {
                Q_ASSERT(pCurrentGroup->containsFanGroupId());
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffset().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->fanGroupId(i);
                        if (pSelectedPrimitive->contains(currentPrimitiveId))
                        {
                                if (!isTransparent)
                                {
                                        GLC_SelectionMaterial::glExecute();
                                        pCurrentLocalMaterial= NULL;
                                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->fansOffset().at(i));
                                }
                        }
                        else if ((NULL != pMaterialHash) && pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pMaterialHash->value(currentPrimitiveId)->isTransparent() == isTransparent)
                                {
                                        GLC_Material* pMat= pMaterialHash->value(currentPrimitiveId);
                                        if (pMat != pCurrentLocalMaterial)
                                        {
                                                pCurrentLocalMaterial= pMat;
                                                pCurrentLocalMaterial->glExecute();
                                        }
                                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->fansOffset().at(i));
                                }

                        }
                        else if (materialIsRenderable)
                        {
                                if (pCurrentLocalMaterial != pCurrentMaterial)
                                {
                                        pCurrentLocalMaterial= pCurrentMaterial;
                                        pCurrentLocalMaterial->glExecute();
                                }
                                glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pCurrentGroup->fansOffset().at(i));
                        }
                }
        }

}

// Use Vertex Array to Draw primitives with specific materials from the specified GLC_PrimitiveGroup
void GLC_Mesh::vertexArrayDrawSelectedPrimitivesGroupOf(GLC_PrimitiveGroup* pCurrentGroup, GLC_Material* pCurrentMaterial, bool materialIsRenderable
                , bool isTransparent, const GLC_RenderProperties& renderProperties)
{
        QSet<GLC_uint>* pSelectedPrimitive= renderProperties.setOfSelectedPrimitivesId();
        Q_ASSERT(NULL != pSelectedPrimitive);

        QHash<GLC_uint, GLC_Material*>* pMaterialHash= NULL;
        if (!renderProperties.hashOfOverwritePrimitiveMaterialsIsEmpty())
        {
                pMaterialHash= renderProperties.hashOfOverwritePrimitiveMaterials();
        }

        GLC_Material* pCurrentLocalMaterial= pCurrentMaterial;
        // Draw triangles
        if (pCurrentGroup->containsTriangles())
        {
                Q_ASSERT(pCurrentGroup->containsTrianglesGroupId());
                const GLsizei trianglesGroupCount= static_cast<GLsizei>(pCurrentGroup->trianglesGroupOffseti().size());
                for (GLint i= 0; i < trianglesGroupCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->triangleGroupId(i);
                        if (pSelectedPrimitive->contains(currentPrimitiveId))
                        {
                                if (!isTransparent)
                                {
                                        GLC_SelectionMaterial::glExecute();
                                        pCurrentLocalMaterial= NULL;
                                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->trianglesGroupOffseti().at(i)];
                                        glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pOffset);
                                }
                        }
                        else if ((NULL != pMaterialHash) && pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pMaterialHash->value(currentPrimitiveId)->isTransparent() == isTransparent)
                                {
                                        GLC_Material* pMat= pMaterialHash->value(currentPrimitiveId);
                                        if (pMat != pCurrentLocalMaterial)
                                        {
                                                pCurrentLocalMaterial= pMat;
                                                pCurrentLocalMaterial->glExecute();
                                        }
                                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->trianglesGroupOffseti().at(i)];
                                        glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pOffset);
                                }

                        }
                        else if (materialIsRenderable)
                        {
                                if (pCurrentLocalMaterial != pCurrentMaterial)
                                {
                                        pCurrentLocalMaterial= pCurrentMaterial;
                                        pCurrentLocalMaterial->glExecute();
                                }
                                GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->trianglesGroupOffseti().at(i)];
                                glDrawElements(GL_TRIANGLES, pCurrentGroup->trianglesIndexSizes().at(i), GL_UNSIGNED_INT, pOffset);
                        }
                }
        }

        // Draw Triangles strip
        if (pCurrentGroup->containsStrip())
        {
                Q_ASSERT(pCurrentGroup->containsStripGroupId());
                const GLsizei stripsCount= static_cast<GLsizei>(pCurrentGroup->stripsOffseti().size());
                for (GLint i= 0; i < stripsCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->stripGroupId(i);
                        if (pSelectedPrimitive->contains(currentPrimitiveId))
                        {
                                if (!isTransparent)
                                {
                                        GLC_SelectionMaterial::glExecute();
                                        pCurrentLocalMaterial= NULL;
                                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->stripsOffseti().at(i)];
                                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pOffset);
                                }
                        }
                        else if ((NULL != pMaterialHash) && pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pMaterialHash->value(currentPrimitiveId)->isTransparent() == isTransparent)
                                {
                                        GLC_Material* pMat= pMaterialHash->value(currentPrimitiveId);
                                        if (pMat != pCurrentLocalMaterial)
                                        {
                                                pCurrentLocalMaterial= pMat;
                                                pCurrentLocalMaterial->glExecute();
                                        }
                                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->stripsOffseti().at(i)];
                                        glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pOffset);
                                }

                        }
                        else if (materialIsRenderable)
                        {
                                if (pCurrentLocalMaterial != pCurrentMaterial)
                                {
                                        pCurrentLocalMaterial= pCurrentMaterial;
                                        pCurrentLocalMaterial->glExecute();
                                }
                                GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->stripsOffseti().at(i)];
                                glDrawElements(GL_TRIANGLE_STRIP, pCurrentGroup->stripsSizes().at(i), GL_UNSIGNED_INT, pOffset);
                        }
                }
        }

        // Draw Triangles fan
        if (pCurrentGroup->containsFan())
        {
                Q_ASSERT(pCurrentGroup->containsFanGroupId());
                const GLsizei fansCount= static_cast<GLsizei>(pCurrentGroup->fansOffseti().size());
                for (GLint i= 0; i < fansCount; ++i)
                {
                        GLC_uint currentPrimitiveId= pCurrentGroup->fanGroupId(i);
                        if (pSelectedPrimitive->contains(currentPrimitiveId))
                        {
                                if (!isTransparent)
                                {
                                        GLC_SelectionMaterial::glExecute();
                                        pCurrentLocalMaterial= NULL;
                                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->fansOffseti().at(i)];
                                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pOffset);
                                }
                        }
                        else if ((NULL != pMaterialHash) && pMaterialHash->contains(currentPrimitiveId))
                        {
                                if (pMaterialHash->value(currentPrimitiveId)->isTransparent() == isTransparent)
                                {
                                        GLC_Material* pMat= pMaterialHash->value(currentPrimitiveId);
                                        if (pMat != pCurrentLocalMaterial)
                                        {
                                                pCurrentLocalMaterial= pMat;
                                                pCurrentLocalMaterial->glExecute();
                                        }
                                        GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->fansOffseti().at(i)];
                                        glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pOffset);
                                }

                        }
                        else if (materialIsRenderable)
                        {
                                if (pCurrentLocalMaterial != pCurrentMaterial)
                                {
                                        pCurrentLocalMaterial= pCurrentMaterial;
                                        pCurrentLocalMaterial->glExecute();
                                }
                                GLvoid* pOffset= &m_MeshData.indexVectorHandle(m_CurrentLod)->data()[pCurrentGroup->fansOffseti().at(i)];
                                glDrawElements(GL_TRIANGLE_FAN, pCurrentGroup->fansSizes().at(i), GL_UNSIGNED_INT, pOffset);
                        }
                }
        }

}

// Activate mesh VBOs and IBO of the current LOD
void GLC_Mesh::activateVboAndIbo()
{
        // Activate Vertices VBO
        m_MeshData.useVBO(true, GLC_MeshData::GLC_Vertex);
        glVertexPointer(3, GL_FLOAT, 0, 0);
        glEnableClientState(GL_VERTEX_ARRAY);

        // Activate Normals VBO
        m_MeshData.useVBO(true, GLC_MeshData::GLC_Normal);
        glNormalPointer(GL_FLOAT, 0, 0);
        glEnableClientState(GL_NORMAL_ARRAY);

        // Activate texel VBO if needed
        if (m_MeshData.useVBO(true, GLC_MeshData::GLC_Texel))
        {
                glTexCoordPointer(2, GL_FLOAT, 0, 0);
                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        }

        // Activate Color VBO if needed
        if ((m_ColorPearVertex && !m_IsSelected && !GLC_State::isInSelectionMode()) && m_MeshData.useVBO(true, GLC_MeshData::GLC_Color))
        {
                glEnable(GL_COLOR_MATERIAL);
                glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
                glColorPointer(4, GL_FLOAT, 0, 0);
                glEnableClientState(GL_COLOR_ARRAY);
        }

        m_MeshData.useIBO(true, m_CurrentLod);
}

// Activate vertex Array
void GLC_Mesh::activateVertexArray()
{
        // Use Vertex Array
        glVertexPointer(3, GL_FLOAT, 0, m_MeshData.positionVectorHandle()->data());
        glEnableClientState(GL_VERTEX_ARRAY);

        glNormalPointer(GL_FLOAT, 0, m_MeshData.normalVectorHandle()->data());
        glEnableClientState(GL_NORMAL_ARRAY);

        // Activate texel if needed
        if (!m_MeshData.texelVectorHandle()->isEmpty())
        {
                glTexCoordPointer(2, GL_FLOAT, 0, m_MeshData.texelVectorHandle()->data());
                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        }

        // Activate Color VBO if needed
        if ((m_ColorPearVertex && !m_IsSelected && !GLC_State::isInSelectionMode()) && !m_MeshData.colorVectorHandle()->isEmpty())
        {
                glEnable(GL_COLOR_MATERIAL);
                glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
                glColorPointer(4, GL_FLOAT, 0, m_MeshData.colorVectorHandle()->data());
                glEnableClientState(GL_COLOR_ARRAY);
        }
}



#endif /* GLC_MESH_H_ */