glc_3dviewinstance.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_3DVIEWINSTANCE_H_
#define GLC_3DVIEWINSTANCE_H_

#include "../glc_global.h"
#include "../glc_boundingbox.h"
#include "../glc_object.h"
#include "../maths/glc_matrix4x4.h"
#include "../glc_state.h"
#include "../geometry/glc_3drep.h"
#include "../shading/glc_renderproperties.h"

#include <QMutex>

#include "../glc_config.h"

class GLC_Viewport;




class GLC_LIB_EXPORT GLC_3DViewInstance : public GLC_Object
{
public:
        enum Viewable
        {
                FullViewable= 120,
                PartialViewable= 121,
                NoViewable= 122
        };


public:
        GLC_3DViewInstance();

        GLC_3DViewInstance(GLC_Geometry* pGeom);

        GLC_3DViewInstance(const GLC_3DRep&);

        GLC_3DViewInstance(const GLC_3DViewInstance& );

        GLC_3DViewInstance &operator=(const GLC_3DViewInstance&);

        ~GLC_3DViewInstance();




public:
        inline bool isTransparent() const;

        inline bool hasTransparentMaterials() const;

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

        inline bool isSelected(void) const
        {return m_RenderProperties.isSelected();}

        inline int numberOfGeometry() const
        {return m_3DRep.numberOfBody();}


        inline GLC_Geometry* geomAt(int index) const
        {
                if (!m_3DRep.isEmpty()) return m_3DRep.geomAt(index);
                else return NULL;
        }

        GLC_BoundingBox boundingBox();

        inline bool boundingBoxValidity() const
        {return (m_pBoundingBox != NULL) && m_IsBoundingBoxValid && m_3DRep.boundingBoxIsValid();}

        inline const GLC_Matrix4x4& matrix() const
        {return m_AbsoluteMatrix;}

        GLC_3DViewInstance deepCopy() const;

        GLC_3DViewInstance instanciate();


        inline GLenum polygonMode() const
        {return m_RenderProperties.polygonMode();}

        inline GLC_RenderProperties* renderPropertiesHandle()
        {return &m_RenderProperties;}

        inline bool isVisible() const
        {return m_IsVisible;}

        inline GLC_3DViewInstance::Viewable viewableFlag() const
        {return m_ViewableFlag;}

        inline bool isGeomViewable(int index) const
        {return m_ViewableGeomFlag.at(index);}

        inline unsigned int numberOfFaces() const
        {return m_3DRep.faceCount();}

        inline unsigned int numberOfVertex() const
        {return m_3DRep.vertexCount();}

        inline unsigned int numberOfMaterials() const
        {return m_3DRep.materialCount();}

        inline QSet<GLC_Material*> materialSet() const
        {return m_3DRep.materialSet();}

        inline int defaultLodValue() const
        {return m_DefaultLOD;}

        inline GLC_3DRep representation() const
        {return m_3DRep;}

        inline int numberOfBody() const
        {return m_3DRep.numberOfBody();}

        inline static int globalDefaultLod()
        {
                return m_GlobalDefaultLOD;
        }




public:


        bool setGeometry(GLC_Geometry* pGeom);

        inline void removeEmptyGeometry()
        {m_3DRep.clean();}

        inline void reverseGeometriesNormals()
        {m_3DRep.reverseNormals();}

        GLC_3DViewInstance& translate(double Tx, double Ty, double Tz);

        inline GLC_3DViewInstance& translate(const GLC_Vector3d& v)
        {
                return translate(v.x(), v.y(), v.z());
        }

        GLC_3DViewInstance& multMatrix(const GLC_Matrix4x4 &MultMat);

        GLC_3DViewInstance& setMatrix(const GLC_Matrix4x4 &SetMat);

        GLC_3DViewInstance& resetMatrix(void);


        inline void setPolygonMode(GLenum Face, GLenum Mode)
        {m_RenderProperties.setPolygonMode(Face, Mode);}

        inline void select(bool primitive)
        {m_RenderProperties.select(primitive);}

