glc_viewport.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_VIEWPORT_H_
#define GLC_VIEWPORT_H_
#include <QGLWidget>
#include <QPair>
#include <QHash>
#include "glc_camera.h"
#include "glc_imageplane.h"
#include "../glc_boundingbox.h"
#include "glc_frustum.h"
#include "../maths/glc_plane.h"
#include "../sceneGraph/glc_3dviewcollection.h"

#include "../glc_config.h"

class GLC_3DViewInstance;



class GLC_LIB_EXPORT GLC_Viewport
{



public:

        GLC_Viewport(QGLWidget *GLWidget);

        virtual ~GLC_Viewport();




public:
        inline GLC_Camera* cameraHandle() const
        {return m_pViewCam;}

        inline int viewHSize() const
        { return m_nWinHSize;}

        inline int viewVSize() const
        { return m_nWinVSize;}

        inline double aspectRatio() const
        { return static_cast<double>(m_nWinHSize) / static_cast<double>(m_nWinVSize);}

        GLC_Vector3d mapPosMouse( GLdouble Posx, GLdouble Posy) const;

        inline double viewAngle() const
        { return m_dFov;}

        inline double viewTangent() const
        { return m_ViewTangent;}


        inline double nearClippingPlaneDist(void) const
        { return m_dCamDistMin;}

        inline double farClippingPlaneDist(void) const
        { return m_dCamDistMax;}

        inline QColor backgroundColor(void) const
        { return m_BackgroundColor;}

        inline GLsizei selectionSquareSize() const
        {return m_SelectionSquareSize;}

        inline GLC_Matrix4x4 projectionMatrix() const
        {return m_ProjectionMatrix;}

        inline GLC_Matrix4x4 compositionMatrix() const;

        inline GLC_3DViewCollection* widget3dCollectionHandle()
        {return &m_3DWidget;}

        inline bool useOrtho()const
        {return m_UseOrtho;}




public:

        void initGl();

        void glExecuteCam(void);

        void updateProjectionMat(void);

        void forceAspectRatio(double);

        void updateAspectRatio();

        const GLC_Frustum& frustum() const
        {return m_Frustum;}

        GLC_Frustum selectionFrustum(int, int) const;

        GLC_Point3d unProject(int, int) const;


        QList<GLC_Point3d> unproject(const QList<int>&)const;

        inline QGLWidget* qGLWidgetHandle()
        {return m_pQGLWidget;}




private:

        void glExecuteImagePlane();

public:

        void render3DWidget();




public:

        void setWinGLSize(int HSize, int VSize);


        GLC_uint renderAndSelect(int x, int y);

        GLC_uint selectOnPreviousRender(int x, int y);


        GLC_uint selectBody(GLC_3DViewInstance*, int x, int y);


        QPair<int, GLC_uint> selectPrimitive(GLC_3DViewInstance*, int x, int y);

        QSet<GLC_uint> selectInsideSquare(int x1, int y1, int x2, int y2);

        void loadBackGroundImage(const QString& imageFile);

        void loadBackGroundImage(const QImage& image);

        void deleteBackGroundImage();

        inline void setViewAngle(double TargetFov)
        {
                m_dFov= TargetFov;
                m_ViewTangent= tan(glc::toRadian(m_dFov));
                updateProjectionMat();
        }

        bool setDistMin(double DistMin);

        bool setDistMax(double DistMax);


        void setDistMinAndMax(const GLC_BoundingBox& bBox);

        void setBackgroundColor(QColor setColor);

        inline void setSelectionSquareSize(GLsizei size)
        {m_SelectionSquareSize= size;}


        inline bool updateFrustum(GLC_Matrix4x4* pMat= NULL);

        void addClipPlane(GLenum planeGlEnum, GLC_Plane* pPlane);

        void removeClipPlane(GLenum planeGlEnum);

        void useClipPlane(bool flag);

        inline void add3DWidget(GLC_3DViewInstance& widget)
        {m_3DWidget.add(widget);}

        inline void clearBackground(const QColor& c) const
        {m_pQGLWidget->qglClearColor(c);}

        void setToOrtho(bool useOrtho);


//{@

        void reframe(const GLC_BoundingBox& box);



// private services functions
private:
        GLC_uint meaningfulIdInsideSquare(GLint x, GLint y, GLsizei width, GLsizei height);

        QSet<GLC_uint> listOfIdInsideSquare(GLint x, GLint y, GLsizei width, GLsizei height);


// Private Members
private:

        GLC_Camera *m_pViewCam;

        double m_dCamDistMax;           
        double m_dCamDistMin;           
        double m_dFov;                          
        double m_ViewTangent;           


        GLC_ImagePlane* m_pImagePlane;

        // OpenGL View Definition
        int m_nWinHSize;                        
        int m_nWinVSize;                        

        double m_AspectRatio;

        QGLWidget* m_pQGLWidget;

        QColor m_BackgroundColor;

        GLsizei m_SelectionSquareSize;

        GLC_Matrix4x4 m_ProjectionMatrix;

        GLC_Frustum m_Frustum;

        QHash<GLenum, GLC_Plane*> m_ClipPlane;

        bool m_UseClipPlane;

        GLC_3DViewCollection m_3DWidget;

        bool m_UseOrtho;
};

GLC_Matrix4x4 GLC_Viewport::compositionMatrix() const
{
        // Get the viewport projection matrix
        GLC_Matrix4x4 projectionMatrix= m_ProjectionMatrix;
        // Get the camera modelView matrix
        GLC_Matrix4x4 modelViewMatrix= m_pViewCam->modelViewMatrix();
        // Composition matrix
        GLC_Matrix4x4 compMatrix= projectionMatrix * modelViewMatrix;

        return compMatrix;
}

bool GLC_Viewport::updateFrustum(GLC_Matrix4x4* pMat)
{
        if (NULL == pMat)
        {
                return m_Frustum.update(compositionMatrix());
        }
        else
        {
                return m_Frustum.update(*pMat);
        }
}
#endif //GLC_VIEWPORT_H_