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(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();

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__