unix { 
    EXTERNAL = ../local
    LIBS = -lIrrlicht \
        -lglut \
        -lXxf86vm
}
win32 { 
    EXTERNAL = ../../../../../Libraries/devel/trunk/
    LIBS = -lIrrlicht \
        -lqwtd5
}

void GsIrrlicht::initialisation(QColor l_BackGroundColor, int l_Width, int l_Height,QWidget* Parent)
{
    m_Parent = Parent;

    // Initialisation du moteur3D d'Irrlicht ...
    SIrrlichtCreationParameters Parameters;             // Paramètres d'initialisation vidéo pour Irrlicht
    Parameters.DriverType = video::EDT_OPENGL;        // Choix du driver OpenGL ou DirectX
    Parameters.Bits = 16;
    Parameters.Fullscreen = false;                      // option: pleine écran ou non
    Parameters.Stencilbuffer = true;
    Parameters.Vsync = true;                            // option: synchronisation verticale ou non
    Parameters.AntiAlias = true;                        // option: Anti aliésine ou non
    Parameters.HighPrecisionFPU = false;
    Parameters.EventReceiver = m_ManagerEvent;          // pointeur de l'objet getionnaire d'évènement

    if(m_Parent != NULL)                                // Configuration pour Windows héritant d'un widget parent
    {
        WId *winID = new WId;
        *winID = m_Parent->winId();
        Parameters.WindowId = (int*)*winID;        // Avec Linux on fait "parametres.WindowId = winID;"
        m_Device = createDeviceEx(Parameters);        // Création d'Irrlicht avec fenétre QT comme support
        MemIDWin = (int)*winID;
        delete winID;
    }
    else                            // Si aucun widget maitre n'est utilisée, on prend la fenêtre d'Irrlicht...
    {
        m_Device = createDevice(    Parameters.DriverType,core::dimension2d< s32 >(l_Width, l_Height),
                                    Parameters.Bits,
                                    Parameters.Fullscreen,
                                    Parameters.Stencilbuffer,
                                    Parameters.Vsync,
                                    m_ManagerEvent);
    }

    m_Device->setResizeAble(true);              // Autorise le redimentionnement de la fenetre
    m_Driver =  m_Device->getVideoDriver();
}

void GsIrrlicht::updateFrame()
{
    if(m_Device->run())
    {
        updateRobot();                  // Mise à jour de tous les robots ou autre chose !!
        updateObject3D();               // Mise à jour des objets 3D. Doit être en premier pour les effets miroires

        m_Driver->beginScene(true, true, SColor(m_BackGroundColor.alpha(),
                                                m_BackGroundColor.red(),
                                                m_BackGroundColor.green(),
                                                m_BackGroundColor.blue()));

        gestionMouvementCamera3D();

        m_Smgr->drawAll();
        m_Guienv->drawAll();

        m_Driver->endScene();
    }
    emit newFrameDone();                // Signal pour indiqué qu'un nuovelle frame vient d'être faite
}

class FenPrincipale : public QMainWindow
{
        Q_OBJECT

            private slots :
            void mousePressEvent(QMouseEvent *event);
            void mouseReleaseEvent(QMouseEvent *event);
            void mouseMoveEvent(QMouseEvent *event);
            void deplacerCamera();

            private :
            irr::scene::ICameraSceneNode *m_camera;
            bool m_cameraMustMoving;
            long m_mousePosAtClicX;
            long m_mousePosAtClicY;
            long m_mousePosX;
            long m_mousePosY;
}