        inline void unselect(void)
        {m_RenderProperties.unselect();}

        inline void setVisibility(bool visibility)
        {m_IsVisible= visibility;}

        inline void setId(const GLC_uint id)
        {
                GLC_Object::setId(id);
                glc::encodeRgbId(m_Uid, m_colorId);
        }

        inline void setDefaultLodValue(int lod)
        {
                m_DefaultLOD= lod;
        }

        inline bool setViewable(GLC_3DViewInstance::Viewable flag);

        inline void setGeomViewable(int index, bool flag)
        {m_ViewableGeomFlag[index]= flag;}


        static void setGlobalDefaultLod(int);

        inline void setRenderProperties(const GLC_RenderProperties& renderProperties)
        {m_RenderProperties= renderProperties;}




public:
        void render(glc::RenderFlag renderFlag= glc::ShadingFlag, bool useLoad= false, GLC_Viewport* pView= NULL);

        void renderForBodySelection();

        int renderForPrimitiveSelection(GLC_uint);


private:
        inline void OpenglVisProperties()
        {
                // Polygons display mode
                glPolygonMode(m_RenderProperties.polyFaceMode(), m_RenderProperties.polygonMode());
                // Change the current matrix
                glMultMatrixd(m_AbsoluteMatrix.getData());
        }



// private services functions
private:
        void computeBoundingBox(void);

        void clear();

        int choseLod(const GLC_BoundingBox&, GLC_Viewport*, bool);

// Private members
private:

        GLC_3DRep m_3DRep;

        GLC_BoundingBox* m_pBoundingBox;

        GLC_Matrix4x4 m_AbsoluteMatrix;

        bool m_IsBoundingBoxValid;

        GLC_RenderProperties m_RenderProperties;

        bool m_IsVisible;

        GLubyte m_colorId[4];

        int m_DefaultLOD;

        Viewable m_ViewableFlag;

        QVector<bool> m_ViewableGeomFlag;

        static QMutex m_Mutex;

        static int m_GlobalDefaultLOD;


};

// Return true if the all instance's mesh are transparent
bool GLC_3DViewInstance::isTransparent() const
{
        if (m_3DRep.isEmpty()) return false;
        if (m_RenderProperties.renderingMode() == glc::OverwriteTransparency) return true;
        if (m_RenderProperties.renderingMode() == glc::OverwriteMaterial)
        {
                return m_RenderProperties.overwriteMaterial()->isTransparent();
        }
        const int size= m_3DRep.numberOfBody();
        bool result= true;
        int i= 0;
        while((i < size) && result)
        {
                result= result && m_3DRep.geomAt(i)->isTransparent();
                ++i;
        }
        return result && m_RenderProperties.needToRenderWithTransparency();
}

// Return true if the instance contains mesh which contains transparent material
bool GLC_3DViewInstance::hasTransparentMaterials() const
{
        if (m_3DRep.isEmpty()) return false;
        if (m_RenderProperties.needToRenderWithTransparency()) return true;
        const int size= m_3DRep.numberOfBody();
        bool result= false;
        int i= 0;
        while ((i < size) && !result)
        {
                result= result || m_3DRep.geomAt(i)->hasTransparentMaterials();
                ++i;
        }
        return result;
}
bool GLC_3DViewInstance::setViewable(GLC_3DViewInstance::Viewable flag)
{
        const int bodyCount= m_3DRep.numberOfBody();
        if (bodyCount != m_ViewableGeomFlag.size())
        {
                m_ViewableGeomFlag.fill(true, bodyCount);
        }
        bool asChange= m_ViewableFlag != flag;
        if (asChange)
        {
                m_ViewableFlag= flag;
                if (flag != GLC_3DViewInstance::PartialViewable)
                {
                        bool viewable= (flag == GLC_3DViewInstance::FullViewable);

                        for (int i= 0; i < bodyCount; ++i)
                        {
                                m_ViewableGeomFlag[i]= viewable;
                        }
                }
        }
        return asChange;
}


#endif /*GLC_3DVIEWINSTANCE_H_*/