glc_geometry.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_GEOMETRY_H_
#define GLC_GEOMETRY_H_
#include "../shading/glc_material.h"
#include "../shading/glc_renderproperties.h"
#include "glc_wiredata.h"
#include "../glc_boundingbox.h"

#include "../glc_config.h"

typedef QHash<GLC_uint, GLC_Material*> MaterialHash;
typedef QHash<GLC_uint, GLC_uint> MaterialHashMap;




class GLC_LIB_EXPORT GLC_Geometry
{


public:

        GLC_Geometry(const QString &, const bool);

        GLC_Geometry(const GLC_Geometry&);

        GLC_Geometry& operator=(const GLC_Geometry&);

        virtual ~GLC_Geometry();



public:
        inline GLC_uint id() const
        {return m_Id;}

        inline QString name() const
        {return m_Name;}

        inline bool isValid(void) const
        {return m_GeometryIsValid;}

        inline bool hasMaterial() const
        {return !m_MaterialHash.isEmpty();}

        inline GLC_Material* firstMaterial(void) const
        {
                if (!m_MaterialHash.isEmpty())
                {
                        return m_MaterialHash.begin().value();
                }
                else return NULL;
        }

        inline int materialCount() const
        {return m_MaterialHash.size();}

        inline GLC_Material* material(const GLC_uint key) const
        {return m_MaterialHash[key];}

        inline QSet<GLC_Material*> materialSet() const
        {return m_MaterialHash.values().toSet();}

        inline QList<GLC_uint> materialIds() const
        {return m_MaterialHash.keys();}

        inline bool containsMaterial(const GLC_uint key) const
        {return m_MaterialHash.contains(key);}

        virtual const GLC_BoundingBox& boundingBox(void) = 0;

        inline bool boundingBoxIsValid() const
        {return NULL != m_pBoundingBox;}

        virtual GLC_Geometry* clone() const = 0;

        inline bool isTransparent() const
        {return (m_TransparentMaterialNumber >= m_MaterialHash.size()) && hasTransparentMaterials();}

        inline bool hasTransparentMaterials() const
        {return m_TransparentMaterialNumber > 0;}

        inline bool usedColorPerVertex() const
        {return m_UseColorPerVertex;}

        inline bool typeIsWire() const
        {return m_IsWire;}

        virtual unsigned int faceCount(int lod=0) const;

        virtual unsigned int VertexCount() const;

        GLfloat lineWidth() const
        {return m_LineWidth;}

        inline QColor wireColor() const
        {return m_WireColor;}

        inline bool wireDataIsEmpty() const
        {return m_WireData.isEmpty();}

        inline GLfloatVector wirePositionVector() const
        {return m_WireData.positionVector();}

        inline int wirePolylineCount() const
        {return m_WireData.verticeGroupCount();}

        inline GLuint wirePolylineOffset(int index) const
        {return m_WireData.verticeGroupOffset(index);}

        inline GLsizei wirePolylineSize(int index) const
        {return m_WireData.verticeGroupSize(index);}




public:

        virtual void clear();

        virtual void replaceMasterMaterial(GLC_Material*);

        void addMaterial(GLC_Material *);

        inline void colorPerVertex(const bool colorPerVertex)
        {
                if (m_UseColorPerVertex != colorPerVertex)
                {
                        m_UseColorPerVertex= colorPerVertex;
                        m_GeometryIsValid= false;
                }
        }

        void updateTransparentMaterialNumber();

        virtual void reverseNormals() {}


        virtual void setCurrentLod(const int) {}

        inline void setId(const GLC_uint id)
        {m_Id= id;}

        inline void setName(const QString name)
        {m_Name= name;}

        inline GLC_uint addVerticeGroup(const GLfloatVector& vector)
        {return m_WireData.addVerticeGroup(vector);}

        inline void setLineWidth(GLfloat lineWidth)
        {m_LineWidth= lineWidth;}

        void setWireColor(const QColor& color);

        virtual void copyVboToClientSide();

        virtual void releaseVboClientSide(bool update= false);




public:
        virtual void glLoadTexture(void);

        virtual void render(const GLC_RenderProperties&);


protected:

        virtual void glDraw(const GLC_RenderProperties&) = 0;

        virtual void glPropGeom(const GLC_RenderProperties&);




protected:
        void removeMaterial(GLC_uint);

        inline void clearWireAndBoundingBox()
        {
                delete m_pBoundingBox;
                m_pBoundingBox= NULL;
                m_WireData.clear();
                m_GeometryIsValid= false;
        }




private:
        void clearGeometry();


// Protected members
protected:

        bool m_GeometryIsValid;

        GLC_BoundingBox* m_pBoundingBox;

        MaterialHash m_MaterialHash;

        bool m_UseColorPerVertex;

        bool m_IsSelected;

        GLC_WireData m_WireData;

        QColor m_WireColor;

        GLfloat m_LineWidth;


// Private members
private:

        bool m_IsWire;

        int m_TransparentMaterialNumber;


        GLC_uint m_Id;

        QString m_Name;
};

#endif /*GLC_GEOMETRY_H_*/