OGLCamera.cpp

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/>.
 */
 
/*
 *
 */
 
#include "OGLCamera.h"
#include <qmatrix4x4.h>
#include <qvector3d.h>
 
#if _WIN32
    #include <math.h>
    #include <windows.h>
#endif //_WIN32
 
#ifndef MIN
    #define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
 
#ifndef MAX
    #define MAX(a, b) (((a) > (b)) ? (a) : (b))
#endif
 
OGLCamera::OGLCamera(const QVector3D& from, const QVector3D& to, const QVector3D& up, int w, int h,
                     CameraType eCameraType)
{
    m_w = w;
    m_h = h;
    setFromToUp(from, to, up);
    setAllAngleStep(0.1);
    setModeLock(false, false, false);
    m_zoomFactor = 1.0;
    m_eCameraType = eCameraType;
 
    switch (m_eCameraType)
    {
        case PARALLEL:
        {
            m_defaultZoomFactor = 0.29; // le facteur par defaut est pour un monde de 400 de MAX(larg,haut) et
                                        // un viewport 700 de MIN(larg,haut)
        }
        break;
        case PERSPECTIVE:
        {
            m_defaultZoomFactor = 0.5; // le facteur par defaut est pour un monde de 400 de MAX(larg,haut) et
                                       // un viewport 700 de MIN(larg,haut)
        }
        break;
        case FREE:
        {
            m_defaultZoomFactor = 1; // le facteur par defaut est pour un monde de 400 de MAX(larg,haut) et un
                                     // viewport 700 de MIN(larg,haut)
        }
        break;
    }
 
    m_angleAz = 0;
    m_angleEl = 0;
    m_angleRo = 0;
    m_translate = QVector3D(0, 0, 0);
    invalidateProjectionMatrix();
    invalidateViewMatrix();
}
 
void OGLCamera::setSize(int w, int h)
{
    m_w = w;
    m_h = h;
    invalidateProjectionMatrix();
}
 
void OGLCamera::setCameraType(CameraType eCameraType)
{
    m_eCameraType = eCameraType;
    invalidateProjectionMatrix();
    invalidateViewMatrix();
}
 
CameraType OGLCamera::cameraType() const
{
    return m_eCameraType;
}
 
void OGLCamera::move(const QVector3D& _direction)
{
    invalidateViewMatrix();
    _from += _direction;
    _to += _direction;
    calculateStepVectors();
}
 
void OGLCamera::moveFront()
{
    invalidateViewMatrix();
    if (m_eCameraType == FREE)
    {
        m_translate += stepFront;
        calculateStepVectors();
    }
    else
    {
        _from += stepFront;
        _to += stepFront;
    }
}
 
void OGLCamera::moveBack()
{
    invalidateViewMatrix();
    if (m_eCameraType == FREE)
    {
        m_translate -= stepFront;
        calculateStepVectors();
    }
    else
    {
        _from -= stepFront;
        _to -= stepFront;
    }
}
 
void OGLCamera::moveUp()
{
    invalidateViewMatrix();
    if (m_eCameraType == FREE)
    {
        m_translate += stepUp;
        calculateStepVectors();
    }
    else
    {
        _from += stepUp;
        _to += stepUp;
    }
}
 
void OGLCamera::moveDown()
{
    invalidateViewMatrix();
    if (m_eCameraType == FREE)
    {
        m_translate -= stepUp;
        calculateStepVectors();
    }
    else
    {
        _from -= stepUp;
        _to -= stepUp;
    }
}
 
void OGLCamera::moveLeft()
{
    invalidateViewMatrix();
    if (m_eCameraType == FREE)
    {
        m_translate += stepLeft;
        calculateStepVectors();
    }
    else
    {
        _from += stepLeft;
        _to += stepLeft;
    }
}
 
