J'essaye moi aussi d'intégrer Irrlicht à Qt grâce au code de Ilovechocolat, mais cela bloque a certain endroit. Mais j'ai quelques problèmes : le programme n'arrive pas a afficher les images (que ça soit les textures pour la parie 3D et les icones pour les menues de Qt), et aussi, les événements ne marche pas et quand je rajoute le timerDeplacementCamera->start(40); cela fais complément planter l'application.

Voici mon code source, mais celui-ci est exactement le même que celui que Ilovechocolat a donné:

fenprincipale.h

#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

fenprincipale.cpp

#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;
    }
}

Qirrlicht.h

#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

Qirrlicht.cpp

#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;
}

main.cpp

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

S'avez-vous pouquoi ça ne marche pas?