glc_meshdata.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)
 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 3 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser 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_MESHDATA_H_
#define GLC_MESHDATA_H_

#include <QVector>

#include "glc_lod.h"
#include "../glc_global.h"

#include "../glc_config.h"




class GLC_LIB_EXPORT GLC_MeshData
{
        friend GLC_LIB_EXPORT QDataStream &operator<<(QDataStream &, const GLC_MeshData &);
        friend GLC_LIB_EXPORT QDataStream &operator>>(QDataStream &, GLC_MeshData &);

public:

        enum VboType
        {
                GLC_Vertex= 30,
                GLC_Normal,
                GLC_Texel,
                GLC_Color
        };



public:
        GLC_MeshData();

        GLC_MeshData(const GLC_MeshData&);

        GLC_MeshData& operator=(const GLC_MeshData&);

        virtual ~GLC_MeshData();



public:
        static quint32 chunckID();

        inline int lodCount() const
        {return m_LodList.size();}

        GLfloatVector positionVector() const;

        GLfloatVector normalVector() const;

        GLfloatVector texelVector() const;

        GLfloatVector colorVector() const;

        inline GLfloatVector* positionVectorHandle()
        { return &m_Positions;}

        inline GLfloatVector* normalVectorHandle()
        { return &m_Normals;}

        inline GLfloatVector* texelVectorHandle()
        { return &m_Texels;}

        inline GLfloatVector* colorVectorHandle()
        { return &m_Colors;}

        inline GLuintVector indexVector(const int i= 0) const
        {
                Q_ASSERT(i < m_LodList.size());
                return m_LodList.at(i)->indexVector();
        }

        inline GLuintVector* indexVectorHandle(const int i= 0) const
        {
                Q_ASSERT(i < m_LodList.size());
                return m_LodList.at(i)->indexVectorHandle();
        }

        inline int indexVectorSize(const int i= 0) const
        {
                Q_ASSERT(i < m_LodList.size());
                return m_LodList.at(i)->indexVectorSize();
        }
        inline GLC_Lod* getLod(int index) const
        {
                return m_LodList.value(index);
        }

        inline bool isEmpty() const
        {return (0 == m_PositionSize) && (0 == m_Positions.size());}

        inline unsigned int trianglesCount(int lod) const
        {
                Q_ASSERT(lod < m_LodList.size());
                return m_LodList.at(lod)->trianglesCount();
        }




public:
        inline void appendLod(double accuracy= 0.0)
        {m_LodList.append(new GLC_Lod(accuracy));}

        void finishVbo();

        void finishLod();

        void clear();

        void copyVboToClientSide();

        void releaseVboClientSide(bool update= false);

        inline void trianglesAdded(int lod, int number)
        {
                if (lod != 0) lod-= 1;
                else lod= m_LodList.size() - 1;
                m_LodList.at(lod)->trianglesAdded(number);
        }




public:
        void createVBOs();

        bool useVBO(bool, GLC_MeshData::VboType) const;

        inline void useIBO(bool use, const int currentLod= 0)
        {
                if (use) m_LodList.at(currentLod)->useIBO();
                else glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
        }

        void fillVbo(GLC_MeshData::VboType vboType);


// Private members
private:

        GLuint m_VboId;

        GLfloatVector m_Positions;

        GLfloatVector m_Normals;

        GLfloatVector m_Texels;

        GLfloatVector m_Colors;

        GLuint m_NormalVboId;

        GLuint m_TexelVboId;

        GLuint m_ColorVboId;

        QList<GLC_Lod*> m_LodList;

        int m_PositionSize;

        int m_TexelsSize;

        int m_ColorSize;

        static quint32 m_ChunkId;
};

GLC_LIB_EXPORT QDataStream &operator<<(QDataStream &, const GLC_MeshData &);
GLC_LIB_EXPORT QDataStream &operator>>(QDataStream &, GLC_MeshData &);

#endif /* GLC_MESHDATA_H_ */