void OGLCamera::moveRight()
{
    invalidateViewMatrix();
    if (m_eCameraType == FREE)
    {
        m_translate -= stepLeft;
        calculateStepVectors();
    }
    else
    {
        _from -= stepLeft;
        _to -= stepLeft;
    }
}
 
void OGLCamera::moveUp(NxReal _distance)
{
    invalidateViewMatrix();
    _from += _up * _distance;
    _to += _up * _distance;
}
 
void OGLCamera::moveDown(NxReal _distance)
{
    invalidateViewMatrix();
    _from -= _up * _distance;
    _to -= _up * _distance;
}
 
void OGLCamera::moveFront(NxReal _distance)
{
    invalidateViewMatrix();
    _from += _front * _distance;
    _to += _front * _distance;
}
 
void OGLCamera::moveBack(NxReal _distance)
{
    invalidateViewMatrix();
    _from -= _front * _distance;
    _to -= _front * _distance;
}
 
void OGLCamera::moveLeft(NxReal _distance)
{
    invalidateViewMatrix();
    _from += _left * _distance;
    _to += _left * _distance;
}
 
void OGLCamera::moveRight(NxReal _distance)
{
    invalidateViewMatrix();
    _from -= _left * _distance;
    _to -= _left * _distance;
}
 
void OGLCamera::setDistanceStep(NxReal _magnitudeStepUp, NxReal _magnitudeStepFront,
                                NxReal _magnitudeStepLeft)
{
    stepUp /= magnitudeStepUp;
    magnitudeStepUp = _magnitudeStepUp;
    stepUp *= magnitudeStepUp;
    stepFront /= magnitudeStepFront;
    magnitudeStepFront = _magnitudeStepFront;
    stepFront *= magnitudeStepFront;
    stepLeft /= magnitudeStepLeft;
    magnitudeStepLeft = _magnitudeStepLeft;
    stepLeft *= magnitudeStepLeft;
}
 
void OGLCamera::setAllAngleStep(NxReal _angle)
{
    stepAngleUpDown = stepAngleLeftRight = stepAngleSide = _angle;
}
 
void OGLCamera::setAngleStep(NxReal _stepAngleUpDown, NxReal _stepAngleLeftRight, NxReal _stepAngleSide)
{
    stepAngleUpDown = _stepAngleUpDown;
    stepAngleLeftRight = _stepAngleLeftRight;
    stepAngleSide = _stepAngleSide;
}
 
const QVector3D& OGLCamera::from() const
{
    return _from;
}
 
void OGLCamera::setFrom(const QVector3D& from)
{
    invalidateViewMatrix();
    _to += from - _from;
    _from = from;
    calculateStepVectors();
}
 
const QVector3D& OGLCamera::to() const
{
    return _to;
}
 
void OGLCamera::setTo(const QVector3D& to)
{
    invalidateViewMatrix();
    _from += to - _to;
    _to = to;
    calculateStepVectors();
}
 
void OGLCamera::setUp(const QVector3D& up)
{
    invalidateViewMatrix();
    _up = up;
    calculateStepVectors();
}
 
void OGLCamera::setFromToUp(const QVector3D& from, const QVector3D& to, const QVector3D& up)
{
    invalidateViewMatrix();
    _from = from;
    _to = to;
    _up = up.normalized();
    _front = (_to - _from).normalized();
    fromTo = _to - _from;
    _left = QVector3D::crossProduct(_up, _front).normalized();
 
    distanceFromTo = fromTo.length();
    magnitudeStepUp = 1;
    magnitudeStepFront = 1;
    magnitudeStepLeft = 1;
    calculateStepVectors();
}
 
const QVector3D& OGLCamera::front() const
{
    return _front;
}
 
void OGLCamera::setDistanceFromToLockFrom(NxReal _distanceFromTo)
{
    invalidateViewMatrix();
    fromTo *= _distanceFromTo / distanceFromTo;
    distanceFromTo = _distanceFromTo;
    _to = _from + fromTo;
}
 
