TYOpenGLRenderer.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/TYProjet.h"
#include "Tympan/models/business/geometry/TYGeometryNode.h"
#include <cstdio>
#include <qmatrix4x4.h>
#include <qopenglbuffer.h>
#include <qopenglcontext.h>
#include <qopenglfunctions_4_3_core.h>
#include <qopenglshaderprogram.h>
#include <qopenglvertexarrayobject.h>
#include <qtransform.h>
#include <qvector3d.h>
#include <stdexcept>
 
#include "TYOpenGLRenderer.h"
#include "Tympan/gui/gl/TYRenderContext.h"
#include "gui/gl/TYElementGraphic.h"
#include "gui/tools/OGLBoxMesh.h"
#include "gui/tools/OGLSimpleMaterial.h"
#include "gui/tools/OGLShaderManager.h"
 
#if TY_USE_IHM
    #include "Tympan/gui/gl/TYGeometryNodeGraphic.h"
    #include <QOpenGLFunctions_4_3_Core>
#endif
 
void drawBoundingBox(const QVector3D& boxDimensions, QOpenGLShaderProgram* shaderProgram,
                     const QMatrix4x4& model, const QMatrix4x4& view, const QMatrix4x4& projection)
{
    QOpenGLFunctions_4_3_Core gl;
    gl.initializeOpenGLFunctions();
    OGLBoxMesh bboxMesh(boxDimensions);
    bboxMesh.setMaterial(OGLSimpleMaterial::BOUNDING_BOX);
 
    QOpenGLBuffer vbo(QOpenGLBuffer::VertexBuffer);
    vbo.create();
    vbo.bind();
    vbo.allocate(bboxMesh.vertices().data(), bboxMesh.vertices().size() * sizeof(QVector3D));
 
    QOpenGLVertexArrayObject vao;
    vao.create();
    vao.bind();
 
    int vertexLocation = shaderProgram->attributeLocation("pos");
    shaderProgram->enableAttributeArray(vertexLocation);
    shaderProgram->setAttributeBuffer(vertexLocation, GL_FLOAT, 0, 3, 0);
 
    int modelLocation = shaderProgram->uniformLocation("model");
    shaderProgram->setUniformValue(modelLocation, model);
    int viewLocation = shaderProgram->uniformLocation("view");
    shaderProgram->setUniformValue(viewLocation, view);
    int projectionLocation = shaderProgram->uniformLocation("projection");
    shaderProgram->setUniformValue(projectionLocation, projection);
 
    int colorLocation = shaderProgram->uniformLocation("color");
    QColor color = bboxMesh.material().color;
    QVector3D vectorColor = QVector3D(color.redF(), color.greenF(), color.blueF());
    shaderProgram->setUniformValue(colorLocation, vectorColor);
 
    QOpenGLBuffer indexBuffer(QOpenGLBuffer::IndexBuffer);
    indexBuffer.create();
    indexBuffer.bind();
    indexBuffer.allocate(bboxMesh.indices().data(), bboxMesh.indices().size() * sizeof(unsigned int));
 
    gl.glDrawElements(GL_LINES, 24, GL_UNSIGNED_INT, 0);
    gl.glDrawArrays(GL_POINTS, 0, 8);
    indexBuffer.release(QOpenGLBuffer::IndexBuffer);
    indexBuffer.destroy();
    vbo.release(QOpenGLBuffer::VertexBuffer);
    vbo.destroy();
    vao.release();
    vao.destroy();
}
 
TYOpenGLRenderer::TYOpenGLRenderer() // az++
{
    _displayList = 0;        // az++
    _displayListOverlay = 0; // az++
    _pActiveCamera = nullptr;
    _pBackgroundColor = new double[3];
    m_renderType = 0;
    _sceneRenderCacheIsDirty = true;
 
    _boundingBoxScaleMatrix = QMatrix4x4();
    _boundingBoxScaleMatrix.scale(1.1);
}
 
TYOpenGLRenderer::~TYOpenGLRenderer() // az++
{
    if (_displayList) // az++
    {
        glDeleteLists(_displayList, 1);
    }
    if (_displayListOverlay) // az++
    {
        glDeleteLists(_displayListOverlay, 1);
    }
    delete[] _pBackgroundColor;
}
 
void TYOpenGLRenderer::initializeGL()
{
    _displayList = glGenLists(1);
    _displayListOverlay = glGenLists(1);
}
 
