TYRenderWindow.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 "Tympan/models/business/OLocalizator.h"
#include "Tympan/gui/tools/OGLTextElement.h"
#include "Tympan/gui/app/TYApplication.h"
#include <qglobal.h>
#include <qmatrix4x4.h>
#include <qopengldebug.h>
#include <qopenglwidget.h>
#include <qpoint.h>
#include <qsurfaceformat.h>
#include <qtextstream.h>
#include <qvector3d.h>
#include "TYRenderWindow.h"
#include "gui/app/TYModelerFrame.h"
#include "Tympan/gui/gl/TYRenderContext.h"
#include "Tympan/gui/gl/TYRenderViewport.h"
 
#define IMG(id) OLocalizator::getPicture("TYRenderWindow", (id))
 
TYRenderWindow::TYRenderWindow(QWidget* parent, const char* name)
    : QOpenGLWidget(parent), _cachedViewport(nullptr, QRect())
{
    _viewportNeedsUpdate = true;
    // The cached viewport is initially invalid but getViewport will eventually set it to a valid value
    setObjectName(name);
    initRenderWindow();
}
 
void TYRenderWindow::initRenderWindow()
{
    _initNeeded = true;
    _showInfos = false;
 
    // Ensure that the widget's opengl context has debugging enabled
    QSurfaceFormat debugFormat(format());
    debugFormat.setMajorVersion(4);
    debugFormat.setMinorVersion(3);
    debugFormat.setProfile(QSurfaceFormat::CompatibilityProfile);
    debugFormat.setOptions(QSurfaceFormat::DebugContext | QSurfaceFormat::DeprecatedFunctions);
    setFormat(debugFormat);
 
    _pGLLogger = new QOpenGLDebugLogger(context());
    connect(_pGLLogger, &QOpenGLDebugLogger::messageLogged, this, &TYRenderWindow::handleLoggedMessage);
 
    _pRenderer = new TYOpenGLRenderer();
 
    // Label info
    OColor oColor;
    _pOGLTextInfoLabel = new OGLTextElement();
    _pOGLTextInfoLabel->setTextToDisplay("");
    oColor.r = oColor.g = oColor.b = 0.5;
    _pOGLTextInfoLabel->setColor(oColor);
    _pOGLTextInfoLabel->setFont(IMG("id_font"));
    _pOGLTextInfoLabel->setDisplayPosition(10, 10);
    _pOGLTextInfoLabel->setVisibility(false);
    getRenderer()->addOGLElement(_pOGLTextInfoLabel);
 
    // just enable one double buffering
    // by default, we use the one of vtk
    /*#ifdef QT_DOUBLEBUFFER
      // use the double buffering of QT
      _pRenderWindow->SetSwapBuffers(0);
    #else
      // use the double buffering of vtk
      setAutoBufferSwap(false);
    #endif*/
 
    // Gestion du focus
    setFocusProxy(parentWidget());
}
 
TYRenderWindow::~TYRenderWindow()
{
    makeCurrent();
    delete _pGLLogger;
    delete _pOGLTextInfoLabel;
    //_pInfoLabelMapper->Delete();
    delete _pRenderer; // az++
    doneCurrent();
}
 
TYOpenGLRenderer* TYRenderWindow::getRenderer()
{
    return _pRenderer;
}
 
void TYRenderWindow::showInfos(bool state)
{
    _showInfos = state;
    _pOGLTextInfoLabel->setVisibility(state);
 
    //  if (!_showInfos) {
    //      _pInfoLabelMapper->SetInput("");
    //  }
 
    update();
}
 
void TYRenderWindow::initializeGL()
{
    _pGLLogger->initialize();
 
    if (!qEnvironmentVariableIsSet("TYMPAN_DEBUG_OPENGL_ALL_MESSAGES"))
    {
        // Only show errors by default
        _pGLLogger->disableMessages();
        _pGLLogger->enableMessages(QOpenGLDebugMessage::AnySource, QOpenGLDebugMessage::ErrorType);
    }
 
    if (qEnvironmentVariableIsSet("TYMPAN_DEBUG_OPENGL_SYNC"))
    {
        _pGLLogger->startLogging(QOpenGLDebugLogger::SynchronousLogging);
    }
    else
    {
        _pGLLogger->startLogging(QOpenGLDebugLogger::AsynchronousLogging);
    }
    _pRenderer->initializeGL();
}
 
void TYRenderWindow::resizeGL(int w, int h)
{
    _viewportNeedsUpdate = true;
    _pActiveCamera->setSize(width() * devicePixelRatioF(), height() * devicePixelRatioF());
}
 