void FenPrincipale::mousePressEvent(QMouseEvent *event)
{
    if(event->button() == Qt::RightButton)
    {
        if(espaceGraphique->getDevice() != 0)
        {
            m_cameraMustMoving = true;
            m_mousePosAtClicX = event->x();
            m_mousePosAtClicY = event->y();
        }
    }
}
void FenPrincipale::mouseMoveEvent(QMouseEvent *event)
{
    m_mousePosX = event->x();
    m_mousePosY = event->y();
}
void FenPrincipale::deplacerCamera()
{
    if(m_cameraMustMoving)
    {
        long angleX = m_camera->getRotation().X - ((m_mousePosAtClicY-m_mousePosY)*0.02);
        if(angleX < 90 && angleX > -90)
           m_camera->setRotation(irr::core::vector3df(angleX, m_camera->getRotation().Y - ((m_mousePosAtClicX-m_mousePosX)*0.02),0));
    }
}
void FenPrincipale::mouseReleaseEvent(QMouseEvent *event)
{
    if(event->button() == Qt::RightButton)
    {
        m_cameraMustMoving = false;
    }
}

    QTimer* timerDeplacementCamera = new QTimer(this);
    connect(timerDeplacementCamera, SIGNAL(timeout()), this, SLOT(deplacerCamera()));
    timerDeplacementCamera->start(40);

#ifndef HEADER_FENPRINCIPALE
#define HEADER_FENPRINCIPALE

#include <QtGui>
#include "QIrrlicht.h"
#include <irr/irrlicht.h>

class FenPrincipale : public QMainWindow
{
        Q_OBJECT
        public:
                FenPrincipale();
        private slots:
                void enregistrer();
                void gestionaireDeRessource();
                void nouveau();
                void ouvrir();
                void mousePressEvent(QMouseEvent *event);
                void mouseReleaseEvent(QMouseEvent *event);
                void mouseMoveEvent(QMouseEvent *event);
                void deplacerCamera();

        private:
                void ouvrirViaChemin(QString cheminFichier);
                QIrrlicht *espaceGraphique;
                irr::scene::IAnimatedMesh *room;
                irr::scene::ImeshSceneNode *Nroom;
                irr::scene::ICameraSceneNode *m_camera;
                bool m_cameraMustMoving;
                long m_mousePosAtClicX;
                long m_mousePosAtClicY;
                long m_mousePosX;
                long m_mousePosY;

};

#endif

#include "FenPrincipale.h"

