Bonjours a tous !

Mon jeu commençant a se développer, je souhaite réaliser un éditeur (pour simplifier le placement d'objet, la gestion des évents, des ressources, des personnages ...).
Pour cela j'aimerais utiliser Qt, une library que j'aime beaucoup de par sa simplicité. J'ai donc essayé d'intégrer Irrlicht dans une fenêtre Qt.
Le seul poste traitant de ce sujet que j'ai pus trouver est celui ci.

Le compilo m'insulte de la manière suivante

Exception de première chance à 0x101517b7 dans game world editor.exe : 0xC0000005: Violation d'accès lors de la lecture de l'emplacement 0x386db6fa.
Exception non gérée à 0x101517b7 dans game world editor.exe : 0xC0000005: Violation d'accès lors de la lecture de l'emplacement 0x386db6fa.

Et m'indique une erreur dans QIrrlicht.cpp a la ligne 12 ("driver = device->getVideoDriver();").

Et voici le code (la partie intéressante c'est surtout QIrrlicht (dernier fichier)) :

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

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();
	private:
		void ouvrirViaChemin(QString cheminFichier);
		QIrrlicht *espaceGraphique;
		irr::scene::IAnimatedMesh *room;
		irr::scene::IMeshSceneNode *Nroom;
};

#endif

FenPrincipale.cpp

#include "FenPrincipale.h"

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\
ew.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\
essource.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;
    QIrrlicht *espaceGraphique = new QIrrlicht(zoneCentrale);
    QGridLayout *layout = new QGridLayout;
    layout->addWidget(espaceGraphique, 0, 0);
    zoneCentrale->setLayout(layout);

    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"/*regexMapMesh.cap (1).toStdString().c_str()*/);
    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() );
    espaceGraphique->getSceneManager()->getMeshManipulator()->makePlanarTextureMapping(room->getMesh(0), 0.004);
}

QIrrlicht.h

#ifndef QIRRLICHT_H
#define QIRRLICHT_H

#include <QtGui>
#include <IRR/irrlicht.h>

class QIrrlicht : public QWidget
{
    Q_OBJECT
public:
    QIrrlicht(QWidget *parent = 0);
    ~QIrrlicht();
    irr::video::IVideoDriver* getDriver();
    irr::scene::ISceneManager* getSceneManager();
    irr::gui::IGUIEnvironment* qetGui();
    irr::IrrlichtDevice* getDevice();
private slots:
    void irrlichtMaj();
private:
    irr::video::IVideoDriver* driver;
    irr::scene::ISceneManager* sceneManager;
    irr::gui::IGUIEnvironment* gui;
    irr::IrrlichtDevice* device;
	irr::scene::ICameraSceneNode *camera;
};
#endif // QIRRLICHT_H

QIrrlicht.cpp

#include "QIrrlicht.h"

QIrrlicht::QIrrlicht(QWidget *parent)
    : QWidget(parent)
{
    //Irrlicht setup
	irr::SIrrlichtCreationParameters parametres;
    parametres.WindowId = parent->winId();
	parametres.DriverType = irr::video::EDT_OPENGL;

    device = createDeviceEx(parametres);
    driver = device->getVideoDriver();
    sceneManager = device->getSceneManager();
      //sceneManager->setAmbientLight(irr::video::SColorf(1.0, 1.0, 1.0,0.0));
    gui = device->getGUIEnvironment();
      gui->getSkin()->setFont(gui->getFont("ressources/images/interface/fontLucida.png"));

    //slot
	
    QTimer *timer = new QTimer(this);
    connect(timer, SIGNAL(timeout()), this, SLOT(irrlichtMaj()));
    timer->start();

	camera = sceneManager->addCameraSceneNode (0, irr::core::vector3df(0,90,0), irr::core::vector3df(0,90,0));
}
QIrrlicht::~QIrrlicht()
{
}
irr::video::IVideoDriver* QIrrlicht::getDriver()
{
	return driver;
}
irr::scene::ISceneManager* QIrrlicht::getSceneManager()
{
	return sceneManager;
}
irr::gui::IGUIEnvironment* QIrrlicht::qetGui()
{
	return gui;
}
irr::IrrlichtDevice* QIrrlicht::getDevice()
{
	return device;
}
void QIrrlicht::irrlichtMaj()
{
	driver->beginScene(true, true, irr::video::SColor(255,100,101,140));
    sceneManager->drawAll();
    driver->endScene();
}