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 <memory>
#include <qmatrix4x4.h>
#include <qopenglbuffer.h>
#include <qopenglcontext.h>
#include <qopenglfunctions_4_3_core.h>
#include <qopenglshaderprogram.h>
#include <qopengltexture.h>
#include <qopenglvertexarrayobject.h>
#include <qtransform.h>
#include <qvector2d.h>
#include <qvector3d.h>
#include <stdexcept>
#include <vector>
 
#include "TYOpenGLRenderer.h"
#include "Tympan/gui/gl/TYRenderContext.h"
#include "gui/gl/TYElementGraphic.h"
#include "gui/tools/OGLArrayMesh.h"
#include "gui/tools/OGLBoxMesh.h"
#include "gui/tools/OGLMesh.h"
#include "gui/tools/OGLMeshInstance.h"
#include "gui/tools/OGLSimpleMaterial.h"
#include "gui/tools/OGLShaderManager.h"
#include "gui/tools/OGLTextureManager.h"
 
#if TY_USE_IHM
    #include "Tympan/gui/gl/TYAltimetrieGraphic.h"
    #include "Tympan/gui/gl/TYGeometryNodeGraphic.h"
    #include "Tympan/gui/gl/TYAltimetrieGraphic.h"
    #include <QOpenGLFunctions_4_3_Core>
#endif
#include <gui/gl/TYSiteNodeGraphic.h>
#include <gui/gl/TYAcousticVolumeNodeGraphic.h>
#include <gui/gl/TYCourbeNiveauGraphic.h>
#include <gui/gl/TYReseauTransportGraphic.h>
 
void TYOpenGLRenderer::addBoundingBoxMeshInstances(std::vector<OGLMeshInstance>& meshInstances,
                                                   TYElementGraphic* element)
{
    const OBox boundingBox = element->boundingBox();
 
    QMatrix4x4 globalMatrix = element->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 = globalMatrix * bboxTranslation * _boundingBoxScaleMatrix;
 
    // Box mesh
    std::shared_ptr<OGLMesh> bboxMesh = std::make_shared<OGLBoxMesh>(bboxDimensions);
    bboxMesh->setMaterial(OGLSimpleMaterial::BOUNDING_BOX);
    meshInstances.emplace_back(bboxMesh, modelMatrix);
 
    // Vertices mesh
    std::shared_ptr<OGLArrayMesh> points = std::make_shared<OGLArrayMesh>();
    points->fromMeshVertices(*bboxMesh);
    points->setMaterial(OGLSimpleMaterial::BOUNDING_BOX);
    meshInstances.emplace_back(points, modelMatrix);
}
 
void TYOpenGLRenderer::collectMeshInstances(TYElementGraphic* elementGraphic,
                                            std::vector<OGLMeshInstance>& meshInstances,
                                            TYRenderContext* renderContext)
{
    if (elementGraphic != nullptr)
    {
        if (elementGraphic->getModified() && dynamic_cast<TYAltimetrieGraphic*>(elementGraphic) == nullptr)
        {
            elementGraphic->update();
        }
 
        if (elementGraphic->isBoundingBoxVisible())
        {
            addBoundingBoxMeshInstances(meshInstances, elementGraphic);
        }
        bool showGeometry = true;
        // Only test _visible value on high level graphic elements as its value is not consistent on children
        if (dynamic_cast<TYSiteNodeGraphic*>(elementGraphic) != nullptr ||
            dynamic_cast<TYAcousticVolumeNodeGraphic*>(elementGraphic) != nullptr ||
            dynamic_cast<TYCourbeNiveauGraphic*>(elementGraphic) != nullptr ||
            dynamic_cast<TYAcousticLineGraphic*>(elementGraphic) != nullptr ||
            dynamic_cast<TYAltimetrieGraphic*>(elementGraphic) != nullptr)
        {
            showGeometry = elementGraphic->getVisible();
        }
 
        elementGraphic->setVisible(showGeometry);
 
        if (showGeometry)
        {
            elementGraphic->collectMeshInstances(meshInstances, renderContext);
            // recurse
            TYListPtrTYElementGraphic children;
            elementGraphic->getChilds(children, false);
            for (auto child : children)
            {
                collectMeshInstances(child, meshInstances, renderContext);
            }
        }
    }
}
 