void setupIrrlicht(irr::IrrlichtDevice* device )
{
    // Get the scene manager
    irr::scene::ISceneManager* manager = device->getSceneManager();

    // Create a small box
    irr::scene::ISceneNode* node = manager->addCubeSceneNode(75);
    node->setMaterialFlag( irr::video::EMF_LIGHTING, false );

    // Create a camera to view the box
    irr::scene::ICameraSceneNode* cam = manager->addCameraSceneNode();

    cam->setPosition( irr::core::vector3df(100,100,0) );
    cam->setTarget( irr::core::vector3df(0,0,0) );

    irr::scene::ISceneNodeAnimator* anim = manager->createFlyCircleAnimator( irr::core::vector3df(0,0,0), 20 );
    node->addAnimator(anim);
    anim->drop();
}
FenPrincipale::FenPrincipale()
{
//------------------------------------------------------------------------------------------------------------
//---------------------------------------------BARRE-DE-MENUS-------------------------------------------------
//------------------------------------------------------------------------------------------------------------

//------------------------------------------------FICHIER-----------------------------------------------------

        QMenu *menuFichier = menuBar()->addMenu("&Fichier");
      QAction *actionNouveau = menuFichier->addAction("&Nouveau");
            actionNouveau->setShortcut(QKeySequence("Ctrl+N"));
                actionNouveau->setIcon(QIcon("share/new.ico"));
                connect(actionNouveau, SIGNAL(triggered()), this, SLOT(nouveau()));
      QAction *actionOuvrir = menuFichier->addAction("&Ouvrir");
            actionOuvrir->setShortcut(QKeySequence("Ctrl+O"));
                actionOuvrir->setIcon(QIcon("share/open.png"));
                connect(actionOuvrir, SIGNAL(triggered()), this, SLOT(ouvrir()));
      QAction *actionQuitter = menuFichier->addAction("&Enregistrer");
            actionQuitter->setShortcut(QKeySequence("Ctrl+S"));
                actionQuitter->setIcon(QIcon("share/save.ico"));
                connect(actionQuitter, SIGNAL(triggered()), this, SLOT(enregistrer()));
      QAction *actionEnregistrer = menuFichier->addAction("&Quitter");
            actionEnregistrer->setShortcut(QKeySequence("Ctrl+Q"));
                actionEnregistrer->setIcon(QIcon("share/quitter.ico"));
                connect(actionEnregistrer, SIGNAL(triggered()), qApp, SLOT(quit()));

//-----------------------------------------------EDITION------------------------------------------------------
        QMenu *menuEdition = menuBar()->addMenu("&Edition");
          QAction *actionGestionnaireDeTache = menuEdition->addAction("&Gestionaire de Ressource");
            actionGestionnaireDeTache->setShortcut(QKeySequence("F10"));
                actionGestionnaireDeTache->setIcon(QIcon("share/ressource.ico"));
                connect(actionGestionnaireDeTache, SIGNAL(triggered()), this, SLOT(gestionaireDeRessource()));
//------------------------------------------------AIDE--------------------------------------------------------
        QMenu *menuAide = menuBar()->addMenu("&Aide");
          QAction *actionAboutQt = menuAide->addAction("&A propos de Qt");
                actionAboutQt->setIcon(QIcon("share/qt.png"));
                connect(actionAboutQt, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
//------------------------------------------------------------------------------------------------------------
//--------------------------------------------BARRE-D-OUTILS--------------------------------------------------
//------------------------------------------------------------------------------------------------------------
    QToolBar *toolBarFichier = addToolBar("Fichier");
      toolBarFichier->addAction(actionNouveau);
          toolBarFichier->addAction(actionEnregistrer);
                toolBarFichier->addSeparator();
//------------------------------------------------------------------------------------------------------------
//--------------------------------------------ZONE-CENTRALE---------------------------------------------------
//------------------------------------------------------------------------------------------------------------
    QWidget *zoneCentrale = new QWidget;
    espaceGraphique = new QIrrlicht(zoneCentrale);
    setupIrrlicht(espaceGraphique->getDevice());
    QGridLayout *layout = new QGridLayout;
    layout->addWidget(espaceGraphique, 0, 0);
    zoneCentrale->setLayout(layout);

        QTimer* timerDeplacementCamera = new QTimer(this);
    connect(timerDeplacementCamera, SIGNAL(timeout()), this, SLOT(deplacerCamera()));
    //timerDeplacementCamera->start(40);

    setCentralWidget(zoneCentrale);
}
void FenPrincipale::enregistrer()
{

}
void FenPrincipale::gestionaireDeRessource()
{

}
void FenPrincipale::nouveau()
{

}
void FenPrincipale::ouvrir()
{

    ouvrirViaChemin(QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), "Fichier .GWD(*.gwd)"));
}
void FenPrincipale::ouvrirViaChemin(QString cheminFichier)
{
    FILE* fichier = NULL;
    int caractereActuel = 0;
        QString *contenuFichierGWD = new QString;

    fichier = fopen("test1.gwd", "r");

    if (fichier != NULL)
    {
        // Boucle de lecture des caractères un à un
        do
        {
            caractereActuel = fgetc(fichier); // On lit le caractère
            contenuFichierGWD += caractereActuel ;
        } while (caractereActuel != EOF); // On continue tant que fgetc n'a pas retourné EOF (fin de fichier)

        fclose(fichier);
    }
    QRegExp regexMapMesh ("#<mapMesh>(.+)</mapMesh>#isU");
    QRegExp regexMapTexture ("#<mapTexture>(.+)</mapTexture>#isU");
    contenuFichierGWD->contains (regexMapMesh);
    contenuFichierGWD->contains (regexMapTexture);
    room = espaceGraphique->getSceneManager()->getMesh("room.3ds");
    Nroom = espaceGraphique->getSceneManager()->addMeshSceneNode(room->getMesh(0));
    Nroom->setMaterialFlag(irr::video::EMF_LIGHTING, true);
    //Nroom->setMaterialTexture( 0, espaceGraphique->getDriver()->getTexture(regexMapTexture.cap (1)).toStdString().c_str() );
    Nroom->setMaterialTexture( 0, espaceGraphique->getDriver()->getTexture("rockwall.jpg"));
    espaceGraphique->qetGui()->addImage(espaceGraphique->getDriver()->getTexture ("2ddemo.bmp"), irr::core::position2d<irr::s32>(5,5), true, 0,-1,0);
    espaceGraphique->getSceneManager()->getMeshManipulator()->makePlanarTextureMapping(room->getMesh(0), 0.004);
}


