euh, Ilovechocolat, le fichier que tu envoie continent les codes qui fonctionne ou les codes pour X3liF ?

Comment ça les codes pour X3liF ?
C'est les codes de mon projet (combinaison de l'ancien et du tiens) qui compiles mais l'espace Irrlicht est noir.

a ok, donc je voulais juste en faite savoir si c'était parce que t'avais réussi à le faire fonctionner que tu mettais le code lol

J'ai réussit, ça marche mais c'est pas encore au point, quand on redimensionne la fenêtre l'écran devient noir, je vais peaufiner tout ça ...
[EDIT]bon ben après une étude plus précise, ça marche quand on redimensionne en latéral mais au bout d'au moment, la redimension horizontal bug, l'écran d'irrlicht devient noir.

met ton code stp, j'aimerais bien que sa marche aussi chez moi, mais moi j'ai bloqué le redimentionnement donc sa marcherai lol stp ^^

EDIT : OK mais le code please-_-

tu aurrais essayer de modifier la taille de rendu d'irrlicht apres resize ? bon ses certainement pas ça mais ça devrait écarter qu'elle que bug a venir ...

IVideoDriver::OnResize(const core::dimension2d< u32 > &size)

Voici mon code, comme la ça bug après 800px d'agrandissement en largeur, j'ai donc limité la taille a 800 avec un redimensionnement automatique pour obtenir un espace 3D toujours carré.
télécharger

je te remerci, sa marche enfin^^, et encore bien joué

re bonjour à tous dsl pour les réponses tardives...

mon code marche bien, pour créer des noeuds dans le graphe de scène il faut juste le faire après la fonction d'initialisation dans une autre méthode ( du moins c'est ce que je fais )

c'est surement pour laisser le temps à irrlicht de s'initialiser correctement car il fonctionne me semble t'il dans un thread à part...

vous voulez que je vous donne un ptit code qui fonctionne?

[EDIT] ah oui j'ai bien le soucis au redimensionnement :$ j'avais pas essayé de redimensionner la fenetre :$ je termine mon utilisation des shaders et vais tenter de corriger ca

Moi j'ai des problèmes pour la gestion de la caméra, je voulait faire un truc du genre trackball (sauf qu'au lieu de faire tourner l'environnement on fessait tourner la camera) mais c'est quasi impossible ...
Les évènements Irrlicht ne marchent plus et ceux de Qt sont un peut limité je trouve.
Pour l'instant je fais mes tests avec des contrôles au clavier totalement horrible a prendre en main.

Bref, vous avez géré votre caméra comment vous ?

par encore géré la caméra :$ j'en suis aux phases de tests afin de permettre de vior les possibilités du moteur

euh comment ca les évènements Qt sont limités? tu veux faire quoi exactement? quand tu bouges la souris tu bouge ta caméra?

La caméra trackball c'est ça.
C'est la même que dans google eart..

Bonjour, désolé de ne pas avoir été là plutôt. C'est sans doute trop tard mais on ne sait jamais. Je vais essayer de vous filer des bouts de code qui m'ont permis d'intégrer parfaitement Qt avec Irrlicht, ça fait plusieurs mois que ça tourne. D'ailleurs Tmyke, je ferai ma présentation de projet robotique pendant les vacances de noël afin d'honorer cette section.

Alors je fais simple, voici le .pro pour être vraiment compatible linux et windows:

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
}

euh je suis toujours avec irrlicht 1.6, j'atteds qu'un ebuild pour gentoo soit créé...

lors du redimensionnement on faisait une division d'entiers alors que le ratio est un flottant... donc on obtenait 09 ce qui causait une perte de rendu...

ce bug est étrang.... en effet, le redimensionnement est correct à savoir que dans le videoDrivers la fonction getScreenSize() renvoie la bonne taille de fenetre, lorsque j'ajoute un élément dans la scène, le resize de l'image semble bon mais elle est tronquée à la taille d'origine de la fenêtre Qt ....

j'ai fini la gestion de ma caméra, cadeau du nouvel an :

.h

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

oki merci pour ton cadeau mais... tu n'as pas deja un timer de rendu? tu veux vraiment utiliser un autre timer pour les évènements clavier? ca fait pas un peu doublons?

X3liF -> tu peut toujours le connecter au signal de QIrrlichtWidget.

Sinon j'ai un autre problème, je sais pas si ça vous le fait mais quand je met deux widget irrlicht, cela crée des interférences.

malheuresement je n'ai pas essayé de faire ca...

j'avais vu un souci de création de widgets avec irrlicht... dnas la deuxième widget on ne pouvait pas créer le contexte openGL pour le rendu... est de ce problème que tu parles? c'était du je crois au pilote openGL utilisé sur la machine...

Même si pour le deuxième widget j'utilise DirectX, ça marche pas non plus.

j'ai un leger souci aussi pas d'affichage sur l'une des deux fenetres et le timer de rendu qui merdouille apparement j'ai 30fps par fenetre au lieu de 60fps mon proco est pas utilisé à 100% pourtant
est cela les perturbations dont tu parlais? je ne sais pas à quoi elles sont dues... et en plus j'utilise la version 1.5.1 d'irrlicht je suis pas encore passé sur la v6 :$

Pour informations irrlicht 1.6.1 redimensionne correctement la fenetre avec les evènements Qt ya plus de bugs à ce niveau la

j'ai par contre pas d'explications pour le bug des 2fenetres :s je chercherais plus tard si j'ai le temps je ne me sert que d'une fenetre pour le rendu et ne pense pas en avoir besoin de deux avant un très long moment :$

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

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

Je me permet de remonter ce vieux sujet car j'ai un problème, étant récemment passé sous linux (kubuntu) je viens de me rendre compte que cela ne marche plus, le rendu d'irrlicht n'est plus visible, si j'enlève cette ligne : "params.WindowId = (void*)winId();", le rendu d'irrlicht se fait correctement mais dans une fenêtre séparé (donc le problème vient forcement du windowsID), c'est surement une bête erreur de cast mais je n'arrive pas a résoudre ce problème .

Good for the forum here. I'm trying to do the same but with irrlicht 1.8 and qt 5 I fail. I'm about to die trying. I could not download the files you have left because it seems they are no longer online. If you can help me thank you very much. Thanks in advance.

I do not speak French, but I'll try.

Bon pour le forum ici. J'essaie de faire la même chose mais avec Irrlicht 1,8 et 5 qt je échec. Je suis sur le point de mourir en essayant. Je ne pouvais pas télécharger les fichiers que vous avez laissés, car il semble qu'ils ne sont plus en ligne. Si vous pouvez m'aider merci beaucoup. Merci à l'avance.