TYElementGraphic.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/TYElement.h"
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/gui/tools/OGLTextElement.h"
#include "Tympan/gui/tools/OGLCamera.h"
#include "Tympan/gui/tools/OGLLineElement.h"
#include "Tympan/models/business/geometry/TYGeometryNode.h"
 
#include "TYElementGraphic.h"
#include "Tympan/models/business/infrastructure/TYSiteNode.h"
#include "gui/app/TYOpenGLRenderer.h"
#include "Tympan/gui/gl/TYRenderContext.h"
#include "gui/gl/TYGeometryNodeGraphic.h"
#include "gui/tools/OGLMeshInstance.h"
#include "models/common/3d.h"
#include <QtOpenGL>
#include <qmatrix4x4.h>
#include <qvector3d.h>
 
#define IMG(id) OLocalizator::getPicture("TYElementGraphic", (id))
 
bool TYElementGraphic::_gDrawNormals = false;
bool TYElementGraphic::_gDrawPlafond = true;
 
TYElementGraphic::TYElementGraphic(TYElement* pElt)
{
    _pElement = pElt;
 
    _modified = true;
    _visible = true;
    _highlight = false;
    _texture = false;
 
    // Highlight
    _viewOnlyHighlight = false;
    _boundingBoxDirty = true;
}
 
TYElementGraphic::~TYElementGraphic() {}
 
void TYElementGraphic::setElement(TYElement* pElt)
{
    _pElement = pElt;
}
 
void TYElementGraphic::updateTree()
{
    TYElement* pParent = _pElement->getParent();
 
    // On appelle la methode update surchargee par les objets graphiques
    update();
    if (getModified() && pParent && pParent->getGraphicObject())
    {
        // On force la mise a jour du parent
        pParent->setIsGeometryModified(true);
        // On appelle la methode update surchargee par les objets graphiques
        // On remonte l'arbre
        pParent->getGraphicObject()->updateTree();
    }
}
 
void TYElementGraphic::update(bool force /*=false*/)
{
    if (_pElement)
    {
        if (_pElement->isInCurrentCalcul())
        {
            _visible = !_viewOnlyHighlight;
        }
        else
        {
            _visible = false;
        }
    }
 
    // Update highlight seulement si actif
    setBoundingBoxVisible(isBoundingBoxVisible());
 
    // On repositionne le flag modified
    setModified(false);
 
#if TY_USE_IHM
    // Emission du signal de notification de mise a jour
    activateSignal();
#endif // TY_USE_IHM
}
 
bool TYElementGraphic::getModified() const
{
    return _modified;
}
 
void TYElementGraphic::setBoundingBoxVisible(bool state /*=true*/)
{
    // Update
    _highlight = state;
}
 
void TYElementGraphic::displayNormal(OVector3D normal, OPoint3D p1)
{
    OVector3D n = normal; // getElement()->_normale;
    OPoint3D p2;
    p2._x = p1._x + n._x;
    p2._y = p1._y + n._y;
    p2._z = p1._z + n._z;
    glColor3f(1.0f, 0.5f, 0.0f);
    glLineWidth(2);
    glPointSize(4);
 
    glBegin(GL_LINE_STRIP);
    glVertex3f(p1._x, p1._y, p1._z);
    glVertex3f(p2._x, p2._y, p2._z);
    glEnd();
}
 
void TYElementGraphic::drawName(TYRenderContext& renderContext)
{
    TYGeometryNode* pThisGeoNode = TYGeometryNode::GetGeoNode(_pElement);
    const TYGeometryNode* pGeoNode = TYGeometryNode::GetGeoNode(renderContext.modelerElement);
    // pour déterminer la position du texte, il faut le centre de la boundingbox dans le repère du modeleur.
    QVector3D origin;
    float org[3];
    OBox bBox = boundingBox();
    org[0] = (bBox._min._x + bBox._max._x) / 2;
    org[1] = (bBox._min._y + bBox._max._y) / 2;
    org[2] = (bBox._min._z + bBox._max._z) / 2;
    if (pThisGeoNode)
    {
        OMatrix mat;
        if (pGeoNode != nullptr)
        {
            mat = pThisGeoNode->localToGeoNode(pGeoNode);
        }
        else
        {
            mat = pThisGeoNode->localToGlobal();
        }
 
        origin = QVector3D(
            org[0] * mat._m[0][0] + org[1] * mat._m[0][1] + org[2] * mat._m[0][2] + mat._m[0][3],
            org[0] * mat._m[2][0] + org[1] * mat._m[2][1] + org[2] * mat._m[2][2] + mat._m[2][3],
            -(org[0] * mat._m[1][0] + org[1] * mat._m[1][1] + org[2] * mat._m[1][2] + mat._m[1][3]));
    }
    else
    {
        origin = QVector3D(org[0], org[2], -org[1]);
    }
    QVector3D ret = renderContext.viewport.worldToDisplay(origin);
 
    // ajouter une etiquette avec le nom
    OGLTextElement oOGLTextElement;
    oOGLTextElement.setFont(IMG("id_font"));
    oOGLTextElement.setVisibility(true);
    if (_pElement)
    {
        oOGLTextElement.setTextToDisplay(_pElement->getName());
    }
    oOGLTextElement.setColor(OColor::BLACK);
    oOGLTextElement.setDisplayPosition(ret.x() + 22, ret.y() + 40);
    oOGLTextElement.render();
 
    OGLLineElement oglLineElement;
    oglLineElement.setColor(OColor::BLACK);
    oglLineElement.setLineWidth(2.0f);
    oglLineElement.setPoint1(QVector3D(ret.x(), ret.y(), 0));
    oglLineElement.setPoint2(QVector3D(ret.x() + 20, ret.y() + 40, 0));
    oglLineElement.setVisibility(true);
    oglLineElement.render();
}
 
