TYPlanEauGraphic.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 "gui/gl/TYRenderContext.h"
#if _WIN32
    #include <windows.h>
#endif //_WIN32
#include <GL/gl.h>
#include <GL/glu.h>
#include <QtOpenGL>
#include <qvector3d.h>
#include <vector>
 
#include "TYPlanEauGraphic.h"
 
#include "Tympan/models/business/topography/TYPlanEau.h"
 
#include "Tympan/models/business/TYPreferenceManager.h"
#include "Tympan/models/business/cgal_bridge.h"
 
#include "Tympan/gui/gl/TYPickingTable.h"
#include "gui/gl/TYRenderContext.h"
#include "gui/tools/OGLArrayMesh.h"
#include "gui/tools/OGLMeshInstance.h"
#include "models/business/TYDefines.h"
 
TYPlanEauGraphic::TYPlanEauGraphic(TYPlanEau* pElement)
    : TYElementGraphic(pElement), _pPolygonMesh(std::make_shared<OGLPolygonMesh>())
{
    _pPolygon = new TYPolygon();
}
 
void TYPlanEauGraphic::update(bool force /*=false*/)
{
    TYElementGraphic::update(force);
}
 
void TYPlanEauGraphic::getChilds(TYListPtrTYElementGraphic& childs, bool recursif /*=true*/)
{
    TYElementGraphic* pTYElementGraphic = _pPolygon->getGraphicObject();
    childs.push_back(pTYElementGraphic);
    if (recursif)
    {
        pTYElementGraphic->getChilds(childs, recursif);
    }
}
 
void TYPlanEauGraphic::display(TYRenderContext& renderContext)
{
    if (!_visible)
    {
        return;
    }
 
    TYElementGraphic::display(renderContext);
 
    TYTabPoint tabpoints = getElement()->getListPoints();
 
    // Ajout d'un offset pour limiter le flickering avec l'altimetrie
    for (unsigned int i = 0; i < tabpoints.size(); i++)
    {
        tabpoints[i]._z += 0.5; // Anciennement 0.05
    }
 
    _pPolygon->setPoints(tabpoints);
 
    if ((_highlight) && (renderContext.pass == TYRenderPass::Overlay))
    {
        drawName(renderContext);
    }
 
    if (renderContext.type == TYRenderType::Picking)
    {
        TYPickingTable::addElement(getElement());
        glPushName((GLuint)(TYPickingTable::getIndex()));
 
        glColor4fv(getElement()->getColor());
 
        _pPolygon->getGraphicObject()->display(renderContext);
 
        glPopName();
    }
}
 
// Store the vertices both as a QVector3D and as an array
// Both are used for different tesselator functions
struct TesselatorVertexData
{
    QVector3D position;
    double rawPosition[3];
};
 
// Store the vertices of a primitive and their indices
struct TesselatorPrimitive
{
    GLenum type;
    std::vector<QVector3D> vertices;
    std::vector<unsigned int> indices;
};
 
// Store the primitive and the vertices
struct TesselatorPolygonData
{
    std::vector<TesselatorPrimitive> primitives;
    std::vector<TesselatorVertexData*> generatedVerticesData;
};
 