void FenPrincipale::mousePressEvent(QMouseEvent *event)
{
    if(event->button() == Qt::RightButton)
    {
        if(espaceGraphique->getDevice() != 0)
        {
            m_cameraMustMoving = true;
            m_mousePosAtClicX = event->x();
            m_mousePosAtClicY = event->y();
        }
    }
}
void FenPrincipale::mouseMoveEvent(QMouseEvent *event)
{
    m_mousePosX = event->x();
    m_mousePosY = event->y();
}
void FenPrincipale::deplacerCamera()
{
    if(m_cameraMustMoving)
    {
        double angleX = m_camera->getRotation().X - ((m_mousePosAtClicY-m_mousePosY)*0.02);
        if(angleX < 90 && angleX > -90)
        {
           m_camera->setRotation(irr::core::vector3df(angleX, m_camera->getRotation().Y - ((m_mousePosAtClicX-m_mousePosX)*0.02),0));
        }
    }
}
void FenPrincipale::mouseReleaseEvent(QMouseEvent *event)
{
    if(event->button() == Qt::RightButton)
    {
        m_cameraMustMoving = false;
    }
}

#ifndef QIRRLICHT_H
#define QIRRLICHT_H

#include <qwidget.h>
#include <irr/irrlicht.h>
#include <qfont.h>

class QPaintEvent;

class QIrrlicht : public QWidget
{
    Q_OBJECT

public:
    irr::IrrlichtDevice* getDevice();
    irr::scene::ISceneManager* getSceneManager();
    irr::gui::IGUIEnvironment* qetGui();
    irr::video::IVideoDriver* getDriver();

    void setDriverType( irr::video::E_DRIVER_TYPE driver );

    QIrrlicht( QWidget *parent=0 );
    ~QIrrlicht();

    void init();

public slots:
    void autoUpdateIrrlicht( irr::IrrlichtDevice* device );

signals:
    void updateIrrlicht( irr::IrrlichtDevice* device );

protected:
    irr::video::E_DRIVER_TYPE driverType;

    virtual void paintEvent( QPaintEvent* event );

    void sendKeyEventToIrrlicht( QKeyEvent* event, bool pressedDown );
    virtual void keyPressEvent( QKeyEvent* event );
    virtual void keyReleaseEvent( QKeyEvent* event );

    void sendMouseEventToIrrlicht( QMouseEvent* event, bool pressedDown );
    virtual void mousePressEvent( QMouseEvent* event );
    virtual void mouseReleaseEvent( QMouseEvent* event );
    virtual void wheelEvent( QWheelEvent* event );

    virtual void timerEvent( QTimerEvent* event );

    virtual void resizeEvent( QResizeEvent* event );


private:
    irr::IrrlichtDevice* device;
    irr::scene::ISceneManager* sceneManager;
    irr::gui::IGUIEnvironment* gui;
    irr::video::IVideoDriver* driver;
    QWidget *m_parent;
};

#endif // QIRRLICHT_H

#include "qirrlicht.h"
#include <qpalette.h>
#include <QKeyEvent>
#include <QMouseEvent>
#include <qpainter.h>

using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

QIrrlicht::QIrrlicht( QWidget *parent )
    : QWidget(parent)
{
   device = 0;
   driverType = irr::video::EDT_OPENGL;
   m_parent = parent;

   init();
}