void OGLCamera::setDistanceFromToLockTo(NxReal _distanceFromTo)
{
    invalidateViewMatrix();
    fromTo *= _distanceFromTo / distanceFromTo;
    distanceFromTo = _distanceFromTo;
    _from = _to - fromTo;
}
 
void OGLCamera::setModeLock(bool _modeLockUpDown, bool _modeLockLeftRight, bool _modeLockSide)
{
    modeLockUpDown = _modeLockUpDown;
    modeLockLeftRight = _modeLockLeftRight;
    modeLockSide = _modeLockSide;
}
 
void OGLCamera::calculateStepVectors()
{
    if (m_eCameraType != FREE)
    {
        double dist = _from.distanceToPoint(QVector3D(0, 0, 0));
        stepLeft = _left * magnitudeStepLeft * ((dist + 1) / 1000);
        stepFront = _front * magnitudeStepFront * ((dist + 1) / 1000);
        stepUp = _up * magnitudeStepUp * ((dist + 1) / 1000);
    }
    else
    {
        flyTo = _to + m_translate;
        flyFrom = _from + m_translate;
        flyFromTo = flyTo - flyFrom;
        flyUp = _up; // + m_translate;
        flyFront = QVector3D(flyTo - flyFrom).normalized();
 
        flyLeft = QVector3D::crossProduct(flyUp, flyFront).normalized();
        QMatrix4x4 rotationAzimuth;
        rotationAzimuth.rotate(m_angleAz, flyUp);
        flyLeft = rotationAzimuth.mapVector(flyLeft);
        flyFront = rotationAzimuth.mapVector(flyFront);
        QMatrix4x4 rotationElevation;
        rotationElevation.rotate(m_angleEl, flyLeft);
        flyFront = rotationElevation.mapVector(flyFront);
 
        stepLeft = flyLeft * magnitudeStepLeft;
        stepFront = flyFront * magnitudeStepFront;
        stepUp = flyUp * magnitudeStepUp;
    }
}
 
void OGLCamera::zoom(double zoomFactor)
{
    if (m_eCameraType != PARALLEL)
    {
        invalidateViewMatrix();
        calculateStepVectors();
        if (zoomFactor < 1)
        {
            moveFront();
        }
        else
        {
            moveBack();
        }
        calculateStepVectors();
    }
    else
    {
        invalidateProjectionMatrix();
        m_zoomFactor *= zoomFactor;
    }
}
 
void OGLCamera::azimuth(NxReal _angle)
{
    invalidateViewMatrix();
    m_angleAz += (_angle * 500);
    calculateStepVectors();
}
 
void OGLCamera::elevation(NxReal _angle)
{
    invalidateViewMatrix();
    m_angleEl += (_angle * 500);
    calculateStepVectors();
}
 
void OGLCamera::roll(NxReal _angle)
{
    invalidateViewMatrix();
    m_angleRo += _angle;
    calculateStepVectors();
}
 
void OGLCamera::resetZoom(int w /*= -1*/, int h /*= -1*/)
{
    invalidateProjectionMatrix();
    invalidateViewMatrix();
    if ((w <= 0) && (h <= 0))
    {
        m_zoomFactor = m_defaultZoomFactor;
    }
    else
    {
        double minSizeViewport = MIN(m_w, m_h);
        double maxSizeBoundingBox = MAX(w, h);
 
        if (m_eCameraType == PARALLEL)
        {
            m_zoomFactor = m_defaultZoomFactor * (maxSizeBoundingBox / 400) * (700 / minSizeViewport);
        }
        else
        {
            QVector3D fromPersp(
                0, 1000 * (maxSizeBoundingBox / 400) * (700 / minSizeViewport) * m_defaultZoomFactor,
                1000 * (maxSizeBoundingBox / 400) * (700 / minSizeViewport) * m_defaultZoomFactor);
            setFromToUp(fromPersp, _to, _up);
        }
    }
    m_translate = QVector3D(0, 0, 0);
    calculateStepVectors();
}
 