void TYPlanEauGraphic::collectMeshInstances(std::vector<OGLMeshInstance>& meshInstances,
                                            TYRenderContext* renderContext) const
{
    if (renderContext == nullptr || renderContext->showLevelCurves)
    {
        TYTabPoint polygonVertices = getElement()->getListPoints();
        polygonVertices.push_back(polygonVertices[0]);
 
        // Ajout d'un offset pour limiter le flickering avec l'altimetrie
        for (unsigned int i = 0; i < polygonVertices.size(); i++)
        {
            polygonVertices[i]._z += 0.5; // Anciennement 0.05
        }
 
        // Polygon tesselation. The following code relies on GLUTesselator to
        // transform the polygon into a triangles soup.
 
        TesselatorPolygonData polygonData{std::vector<TesselatorPrimitive>(),
                                          std::vector<TesselatorVertexData*>()};
        GLUtesselator* tesselator = gluNewTess();
 
        // Add a new primitive to the tesselation state
        auto beginCallback = +[](GLenum type, TesselatorPolygonData* polygonData)
        { polygonData->primitives.emplace_back(TesselatorPrimitive{type}); };
 
        // Add a a new vertex to the current primitive
        auto vertexDataCallback = +[](TesselatorVertexData* vertexData, TesselatorPolygonData* polygonData)
        {
            TesselatorPrimitive& primitive = polygonData->primitives.back();
            primitive.vertices.emplace_back(vertexData->position);
            unsigned int lastVertexIndex = primitive.vertices.size() - 1;
 
            if (primitive.type == GL_TRIANGLES)
            {
                primitive.indices.push_back(lastVertexIndex);
            }
            else if (primitive.type == GL_TRIANGLE_STRIP)
            {
                if (lastVertexIndex >= 2)
                {
                    primitive.indices.push_back(lastVertexIndex - 2);
                    primitive.indices.push_back(lastVertexIndex - 1);
                    primitive.indices.push_back(lastVertexIndex);
                }
            }
            else if (primitive.type == GL_TRIANGLE_FAN)
            {
                if (lastVertexIndex >= 2)
                {
                    primitive.indices.push_back(0);
                    primitive.indices.push_back(lastVertexIndex - 1);
                    primitive.indices.push_back(lastVertexIndex);
                }
            }
        };
 
        // Interpolate data on vertices generated by GLUTesselator
        auto combineCallback = +[](GLdouble coords[3], TesselatorVertexData* vertexData[4], GLfloat weight[4],
                                   TesselatorVertexData** outData, TesselatorPolygonData* polygonData)
        {
            TesselatorVertexData* outVertexData = new TesselatorVertexData();
 
            outVertexData->position = QVector3D(0, 0, 0);
            for (int i = 0; i < 4; i++)
            {
                if (vertexData[i] != nullptr)
                {
                    outVertexData->position += (weight[i] * vertexData[i]->position);
                }
            }
            *outData = outVertexData;
            polygonData->generatedVerticesData.push_back(outVertexData);
        };
 
        gluTessCallback(tesselator, GLU_TESS_BEGIN_DATA, (void (*)())beginCallback);
        gluTessCallback(tesselator, GLU_TESS_VERTEX_DATA, (void (*)())vertexDataCallback);
        gluTessCallback(tesselator, GLU_TESS_COMBINE_DATA, (void (*)())combineCallback);
 
        gluTessBeginPolygon(tesselator, &polygonData);
        gluTessBeginContour(tesselator);
        std::vector<TesselatorVertexData> verticesData;
        for (const auto& point : polygonVertices)
        {
            TesselatorVertexData& vertexData =
                verticesData.emplace_back(TesselatorVertexData{QVector3D(point._x, point._y, point._z)});
            vertexData.rawPosition[0] = point._x;
            vertexData.rawPosition[1] = point._y;
            vertexData.rawPosition[2] = point._z;
        }
        for (auto& vertexData : verticesData)
        {
            double position[3] = {vertexData.position.x(), vertexData.position.y(), vertexData.position.z()};
            gluTessVertex(tesselator, position, &vertexData);
        }
        gluTessEndContour(tesselator);
        gluTessEndPolygon(tesselator);
 
        gluDeleteTess(tesselator);
        for (TesselatorVertexData* generatedVertexData : polygonData.generatedVerticesData)
        {
            delete generatedVertexData;
        }
 
        std::vector<QVector3D> vertices;
        std::vector<unsigned int> indices;
        unsigned int indicesOffset = 0;
 
        // Merge all GL_TRIANGLES primitives into a single one
        for (auto& primitive : polygonData.primitives)
        {
            vertices.insert(vertices.end(), primitive.vertices.begin(), primitive.vertices.end());
            for (auto index : primitive.indices)
            {
                indices.push_back(indicesOffset + index);
            }
            indicesOffset += primitive.vertices.size();
        }
        _pPolygonMesh->setVertices(vertices);
 
        _pPolygonMesh->setIndices(indices);
        _pPolygonMesh->material().color = getElement()->getColor();
        meshInstances.emplace_back(_pPolygonMesh, globalMatrix());
    }
}