QIrrlicht::~QIrrlicht()
{
    if ( device != 0 )
    {
        device->closeDevice();
        device->run();
        device->drop();
    }
}

void QIrrlicht::init()
{
    if ( device != 0 ) return;

    irr::SIrrlichtCreationParameters params;

    params.DriverType = driverType;
    params.WindowId = (void*)winId();
    params.WindowSize.Width = 400;
    params.WindowSize.Height = 800;
    //setMinimumSize(params.WindowSize.Width,params.WindowSize.Height);
    setMinimumSize(600,600);
    setMaximumSize(800,800);
    setAttribute(Qt::WA_OpaquePaintEvent);

    device = irr::createDeviceEx( params );
    driver = device->getVideoDriver();
    sceneManager = device->getSceneManager();
    gui = device->getGUIEnvironment();



    connect( this, SIGNAL(updateIrrlicht(irr::IrrlichtDevice*)),
             this, SLOT(autoUpdateIrrlicht(irr::IrrlichtDevice*)) );
    startTimer(0);
}


irr::IrrlichtDevice* QIrrlicht::getDevice()
{
    return device;
}

void QIrrlicht::paintEvent( QPaintEvent* event )
{
    if ( device != 0 )
    {
        emit updateIrrlicht( device );

    }

}

void QIrrlicht::timerEvent( QTimerEvent* event )
{
    if ( device != 0 )
    {
        emit updateIrrlicht( device );
    }
    event->accept();
}


void QIrrlicht::resizeEvent( QResizeEvent* event )
{
    if ( device != 0 )
    {
        irr::core::dimension2d<unsigned int> size;
        if(event->size().height() < event->size().width())
        {
            size.Width = event->size().height();
            size.Height = event->size().height();
        }
        else if(event->size().height() > event->size().width())
        {
            size.Width = event->size().width();
            size.Height = event->size().width();
        }
        else if(event->size().height() == event->size().width())
        {
            size.Width = event->size().width();
            size.Height = event->size().height();
        }
        device->getVideoDriver()->OnResize( size );
        resize(size.Width,size.Height);

        irr::scene::ICameraSceneNode *cam = device->getSceneManager()->getActiveCamera();
        if ( cam != 0 )
        {
            cam->setAspectRatio( size.Height / size.Width );
        }
    }
    QWidget::resizeEvent(event);
}

void QIrrlicht::autoUpdateIrrlicht( irr::IrrlichtDevice* device )
{
    device->getTimer()->tick();

    irr::video::SColor color (0,0,0,0);

    device->getVideoDriver()->beginScene( true, true, color );

    device->getSceneManager()->drawAll();
    device->getGUIEnvironment()->drawAll();

    device->getVideoDriver()->endScene();
}

struct SIrrlichtKey
{
    irr::EKEY_CODE code;
    wchar_t ch;
};

SIrrlichtKey convertToIrrlichtKey( int key )
{
    SIrrlichtKey irrKey;
    irrKey.code = (irr::EKEY_CODE)(0);
    irrKey.ch = (wchar_t)(0);

    // Letters A..Z and numbers 0..9 are mapped directly
    if ( (key >= Qt::Key_A && key <= Qt::Key_Z) || (key >= Qt::Key_0 && key <= Qt::Key_9) )
    {
        irrKey.code = (irr::EKEY_CODE)( key );
        irrKey.ch = (wchar_t)( key );
    }
    else

    // Dang, map keys individually
    switch( key )
    {
    case Qt::Key_Up:
        irrKey.code = irr::KEY_UP;
        break;

    case Qt::Key_Down:
        irrKey.code = irr::KEY_DOWN;
        break;

    case Qt::Key_Left:
        irrKey.code = irr::KEY_LEFT;
        break;

    case Qt::Key_Right:
        irrKey.code = irr::KEY_RIGHT;
        break;
    }
    return irrKey;
}