void TYOpenGLRenderer::init()
{
    //  glClearColor(1.0, 1.0, 1.0, 1.0);
    glClearColor(_pBackgroundColor[0], _pBackgroundColor[1], _pBackgroundColor[2], 1.0);
    glColor3f(1.0, 0.0, 0.0);
 
    if (_renderMode == TYOpenGLRenderer::Points)
    {
        glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
    }
    else if (_renderMode == TYOpenGLRenderer::Wireframe)
    {
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    }
    else if (_renderMode == TYOpenGLRenderer::Surface)
    {
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    }
    else if (_renderMode == TYOpenGLRenderer::Flat)
    {
        glShadeModel(GL_FLAT);
    }
    else if (_renderMode == TYOpenGLRenderer::Gouraud)
    {
        glShadeModel(GL_SMOOTH);
    }
 
    // Lights
    glEnable(GL_LIGHTING);
    glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
 
    static GLfloat ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};
    static GLfloat ambientBIS[] = {0.8f, 0.8f, 0.8f, 0.8f};
    static GLfloat diffuse[] = {0.8f, 0.8f, 0.8f, 1.0f};
    static GLfloat specular[] = {0.8f, 0.8f, 0.8f, 1.0f};
    static GLfloat shininess = 50.;
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientBIS);
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
}
 
void TYOpenGLRenderer::setRenderMode(TYOpenGLRenderer::RenderMode mode)
{
    _renderMode = mode;
}
 
TYOpenGLRenderer::RenderMode TYOpenGLRenderer::getRenderMode()
{
    return _renderMode;
}
 
void TYOpenGLRenderer::updateDisplayListOverlay(TYRenderContext& renderContext, TYGeometryNode* pElement,
                                                TYGeometryNode* pDansCeRepere)
{
    if (pElement)
    {
        // Chercher le GeoNode correspondant a pElement (le repere dans lequel est exprime pElement)
        TYGeometryNode* pGeoNode = pElement;
        if (pElement->isA("TYGeometryNode"))
        {
            pGeoNode = (TYGeometryNode*)pElement;
        }
        else
        {
            pGeoNode = (TYGeometryNode*)pElement->GetGeoNodeParent();
        }
 
        if (pGeoNode)
        {
            LPTYElementGraphic pTYElementGraphic = pGeoNode->getGraphicObject();
            TYGeometryNodeGraphic* pGeoNodeGraphic =
                (TYGeometryNodeGraphic*)pTYElementGraphic.getRealPointer();
            pGeoNodeGraphic->displayPushingParentMatrix(renderContext, pDansCeRepere);
        }
    }
}
 
void TYOpenGLRenderer::invalidateScene(void)
{
    _sceneRenderCacheIsDirty = true;
}
 
void TYOpenGLRenderer::_renderScene(TYRenderContext& renderContext) const
{
    if (!_sceneRenderCacheIsDirty) // az++
    {
        glCallList(_displayList);
        return;
    }
    else
    {
        // Affectation de la displayList principale:
        glNewList(_displayList, GL_COMPILE_AND_EXECUTE);
        drawElement(renderContext);
        glEndList();
        _sceneRenderCacheIsDirty = false;
    }
}
 