bool TYElementGraphic::isBoundingBoxVisible() const
{
    return _highlight;
}
 
bool TYElementGraphic::getOnlyBoundingBox() const
{
    return _viewOnlyHighlight;
}
 
void TYElementGraphic::setOnlyBoundingBox(bool state /*=true*/)
{
    _viewOnlyHighlight = state;
 
    // Active le highlight
    setBoundingBoxVisible(_viewOnlyHighlight);
}
 
void TYElementGraphic::display(TYRenderContext& renderContext)
{
#if TY_USE_IHM
    // Emission du signal de notification de mise a jour
    activateSignal();
 
#endif // TY_USE_IHM
}
 
OBox TYElementGraphic::boundingBox() const
{
    if (_boundingBoxDirty)
    {
        _boundingBox = computeBoundingBox();
        _boundingBoxDirty = false;
    }
    return _boundingBox;
}
 
OBox TYElementGraphic::computeBoundingBox() const
{
    OBox Box;
 
    TYListPtrConstTYElementGraphic childs;
    getChilds(childs, false);
    if (childs.size() > 0)
    {
        const TYElementGraphic* pChild = nullptr;
        TYListPtrConstTYElementGraphic::iterator ite = childs.begin();
        pChild = (*ite);
        Box = OBox{pChild->boundingBox()};
        ite++;
        for (; ite != childs.end(); ite++)
        {
            pChild = (*ite);
            if (pChild != nullptr)
            {
                Box.Enlarge(pChild->boundingBox());
            }
        }
    }
 
    std::vector<OGLMeshInstance> meshInstances;
    collectMeshInstances(meshInstances, nullptr);
    for (const OGLMeshInstance& meshInstance : meshInstances)
    {
        Box.Enlarge(meshInstance.mesh()->boundingBox());
    }
    return Box;
}
 
void TYElementGraphic::invalidateBoundingBox()
{
    if (getTYElement() != nullptr)
    {
        TYElement* parent = getTYElement()->getParent();
        if (parent != nullptr)
        {
            LPTYElementGraphic parentGraphicElement = parent->getGraphicObject();
            if (parentGraphicElement != nullptr)
            {
                parentGraphicElement->invalidateBoundingBox();
            }
        }
        LPTYElementArray children;
        getTYElement()->getChilds(children, false);
        LPTYElementGraphic childGraphicElement;
        for (int i = 0; i < children.size(); i++)
        {
            childGraphicElement = children[i]->getGraphicObject();
            if (childGraphicElement != nullptr)
            {
                childGraphicElement->_boundingBoxDirty = true;
            }
        }
    }
    this->_boundingBoxDirty = true;
}
 
void TYElementGraphic::collectMeshInstances(std::vector<OGLMeshInstance>& meshInstances,
                                            TYRenderContext* renderContext) const {};
 
const TYGeometryNodeGraphic* TYElementGraphic::nearestGeoNode() const
{
    if (dynamic_cast<const TYGeometryNodeGraphic*>(this) != nullptr)
    {
        return dynamic_cast<const TYGeometryNodeGraphic*>(this);
    }
    const TYElement* parent = getTYElement();
    while (parent != nullptr)
    {
        TYGeometryNode* geoNode = const_cast<TYGeometryNode*>(TYGeometryNode::GetGeoNode(parent));
 
        if (geoNode != nullptr)
        {
            return dynamic_cast<TYGeometryNodeGraphic*>(geoNode->getGraphicObject().getRealPointer());
        }
        parent = parent->getParent();
    }
    return nullptr;
}
 
QMatrix4x4 TYElementGraphic::globalMatrix() const
{
    const TYGeometryNodeGraphic* geoNodeGraphic = nearestGeoNode();
    if (geoNodeGraphic != nullptr)
    {
        return geoNodeGraphic->globalMatrix();
    }
    return {};
}
void TYElementGraphic::setModified(bool modified)
{
    _modified = modified;
    if (modified)
    {
        invalidateBoundingBox();
    }
}