OGLCamera.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) 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 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) 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 Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
/*
 *
 *
 *
 *
 */
 
#ifndef __O_GLCAMERA__
#define __O_GLCAMERA__
 
#include "Tympan/core/smartptr.h"
#include <qmatrix4x4.h>
#include <qvector3d.h>
 
#if _WIN32
    #include <windows.h>
#endif //_WIN32
 
#include <GL/gl.h>
#include <GL/glu.h>
#include "NxVec3.h"
#include "Tympan/models/common/3d.h"
 
typedef enum
{
    PARALLEL,
    PERSPECTIVE,
    FREE
} CameraType;
 
class OGLCamera
{
 
public:
    OGLCamera(const QVector3D& _from, const QVector3D& _to, const QVector3D& _up, int w, int h,
              CameraType eCameraType);
    CameraType cameraType() const;
    void setCameraType(CameraType eCameraType);
    void moveFront();
    void moveBack();
    void moveUp();
    void moveDown();
    void moveLeft();
    void moveRight();
    void move(const QVector3D& _direction);
    void moveFront(NxReal _distance);
    void moveBack(NxReal _distance);
    void moveUp(NxReal _distance);
    void moveDown(NxReal _distance);
    void moveLeft(NxReal _distance);
    void moveRight(NxReal _distance);
    void setDistanceStep(NxReal _magnitudeStepUp, NxReal _magnitudeStepFront, NxReal _magnitudeStepLeft);
    void setAllAngleStep(NxReal _angle);
    void setAngleStep(NxReal _stepAngleUpDown, NxReal _stepAngleLeftRight, NxReal _stepAngleSide);
    const QVector3D& from() const;
    void setFrom(const QVector3D& _from);
    const QVector3D& to() const;
    void setTo(const QVector3D& _to);
    void setUp(const QVector3D& _up);
    void setFromToUp(const QVector3D& _from, const QVector3D& _to, const QVector3D& _up);
    const QVector3D& front() const;
    void setDistanceFromToLockFrom(NxReal _distanceFromTo);
    void setDistanceFromToLockTo(NxReal _distanceFromTo);
    void setModeLock(bool _modeLockUpDown, bool _modeLockLeftRight, bool _modeLockSide);
    void setSize(int w, int h);
    void calculateStepVectors();
    void zoom(double zoomFactor);
    void azimuth(NxReal _angle);
    void elevation(NxReal _angle);
    void roll(NxReal _angle);
    void resetZoom(int w = -1, int h = -1);
    void resetTranslation();
    void setTranslation(double x, double y, double z);
    void getTranslation(double& x, double& y, double& z);
    void resetRotations();
    void setDefaultZoomFactor(double defaultZoomFactor);
    void getPosition(double& x, double& y, double& z) const;
 
    const QMatrix4x4& viewMatrix() const;
    const QMatrix4x4& projectionMatrix() const;
 
private:
    QVector3D // points:
        _from,
        _to;
 
    // normalized vectors:
    QVector3D _up, _left, _front;
    // balanced vectors:
    QVector3D stepUp, stepLeft, stepFront, flyTo, flyFrom, flyFromTo, flyUp, flyLeft, flyFront;
    NxReal stepAngleUpDown, stepAngleLeftRight, stepAngleSide;
    // distance and vector from - to :
    NxReal distanceFromTo;
    QVector3D fromTo;
 
    bool modeLockUpDown, modeLockLeftRight, modeLockSide;
 
    NxReal magnitudeStepUp, magnitudeStepFront, magnitudeStepLeft;
 
    int m_w, m_h;
    double m_zoomFactor, m_defaultZoomFactor, m_angleAz, m_angleEl, m_angleRo;
    CameraType m_eCameraType;
    QVector3D m_translate;
 
    // Cached matrices
    mutable bool _viewMatrixDirty;
    mutable bool _projectionMatrixDirty;
    mutable QMatrix4x4 _viewMatrix;
    mutable QMatrix4x4 _projectionMatrix;
 
    void invalidateProjectionMatrix() const
    {
        _projectionMatrixDirty = true;
    }
    void invalidateViewMatrix() const
    {
        _viewMatrixDirty = true;
    }
 
    void updateProjectionMatrix() const;
    void updateViewMatrix() const;
};
 
// Smart pointer sur OGLCamera.
typedef SmartPtr<OGLCamera> LPOGLCamera;
 
#endif // __O_GLCAMERA__