void TYOpenGLRenderer::OpenGLRender(TYRenderContext& renderContext, int x /* = 0*/, int y /* = 0*/)
{
    GLint polygon_mode[2];
    glGetIntegerv(GL_POLYGON_MODE, polygon_mode);
 
    // do the render library specific stuff
    const OGLCamera* currentCamera = renderContext.viewport.camera();
    if (currentCamera)
    {
        glMatrixMode(GL_PROJECTION);
        glLoadMatrixf(currentCamera->projectionMatrix().constData());
        glMatrixMode(GL_MODELVIEW);
        glLoadMatrixf(currentCamera->viewMatrix().constData());
    }
 
    // set matrix mode for actors
    glMatrixMode(GL_MODELVIEW);
 
    // Gestion des lumieres
    if (currentCamera)
    {
        // place la lumiere 0 sur la camera
        double xc, yc, zc;
        currentCamera->getPosition(xc, yc, zc);
        _tabLights[0]->setPosition(OPoint3D(xc, yc, zc));
    }
    for (int il = 0; il < _tabLights.size(); il++)
    {
        _tabLights[il]->render();
    }
 
    // Materials
    float colorSpec[] = {0.0, 0.0, 0.0, 1.0};
    float colorShine[] = {127.0};
    glMaterialfv(GL_FRONT, GL_SPECULAR, colorSpec);
    glMaterialfv(GL_FRONT, GL_SHININESS, colorShine);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    glEnable(GL_COLOR_MATERIAL);
 
    // Antialiasing
    glEnable(GL_LINE_SMOOTH);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
 
    glEnable(GL_NORMALIZE);
    glEnable(GL_DEPTH_TEST);
    glDepthRange(0, 1);
 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    if (renderContext.type == TYRenderType::Picking)
    {
        GLint viewport[4];
        GLfloat proj[16];
 
        glGetFloatv(GL_PROJECTION_MATRIX, proj);
 
        glGetIntegerv(GL_VIEWPORT, viewport);
 
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        gluPickMatrix((GLdouble)x, (GLdouble)y, 5, 5, viewport);
        glMultMatrixf(proj);
 
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        drawElement(renderContext);
        glPopMatrix();
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
    }
    else /* renderType == TYOpenGLRenderer::DisplayRenderer */
    {
        // CLM-NT35: Init la liste avant d'ajouter les elements
        // display overlay text for selected elements (localized)
        TYRenderContext overlayRenderContext = {renderContext.type, TYRenderPass::Overlay,
                                                renderContext.viewport, renderContext.modelerElement};
        glNewList(_displayListOverlay, GL_COMPILE);
        std::vector<TYElement*>::iterator iterElements;
        for (iterElements = _tabSelectedElements.begin(); iterElements < _tabSelectedElements.end();
             iterElements++)
        {
            TYGeometryNode* pGeoNode = TYGeometryNode::GetGeoNode(*iterElements);
            TYGeometryNode* pRootGeometryNode = TYGeometryNode::GetGeoNode(renderContext.modelerElement);
            // For elements without GeoNode like TYPointControl, display in GL_COMPILE mode the
            // correponding graphic object
            if (!pGeoNode)
            {
                if (*iterElements != nullptr)
                {
                    LPTYElementGraphic pTYElementGraphic = (*iterElements)->getGraphicObject();
                    if (pTYElementGraphic != nullptr)
                    {
                        pTYElementGraphic->display(overlayRenderContext);
                    }
                }
            }
            updateDisplayListOverlay(overlayRenderContext, pGeoNode, pRootGeometryNode);
        }
        glEndList();
    }
 
    glMatrixMode(GL_MODELVIEW);
    if (renderContext.type == TYRenderType::Display)
    {
        glPushMatrix();
        _renderScene(renderContext);
        glCallList(_displayListOverlay);
        renderBoundingBoxes(renderContext);
        glPopMatrix();
    }
 
    // render the TYAtcor2D list
    glDisable(GL_LIGHTING);
    std::vector<OGLElement*>::iterator iter;
    for (iter = _tabOGLElement.begin(); iter < _tabOGLElement.end(); iter++)
    {
        glPushMatrix();
        (*iter)->render();
        glPopMatrix();
    }
 
    glPolygonMode(GL_FRONT_AND_BACK, polygon_mode[0]);
}
 
void TYOpenGLRenderer::drawElement(TYRenderContext& renderContext) const
{
    LPTYElementGraphic pGraphObj = NULL;
    if (renderContext.modelerElement)
    {
        pGraphObj = renderContext.modelerElement->getGraphicObject();
 
        if (dynamic_cast<TYSiteNode*>(renderContext.modelerElement) != nullptr)
        {
            TYElement* pParent = renderContext.modelerElement->getParent();
            if (pParent && pParent->isA("TYProjet"))
            {
                pGraphObj = pParent->getGraphicObject();
            }
        }
 
        glRotatef(-90.0, 1.0, 0.0, 0.0);
        if (pGraphObj)
        {
            pGraphObj->display(renderContext);
        }
    }
}
 
void TYOpenGLRenderer::addOGLElement(OGLElement* pOGLElement)
{
    bool _bFinded = false;
    std::vector<OGLElement*>::iterator iter;
    for (iter = _tabOGLElement.begin(); !_bFinded && (iter < _tabOGLElement.end()); iter++)
    {
        if ((OGLElement*)(*iter) == pOGLElement)
        {
            _bFinded = true;
        }
    }
    if (!_bFinded)
    {
        _tabOGLElement.push_back(pOGLElement);
    }
}
 
void TYOpenGLRenderer::addLight(OGLLightElement* pOGLElement)
{
    _tabLights.push_back(pOGLElement);
}
 
void TYOpenGLRenderer::removeLights()
{
    _tabLights.clear();
}
 
std::vector<OGLLightElement*> TYOpenGLRenderer::getLights()
{
    return _tabLights;
}
 
void TYOpenGLRenderer::removeOGLElement(OGLElement* pOGLElement)
{
    std::vector<OGLElement*>::iterator iter;
    bool _bFinded = false;
    for (iter = _tabOGLElement.begin(); !_bFinded && (iter < _tabOGLElement.end()); iter++)
    {
        if ((OGLElement*)(*iter) == pOGLElement)
        {
            _bFinded = true;
            _tabOGLElement.erase(iter);
            break;
        }
    }
}
 
void TYOpenGLRenderer::addSelectedElement(TYElement* pElement)
{
    bool _bFinded = false;
    std::vector<TYElement*>::iterator iter;
    for (iter = _tabSelectedElements.begin(); !_bFinded && (iter < _tabSelectedElements.end()); iter++)
    {
        if ((TYElement*)(*iter) == pElement)
        {
            _bFinded = true;
        }
    }
    if (!_bFinded)
    {
        _tabSelectedElements.push_back(pElement);
    }
}
 