void QIrrlicht::sendKeyEventToIrrlicht( QKeyEvent* event, bool pressedDown )
{
    irr::SEvent irrEvent;

    irrEvent.EventType = irr::EET_KEY_INPUT_EVENT;

    SIrrlichtKey irrKey = convertToIrrlichtKey( event->key() );

    if ( irrKey.code == 0 ) return; // Could not find a match for this key

    irrEvent.KeyInput.Key = irrKey.code;
    irrEvent.KeyInput.Control = ((event->modifiers() & Qt::ControlModifier) != 0);
    irrEvent.KeyInput.Shift = ((event->modifiers() & Qt::ShiftModifier) != 0);
    irrEvent.KeyInput.Char = irrKey.ch;
    irrEvent.KeyInput.PressedDown = pressedDown;

    device->postEventFromUser( irrEvent );
}

void QIrrlicht::keyPressEvent( QKeyEvent* event )
{
    if ( device != 0 )
    {
        sendKeyEventToIrrlicht( event, true );
    }
    event->ignore();
}

void QIrrlicht::keyReleaseEvent( QKeyEvent* event )
{
    if ( device != 0 )
    {
        sendKeyEventToIrrlicht( event, false );
    }
    event->ignore();
}

void QIrrlicht::sendMouseEventToIrrlicht( QMouseEvent* event, bool pressedDown )
{
    irr::SEvent irrEvent;

    irrEvent.EventType = irr::EET_MOUSE_INPUT_EVENT;

    switch ( event->button() )
    {
    case Qt::LeftButton:
        irrEvent.MouseInput.Event = pressedDown? irr::EMIE_LMOUSE_PRESSED_DOWN:irr::EMIE_LMOUSE_LEFT_UP;
        break;

    case Qt::MidButton:
        irrEvent.MouseInput.Event = pressedDown? irr::EMIE_MMOUSE_PRESSED_DOWN:irr::EMIE_MMOUSE_LEFT_UP;
        break;

    case Qt::RightButton:
        irrEvent.MouseInput.Event = pressedDown? irr::EMIE_RMOUSE_PRESSED_DOWN:irr::EMIE_RMOUSE_LEFT_UP;
        break;

    default:
        return; // Cannot handle this mouse event
    }

    irrEvent.MouseInput.X = event->x();
    irrEvent.MouseInput.Y = event->y();
    irrEvent.MouseInput.Wheel = 0.0f; // Zero is better than undefined

    device->postEventFromUser( irrEvent );
}

void QIrrlicht::mousePressEvent( QMouseEvent* event )
{
    if ( device != 0 )
    {
        sendMouseEventToIrrlicht( event, true );
    }
    event->ignore();
}

void QIrrlicht::mouseReleaseEvent( QMouseEvent* event )
{
    if ( device != 0 )
    {
        sendMouseEventToIrrlicht( event, false );
    }
    event->ignore();
}

void QIrrlicht::wheelEvent( QWheelEvent* event )
{
    if ( device != 0 && event->orientation() == Qt::Vertical )
    {
        irr::SEvent irrEvent;

        irrEvent.EventType = irr::EET_MOUSE_INPUT_EVENT;

        irrEvent.MouseInput.Event = irr::EMIE_MOUSE_WHEEL;
        irrEvent.MouseInput.X = 0; // We don't know these,
        irrEvent.MouseInput.Y = 0; // but better zero them instead of letting them be undefined
        irrEvent.MouseInput.Wheel = event->delta() / 120.0f;

        device->postEventFromUser( irrEvent );
    }
    event->ignore();
}
irr::video::IVideoDriver* QIrrlicht::getDriver()
{
        return driver;
}
irr::scene::ISceneManager* QIrrlicht::getSceneManager()
{
        return sceneManager;
}
irr::gui::IGUIEnvironment* QIrrlicht::qetGui()
{
        return gui;
}

#include <QApplication>
#include <QTranslator>
#include <QLocale>
#include <QLibraryInfo>
#include "FenPrincipale.h"

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    FenPrincipale principale;
    principale.show();

    return app.exec();
}