void OGLCamera::resetTranslation()
{
    invalidateViewMatrix();
    m_translate = QVector3D(0, 0, 0);
    calculateStepVectors();
}
 
void OGLCamera::setDefaultZoomFactor(double defaultZoomFactor)
{
    m_defaultZoomFactor = defaultZoomFactor;
}
 
void OGLCamera::resetRotations()
{
    invalidateViewMatrix();
    m_angleAz = 0;
    m_angleEl = 0;
    m_angleRo = 0;
    calculateStepVectors();
}
 
void OGLCamera::setTranslation(double x, double y, double z)
{
    invalidateViewMatrix();
    m_translate = QVector3D(x, y, z);
    calculateStepVectors();
}
 
void OGLCamera::getTranslation(double& x, double& y, double& z)
{
    x = m_translate.x();
    y = m_translate.y();
    z = m_translate.z();
}
 
void OGLCamera::getPosition(double& x, double& y, double& z) const
{
    x = _from.x();
    y = _from.y();
    z = _from.z();
    if (m_angleAz != 0)
    {
        double d = _from.z(); // from.magnitude();
        x = d * sin(m_angleAz * M_PI / 180.0f);
        z = d * cos(m_angleAz * M_PI / 180.0f);
    }
 
    x += m_translate.x();
    y += m_translate.y();
    z += m_translate.z();
}
 
void OGLCamera::updateViewMatrix() const
{
    _viewMatrix.setToIdentity();
    _viewMatrix.lookAt(_from, _to, _up);
    switch (m_eCameraType)
    {
        case PARALLEL:
            break;
        case PERSPECTIVE:
        {
            // Roll
            _viewMatrix.rotate(m_angleRo, _front);
            // Elevation
            QVector3D elevationVector = QVector3D::crossProduct(_up, fromTo);
            _viewMatrix.rotate(-m_angleEl, elevationVector); /* orbit the UP axis */
            // Azhimut
            _viewMatrix.rotate(-m_angleAz, _up); /* orbit the UP axis */
        }
        break;
        case FREE:
        {
            _viewMatrix.translate(-flyFromTo);
 
            // Roll
            _viewMatrix.rotate(m_angleRo, _front);
            // Elevation
            QVector3D elevationVector = QVector3D::crossProduct(_up, fromTo);
            _viewMatrix.rotate(-m_angleEl, elevationVector); /* orbit the UP axis */
            // Azhimut
            _viewMatrix.rotate(-m_angleAz, _up); /* orbit the UP axis */
 
            _viewMatrix.translate(flyFromTo);
            _viewMatrix.translate(-m_translate);
        }
        break;
    }
    _viewMatrixDirty = false;
}
 
void OGLCamera::updateProjectionMatrix() const
{
    _projectionMatrix.setToIdentity();
    switch (m_eCameraType)
    {
        case PARALLEL:
            _projectionMatrix.ortho(-m_w * m_zoomFactor, m_w * m_zoomFactor, -m_h * m_zoomFactor,
                                    m_h * m_zoomFactor, 1, 20000);
            break;
        case PERSPECTIVE:
            _projectionMatrix.perspective(30 * m_zoomFactor, (double)m_w / m_h, 10,
                                          50000); // Initialement 1, 50000
            break;
        case FREE:
            _projectionMatrix.perspective(30 * m_zoomFactor, (double)m_w / m_h, 1,
                                          5000); // Initialement 1, 50000
            break;
    }
    _projectionMatrixDirty = false;
}
 
const QMatrix4x4& OGLCamera::viewMatrix() const
{
    if (_viewMatrixDirty)
    {
        updateViewMatrix();
    }
    return _viewMatrix;
}
 
const QMatrix4x4& OGLCamera::projectionMatrix() const
{
    if (_projectionMatrixDirty)
    {
        updateProjectionMatrix();
    }
    return _projectionMatrix;
}