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)
 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_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_WindowHSize;}

        inline int viewVSize() const
        { return m_WindowVSize;}

        inline double aspectRatio() const
        { return static_cast<double>(m_WindowHSize) / static_cast<double>(m_WindowVSize);}

        GLC_Point2d normalyseMousePosition(int x, int y);

        GLC_Point2d mapToOpenGLScreen(int x, int y);

        GLC_Point2d mapNormalyzeToOpenGLScreen(double x, double y);

        GLC_Vector3d mapPosMouse( GLdouble Posx, GLdouble Posy) const;

        GLC_Vector3d mapNormalyzePosMouse(double Posx, double Posy) const;

        inline double viewAngle() const
        { return m_ViewAngle;}

        inline double viewTangent() const
        { return m_ViewTangent;}


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

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

        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_3DWidgetCollection;}

        inline bool useOrtho()const
        {return m_UseParallelProjection;}

        inline int minimumPixelCullingSize() const
        {return m_MinimumStaticPixelSize;}

        inline double minimumStaticPixelCullingRatio() const
        {return m_MinimumStaticRatioSize;}

        inline double minimumDynamicPixelCullingRatio() const
        {return m_MinimumDynamicRatioSize;}




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 renderImagePlane();

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_ViewAngle= TargetFov;
                m_ViewTangent= tan(glc::toRadian(m_ViewAngle));
                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 removeAllClipPlane();

        void useClipPlane(bool flag);

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

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

        void setToOrtho(bool useOrtho);

        inline void setMinimumPixelCullingSize(int size)
        {
                m_MinimumStaticPixelSize= size;
                updateMinimumRatioSize();
        }


//{@

        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);

        void updateMinimumRatioSize();


// Private Members
private:

        GLC_Camera *m_pViewCam;

        double m_DistanceMax;           
        double m_dDistanceMini;         
        double m_ViewAngle;             
        double m_ViewTangent;           


        GLC_ImagePlane* m_pImagePlane;

        // OpenGL View Definition
        int m_WindowHSize;                      
        int m_WindowVSize;                      

        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_ClipPlanesHash;

        bool m_UseClipPlane;

        GLC_3DViewCollection m_3DWidgetCollection;

        bool m_UseParallelProjection;

        int m_MinimumStaticPixelSize;

        double m_MinimumStaticRatioSize;

        double m_MinimumDynamicRatioSize;
};

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_