void drawMeshInstance(const OGLMeshInstance& meshInstance, QOpenGLShaderProgram* shaderProgram,
                      const QMatrix4x4& view, const QMatrix4x4& projection)
{
    const OGLMesh& mesh = *meshInstance.mesh();
    QOpenGLFunctions_4_3_Core gl;
    gl.initializeOpenGLFunctions();
 
    QOpenGLVertexArrayObject vao;
    vao.create();
    vao.bind();
 
    // Bind position
    QOpenGLBuffer positionBuffer(QOpenGLBuffer::VertexBuffer);
    positionBuffer.create();
    positionBuffer.bind();
    positionBuffer.allocate(mesh.vertices().data(), mesh.vertices().size() * sizeof(QVector3D));
 
    int vertexLocation = shaderProgram->attributeLocation("vPosition");
    shaderProgram->enableAttributeArray(vertexLocation);
    shaderProgram->setAttributeBuffer(vertexLocation, GL_FLOAT, 0, 3, 0);
 
    // Bind vertices colors
    QOpenGLBuffer colorsBuffer(QOpenGLBuffer::VertexBuffer);
    int colorsLocation = shaderProgram->attributeLocation("vColor");
    if (mesh.verticesColors().size() == mesh.vertices().size() * 4)
    {
        colorsBuffer.create();
        colorsBuffer.bind();
        colorsBuffer.allocate(mesh.verticesColors().data(), mesh.verticesColors().size() * sizeof(float));
 
        shaderProgram->enableAttributeArray(colorsLocation);
        shaderProgram->setAttributeBuffer(colorsLocation, GL_FLOAT, 0, 4, 0);
    }
    else
    {
        shaderProgram->disableAttributeArray(colorsLocation);
        shaderProgram->setAttributeValue(colorsLocation, mesh.material().color);
    }
 
    // Bind texture coordinates
    QOpenGLBuffer textureCoordinatesBuffer(QOpenGLBuffer::VertexBuffer);
    int textureCoordinatesLocation = shaderProgram->attributeLocation("vTextureCoordinates");
    if (mesh.textureCoordinates().size() == mesh.vertices().size())
    {
        textureCoordinatesBuffer.create();
        textureCoordinatesBuffer.bind();
        textureCoordinatesBuffer.allocate(mesh.textureCoordinates().data(),
                                          mesh.textureCoordinates().size() * sizeof(QVector2D));
 
        shaderProgram->enableAttributeArray(textureCoordinatesLocation);
        shaderProgram->setAttributeBuffer(textureCoordinatesLocation, GL_FLOAT, 0, 2, 0);
    }
    else
    {
        shaderProgram->disableAttributeArray(textureCoordinatesLocation);
        shaderProgram->setAttributeValue(textureCoordinatesLocation, QVector2D(0.5, 0.5));
    }
 
    // Bind texture coordinates
    QOpenGLBuffer normalBuffer(QOpenGLBuffer::VertexBuffer);
    int normalLocation = shaderProgram->attributeLocation("vNormal");
    if (mesh.normals().size() == mesh.vertices().size())
    {
        normalBuffer.create();
        normalBuffer.bind();
        normalBuffer.allocate(mesh.normals().data(), mesh.normals().size() * sizeof(QVector3D));
 
        shaderProgram->enableAttributeArray(normalLocation);
        shaderProgram->setAttributeBuffer(normalLocation, GL_FLOAT, 0, 3, 0);
    }
    else
    {
        shaderProgram->disableAttributeArray(normalLocation);
        shaderProgram->setAttributeValue(normalLocation, QVector3D(0.0, 0.0, 1.0));
    }
 
    int modelLocation = shaderProgram->uniformLocation("uModel");
    shaderProgram->setUniformValue(modelLocation, meshInstance.globalMatrix());
    int viewLocation = shaderProgram->uniformLocation("uView");
    shaderProgram->setUniformValue(viewLocation, view);
    int projectionLocation = shaderProgram->uniformLocation("uProjection");
    shaderProgram->setUniformValue(projectionLocation, projection);
 
    int textureBlendLocation = shaderProgram->uniformLocation("uTextureBlend");
    shaderProgram->setUniformValue(textureBlendLocation, (GLuint)mesh.material().textureBlend);
 
    int lightingModeLocation = shaderProgram->uniformLocation("uLightingMode");
    shaderProgram->setUniformValue(lightingModeLocation, (GLuint)mesh.material().lightingMode);
 
    int texLocation = shaderProgram->uniformLocation("uTexture");
    auto image = mesh.material().image;
    auto textureManager = OGLTextureManager::instance(QOpenGLContext::currentContext());
    auto texture = image == nullptr ? textureManager->whiteTexture() : textureManager->getTexture(image);
    texture->bind(0);
    shaderProgram->setUniformValue(texLocation, 0);
 
    QOpenGLBuffer indexBuffer(QOpenGLBuffer::IndexBuffer);
    indexBuffer.create();
    indexBuffer.bind();
    indexBuffer.allocate(mesh.indices().data(), mesh.indices().size() * sizeof(unsigned int));
 
    switch (meshInstance.mesh()->primitiveType())
    {
        case OGLPrivimitiveType::Lines:
            glDrawElements(GL_LINES, mesh.indices().size(), GL_UNSIGNED_INT, 0);
            break;
        case OGLPrivimitiveType::LineStrip:
            glDrawElements(GL_LINE_STRIP, mesh.indices().size(), GL_UNSIGNED_INT, 0);
            break;
        case OGLPrivimitiveType::LineLoop:
            glDrawElements(GL_LINE_LOOP, mesh.indices().size(), GL_UNSIGNED_INT, 0);
            break;
        case OGLPrivimitiveType::Points:
            glDrawElements(GL_POINTS, mesh.indices().size(), GL_UNSIGNED_INT, 0);
            break;
        case OGLPrivimitiveType::Triangles:
            glDrawElements(GL_TRIANGLES, mesh.indices().size(), GL_UNSIGNED_INT, 0);
            break;
        case OGLPrivimitiveType::Quads:
 
            glDrawElements(GL_QUADS, mesh.indices().size(), GL_UNSIGNED_INT, 0);
            break;
    }
    gl.glBindTexture(GL_TEXTURE_2D, 0);
 
    indexBuffer.destroy();
 
    if (mesh.normals().size() == mesh.vertices().size())
    {
        normalBuffer.destroy();
    }
    if (mesh.textureCoordinates().size() == mesh.vertices().size())
    {
        textureCoordinatesBuffer.destroy();
    }
    positionBuffer.release(QOpenGLBuffer::VertexBuffer);
    positionBuffer.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_MULTISAMPLE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    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)
 
        renderContext.pass = TYRenderPass::Overlay;
 
        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(renderContext);
                    }
                }
            }
            updateDisplayListOverlay(renderContext, pGeoNode, pRootGeometryNode);
        }
        glEndList();
        renderContext.pass = TYRenderPass::Default;
    }
 
    glMatrixMode(GL_MODELVIEW);
    if (renderContext.type == TYRenderType::Display)
    {
        // Render mesh instances (new pipeline)
        std::vector<OGLMeshInstance> meshInstances;
        if (renderContext.modelerElement != nullptr)
        {
            std::vector<OGLMeshInstance> meshInstancesInProjectSpace;
            collectMeshInstances(renderContext.modelerElement->getGraphicObject().getRealPointer(),
                                 meshInstancesInProjectSpace, &renderContext);
            std::vector<OGLMeshInstance> meshInstancesInModelerSpace;
            for (auto& meshInstance : meshInstancesInProjectSpace)
            {
                meshInstances.emplace_back(meshInstance.mesh(),
                                           renderContext.globalToModelerMatrix * meshInstance.globalMatrix());
            }
        }
        drawMeshInstances(renderContext, meshInstances);
        glPushMatrix();
        _renderScene(renderContext);
        glCallList(_displayListOverlay);
        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<TYAltimetrieGraphic*>(pGraphObj.getRealPointer()) != nullptr)
        {
            std::vector<OGLMeshInstance> meshInstances = {};
            pGraphObj->collectMeshInstances(meshInstances, &renderContext);
        }
 
        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::drawMeshInstances(TYRenderContext& renderContext,
                                         const std::vector<OGLMeshInstance>& meshInstances) const
{
    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();
 
    // >>> Extraction cam en espace monde à partir de viewMatrix <<<
    bool ok = false;
    QMatrix4x4 invView = viewMatrix.inverted(&ok);
    // position caméra = C * (0,0,0,1)
    const QVector3D camPosWS = invView.map(QVector3D(0.0f, 0.0f, 0.0f));
    // direction avant caméra = C * (0,0,-1,0) (vecteur)
    QVector3D camFwdWS = invView.mapVector(QVector3D(0.0f, 0.0f, -1.0f));
    camFwdWS.normalize();
 
    // Dans Tympan, le monde est RHS avec Z-up => "vers le bas" = -Z
    const QVector3D downDirWS(0.0f, 0.0f, -1.0f);
 
    QOpenGLShaderProgram* shaderProgram = OGLShaderManager::instance(QOpenGLContext::currentContext())
                                              ->getShaderProgram(OGLShaderManager::SimpleShader);
    shaderProgram->bind();
 
    // Position et et direction avant caméra
    shaderProgram->setUniformValue("uCamPosWS", camPosWS);
    shaderProgram->setUniformValue("uCamFwdWS", camFwdWS);
 
    // Ambiant & matériau
    shaderProgram->setUniformValue("uGlobalAmbient", QVector3D(0.8f, 0.8f, 0.8f));
    shaderProgram->setUniformValue("uKa", 0.8f);
    shaderProgram->setUniformValue("uKd", 0.8f);
    shaderProgram->setUniformValue("uKsDown", 0.0f);
    shaderProgram->setUniformValue("uKsHeadlight", 0.0f); // coupe le hotspot
    shaderProgram->setUniformValue("uShininess", 50.0f);
 
    // Directions & gains
    shaderProgram->setUniformValue("uDownDirWS", QVector3D(0.0f, 0.0f, -1.0f)); // rayons vers le bas
    shaderProgram->setUniformValue("uDownIntensity", 1.0f);
    shaderProgram->setUniformValue("uHeadlightIntensity", 1.0f);
 
    // Headlight adoucie + remplissage
    shaderProgram->setUniformValue("uCamWrap", 0.0f);        // 0 = Lambert ; 0.4–0.7 adoucit la chute
    shaderProgram->setUniformValue("uCamPointWeight", 0.0f); // 0 = dir ; 1 = point
    shaderProgram->setUniformValue("uGrazingFill", 0.0f);    // 0.08–0.20
    shaderProgram->setUniformValue("uHeadlightFloor", 0.0f); // 0.05–0.20
 
    for (const OGLMeshInstance& meshInstance : meshInstances)
    {
        if (meshInstance.mesh()->primitiveType() == OGLPrivimitiveType::Quads &&
            _renderMode == TYOpenGLRenderer::Wireframe)
        {
            std::shared_ptr<OGLArrayMesh> lineMesh = std::make_shared<OGLArrayMesh>();
            lineMesh->material() = meshInstance.mesh()->material();
            lineMesh->fromQuadMeshEdges(*meshInstance.mesh());
            OGLMeshInstance lineMeshInstance(lineMesh, meshInstance.globalMatrix());
            drawMeshInstance(lineMeshInstance, shaderProgram, viewMatrix, projectionMatrix);
        }
        else
        {
            drawMeshInstance(meshInstance, shaderProgram, viewMatrix, projectionMatrix);
        }
    }
    shaderProgram->release();
}