void TYOpenGLRenderer::removeSelectedElement(TYElement* pElement)
{
    std::vector<TYElement*>::iterator iter;
    bool _bFinded = false;
    for (iter = _tabSelectedElements.begin(); !_bFinded && (iter < _tabSelectedElements.end()); iter++)
    {
        if ((TYElement*)(*iter) == pElement)
        {
            _bFinded = true;
            _tabSelectedElements.erase(iter);
            break;
        }
    }
}
 
void TYOpenGLRenderer::clearTabSelectedElement()
{
    _tabSelectedElements.clear();
}
 
void gluPickMatrix(GLdouble x, GLdouble y, GLdouble deltax, GLdouble deltay, GLint viewport[4])
{
    if (deltax <= 0 || deltay <= 0)
    {
        return;
    }
 
    /* Translate and scale the picked region to the entire window */
    glTranslated((viewport[2] - 2 * (x - viewport[0])) / deltax,
                 (viewport[3] - 2 * (y - viewport[1])) / deltay, 0);
    glScaled(viewport[2] / deltax, viewport[3] / deltay, 1.0);
}
 
void TYOpenGLRenderer::renderBoundingBoxes(TYRenderContext& renderContext) const
{
    if (renderContext.modelerElement == nullptr)
    {
        return;
    }
    auto camera = renderContext.viewport.camera();
    QMatrix4x4 viewMatrix = camera->viewMatrix();
    // TODO: Tympan coordinate system is RHS with Z-up while camera is operated as if
    // Y was UP. Rotating the view matrix before rendering fixes it (the same
    // hack is used both in interactions and with legacy render pipeline).
    viewMatrix.rotate(90, -1, 0, 0);
 
    QMatrix4x4 projectionMatrix = camera->projectionMatrix();
 
    TYElement* modelerElement = renderContext.modelerElement;
    TYElementGraphic* modelerElementGraphic = modelerElement->getGraphicObject();
    TYListPtrConstTYElementGraphic allModelerElementGraphics;
    modelerElementGraphic->getChilds(allModelerElementGraphics, true);
 
    TYGeometryNode* modelerGeoNode = TYGeometryNode::GetGeoNode(modelerElement);
    QMatrix4x4 invertedGlobalModelerMatrix{};
    if (modelerGeoNode != nullptr)
        invertedGlobalModelerMatrix =
            dynamic_cast<TYGeometryNodeGraphic*>(modelerGeoNode->getGraphicObject().getRealPointer())
                ->globalMatrix()
                .inverted();
    allModelerElementGraphics.push_back(modelerElementGraphic);
 
    QOpenGLShaderProgram* shaderProgram = OGLShaderManager::instance(QOpenGLContext::currentContext())
                                              ->getShaderProgram(OGLShaderManager::SimpleShader);
    shaderProgram->bind();
    for (auto element : allModelerElementGraphics)
    {
        if (element->isBoundingBoxVisible() && dynamic_cast<const TYGeometryNodeGraphic*>(element) == nullptr)
        {
            const OBox boundingBox = element->boundingBox();
 
            // TODO : understand how the map is constructed
            TYGeometryNode* geoNode =
                const_cast<TYGeometryNode*>(TYGeometryNode::GetGeoNode(element->getTYElement()));
            const TYElement* parent = element->getTYElement();
 
            while (geoNode == nullptr && parent->getParent())
            {
                parent = parent->getParent();
                geoNode = const_cast<TYGeometryNode*>(TYGeometryNode::GetGeoNode(parent));
            }
 
            QMatrix4x4 globalMatrix{};
            if (geoNode != nullptr)
            {
                globalMatrix =
                    dynamic_cast<TYGeometryNodeGraphic*>(geoNode->getGraphicObject().getRealPointer())
                        ->globalMatrix();
            }
 
            QMatrix4x4 bboxTranslation;
            bboxTranslation.translate(QVector3D((boundingBox._min._x + boundingBox._max._x),
                                                (boundingBox._min._y + boundingBox._max._y),
                                                (boundingBox._min._z + boundingBox._max._z)) /
                                      2);
 
            QVector3D bboxDimensions(boundingBox._max._x - boundingBox._min._x,
                                     boundingBox._max._y - boundingBox._min._y,
                                     boundingBox._max._z - boundingBox._min._z);
            QMatrix4x4 modelMatrix = invertedGlobalModelerMatrix * globalMatrix * bboxTranslation;
            drawBoundingBox(bboxDimensions, shaderProgram, modelMatrix * _boundingBoxScaleMatrix, viewMatrix,
                            projectionMatrix);
        }
    }
    shaderProgram->release();
}