void TYRenderWindow::paintGL()
{
    _pRenderer->init();
 
    clock_t timeBefore = clock();
    TYModelerFrame* modelerFrame = (TYModelerFrame*)parent();
    TYRenderContext renderContext = {
        TYRenderType::Display,
        TYRenderPass::Default,
        getViewport(),
        modelerFrame->getElement(),
    };
    _pRenderer->OpenGLRender(renderContext);
    clock_t timeAfter = clock();
 
    double timeElaspedInSec = ((double)(timeAfter - timeBefore)) / (double)CLOCKS_PER_SEC;
 
    if (_showInfos)
    {
        writeOutputMsg(QString("FPS = %1").arg(1.0 / timeElaspedInSec, 0, 'f', 2));
        _pOGLTextInfoLabel->setTextToDisplay(QString("FPS = %1").arg(1.0 / timeElaspedInSec, 0, 'f', 2));
    }
}
 
const TYRenderViewport& TYRenderWindow::getViewport() const
{
    if (_viewportNeedsUpdate)
    {
        _cachedViewport = TYRenderViewport(
            _pActiveCamera, QRect(0, 0, width() * devicePixelRatioF(), height() * devicePixelRatioF()));
        _viewportNeedsUpdate = false;
    }
    return _cachedViewport;
}
 
QPoint TYRenderWindow::toViewport(QPoint point)
{
    return point * devicePixelRatioF();
}
 
static inline const char* printableDebugMessageSource(QOpenGLDebugMessage::Source source)
{
    switch (source)
    {
        case QOpenGLDebugMessage::APISource:
            return "API";
        case QOpenGLDebugMessage::WindowSystemSource:
            return "Window system";
        case QOpenGLDebugMessage::ShaderCompilerSource:
            return "Shader compiler";
        case QOpenGLDebugMessage::ThirdPartySource:
            return "Third party";
        case QOpenGLDebugMessage::ApplicationSource:
            return "Application";
        case QOpenGLDebugMessage::OtherSource:
            return "Other";
        case QOpenGLDebugMessage::AnySource:
        case QOpenGLDebugMessage::InvalidSource:
        default:
            return ""; // Shouldn't happen
    }
}
 
static inline const char* printableDebugMessageType(QOpenGLDebugMessage::Type messageType)
{
    switch (messageType)
    {
        case QOpenGLDebugMessage::ErrorType:
            return "Error";
        case QOpenGLDebugMessage::DeprecatedBehaviorType:
            return "Deprecated behavior";
        case QOpenGLDebugMessage::UndefinedBehaviorType:
            return "Undefined behavior";
        case QOpenGLDebugMessage::PortabilityType:
            return "Portability";
        case QOpenGLDebugMessage::PerformanceType:
            return "Performance";
        case QOpenGLDebugMessage::MarkerType:
            return "Marker";
        case QOpenGLDebugMessage::GroupPushType:
            return "Group Push";
        case QOpenGLDebugMessage::GroupPopType:
            return "Group Pop";
        case QOpenGLDebugMessage::OtherType:
            return "Other";
        case QOpenGLDebugMessage::InvalidType:
        case QOpenGLDebugMessage::AnyType:
        default:
            return ""; // Shouldn't happen
    }
}
 
static inline const char* printableDebugMessageSeverity(QOpenGLDebugMessage::Severity severity)
{
    switch (severity)
    {
        case QOpenGLDebugMessage::HighSeverity:
            return "High";
        case QOpenGLDebugMessage::MediumSeverity:
            return "Medium";
        case QOpenGLDebugMessage::LowSeverity:
            return "Low";
        case QOpenGLDebugMessage::NotificationSeverity:
            return "Notification";
        case QOpenGLDebugMessage::InvalidSeverity:
        case QOpenGLDebugMessage::AnySeverity:
        default:
            return ""; // Shouldn't happen
    }
}
 
static const char* OGL_DEBUG_MESSAGE_FORMAT = "OpenGL message\n"
                                              "==============\n"
                                              "Type = %1\n"
                                              "Source = %2\n"
                                              "Severity = %3\n"
                                              "Message = %4\n";
 
void TYRenderWindow::handleLoggedMessage(QOpenGLDebugMessage message)
{
    QString output = QString(OGL_DEBUG_MESSAGE_FORMAT)
                         .arg(printableDebugMessageType(message.type()))
                         .arg(printableDebugMessageSource(message.source()))
                         .arg(printableDebugMessageSeverity(message.severity()))
                         .arg(message.message());
    QTextStream(stdout) << output << Qt::endl;
}