TYElementGraphic.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program 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 2 of the License, or
 * (at your option) any later version.
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef __TY_ELEMENT_GRAPHIC__
#define __TY_ELEMENT_GRAPHIC__
 
#if _MSC_VER > 1000
    #pragma once
#endif // _MSC_VER > 1000
 
#ifdef _MSC_VER
    #pragma warning(disable : 4284)
#endif
 
#if TY_USE_IHM
    #include <QtOpenGL>
    #include <GL/gl.h>
    #include <GL/glu.h>
/* #include <qobject.h> */
/* #include <qgl.h> */
#else
    #include <GL/gl.h>
    #include <GL/glu.h>
#endif // TY_USE_IHM
 
#include "Tympan/models/common/3d.h"
#include "Tympan/core/color.h"
#include "Tympan/core/smartptr.h"
 
class TYElement;
 
#define TY_DECL_METIER_GRAPHIC(classname)                                                                    \
public:                                                                                                      \
    inline classname* getElement() const                                                                     \
    {                                                                                                        \
        return (classname*)_pElement;                                                                        \
    }
 
#include <list>
// Pour l'utilisation de la librairie standard STL.
using std::list;
 
class TYElementGraphic;
typedef list<TYElementGraphic*> TYListPtrTYElementGraphic;
 
class TYElementGraphic : public IRefCount
{
    // Methodes
public:
    virtual ~TYElementGraphic();
 
    void setElement(TYElement* pElt);
    TYElement* getTYElement()
    {
        return _pElement;
    }
 
    void updateTree();
 
    virtual void update(bool force = false);
 
    virtual void display(TYElement* pModelerElement = nullptr, GLenum mode = GL_RENDER);
 
    void setModified(bool modified = true)
    {
        _modified = modified;
    }
    bool getModified(bool andReset = false);
 
    void setVisible(bool visible = true)
    {
        _visible = visible;
    }
    bool getVisible()
    {
        return _visible;
    }
    void setRecursiveVisible(bool visible = true);
 
    void setTexture(bool state = true)
    {
        _texture = state;
    }
    bool getTexture()
    {
        return _texture;
    }
 
    OBox GetBox()
    {
        return _boundingBox;
    }
 
    virtual void computeBoundingBox();
 
    virtual void getChilds(TYListPtrTYElementGraphic& childs, bool recursif = true){};
 
    void highlight(bool state = true);
 
    bool getHighlightState();
 
    void viewOnlyHighlight(bool state = true);
    bool getOnlyHighlight()
    {
        return _viewOnlyHighlight;
    }
 
public:
#if TY_USE_IHM
    virtual void activateSignal(){};
 
    virtual void connectUpdateSignal(QObject* pReceiver, const char* member){};
    virtual void disconnectUpdateSignal(QObject* pReceiver, const char* member){};
#endif // TY_USE_IHM
 
    static OBox _globalBoundingBox;
 
protected:
    TYElementGraphic(TYElement* pElt);
 
    void displayNormal(OVector3D normal, OPoint3D p1);
 
    void glVertex3fAndEnlargeBB(GLfloat x, GLfloat y, GLfloat z);
    void glVertex3dAndEnlargeBB(GLdouble x, GLdouble y, GLdouble z);
    void gluDiskAndEnlargeBB(GLUquadric* qobj, GLdouble innerRadius, GLdouble outerRadius, GLint slices,
                             GLint loops);
    void gluCylinderAndEnlargeBB(GLUquadric* qobj, GLdouble baseRadius, GLdouble topRadius, GLdouble height,
                                 GLint slices, GLint stacks);
    void gluPartialDiskAndEnlargeBB(GLUquadric* qobj, GLdouble innerRadius, GLdouble outerRadius,
                                    GLint slices, GLint loops, GLdouble startAngle, GLdouble sweepAngle);
    void drawBoundingBox();
    void drawLineBoundingBox();
    void drawName(TYElement* pModelerElement = nullptr);
 
public:
    static bool _gDrawNormals;
 
    static bool _gDrawPlafond;
 
private:
    bool _modified;
 
    bool _viewOnlyHighlight;
 
protected:
    OBox _boundingBox;
    TYElement* _pElement;
 
    bool _highlight;
 
    bool _texture;
 
    bool _visible;
 
    bool _bFirstDisp;
};
 
typedef SmartPtr<TYElementGraphic> LPTYElementGraphic;
 
#endif // __TY_ELEMENT_GRAPHIC__