bonjour tout le monde,

voilà j'ai un problème avec mon code et je ne sais pas comment le résoudre. J'ai posé la question sur le forum du siteduzero mais le problème n'a pas été résolu.
Comme il concerne irrlicht je vais maintenant vous le présenter.
J'ai une classe afficherImage qui doit charger une image et récupérer sa position. Mais il doit y avoir un problème quelque part parce que quand je veux récupérer la position de l'image dans la boucle de rendu de mon main, ma compilation plante.
Voici mon code:

main.cpp

#include <irrlicht.h>
#include <iostream>
#include "main.hpp"

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

AfficherImage* afficherImage;//C'est la seule chose qui est dans le main.hpp donc je le met ici

int main()
{
    video::E_DRIVER_TYPE driverType = video::EDT_OPENGL;

        IrrlichtDevice *Device = createDevice(EDT_SOFTWARE, dimension2d<s32>(800, 600), 16,
                        false, false, false, 0);

    if (Device == 0)
    return 1; // could not create selected driver.

        Device->setWindowCaption(L"Equilibrum : La malediction");

        IVideoDriver* driver = Device->getVideoDriver();
        ISceneManager* smgr = Device->getSceneManager();
        IGUIEnvironment* guienv = Device->getGUIEnvironment();

    afficherImage->afficherMenu();

        Device->setResizeAble(true);


        while(Device->run())
        {
            u32 time = Device->getTimer()->getTime();

                driver->beginScene(true, true, SColor(0,0,0,0));

        driver->draw2DImage(afficherImage->get_interfaceMenu(), afficherImage->get_rectangle(),
        SColor (255,255,255,255), true);

        //pour afficher les positions du curseur dans la barre de titre :
        core::position2d<s32> mouse = Device->getCursorControl()->getPosition();

        //pour afficher les positions du curseur dans la barre de titre :
        core::stringw titre = L"Positions de la souris :";
        titre += mouse.X;
        titre += L"-";
        titre += mouse.Y;

        Device->setWindowCaption(titre.c_str());

                smgr->drawAll();
                guienv->drawAll();

                driver->endScene();
        }

        Device->drop();

        return 0;
}

#include <irrlicht.h>
#include <iostream>
#include "afficherImage.hpp"

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

int AfficherImage::afficherMenu()
{
    interfaceMenu = driver->getTexture ("Interface/interface_hors_jeu/menu_principale/interfaceMenu1.PNG");
    if (interfaceMenu == 0)
    {
        cout << "probleme de chargement de l'image" << endl;
        return 1;
    }

    //La transparence pour le fond
    driver->makeColorKeyTexture (interfaceMenu, video::SColor (0,255,0,255));

    //On récupère les dimensions de l'image
    dimension2d<s32> taille = interfaceMenu->getSize ();

    //On crée une position qui va représenter l'origine
    position2d<s32> position0;
    position0.X = 0;
    position0.Y = 0;
    //Et maintenant la position du coin bas droit du rectangle en se servant des dimensions de l'image
    position2d<s32> position1;
    position1.X = taille.Width;
    position1.Y = taille.Height;

    //On crée la variable rectangle
    rect<s32> rectangle;
    rectangle.UpperLeftCorner = position0;
    rectangle.LowerRightCorner = position1;
}

#include <irrlicht.h>
#include <iostream>

#ifndef DEF_AFFICHER_IMAGE
#define DEF_AFFICHER_IMAGE

class AfficherImage
{
  public:

    AfficherImage();
    ~AfficherImage();

    int afficherMenu();

    irr::core::position2d<irr::s32> get_position0()
    {
        return position0;
    }
    irr::core::position2d<irr::s32> get_position1()
    {
        return position1;
    }
    irr::core::rect<irr::s32> get_rectangle()
    {
        return rectangle;
    }

    irr::video::ITexture* get_interfaceMenu()
    {

        return interfaceMenu;
    }



    private:

    irr::video::IVideoDriver* driver;
    irr::video::ITexture *interfaceMenu;
    irr::core::position2d<irr::s32> position0;
    irr::core::position2d<irr::s32> position1;
    irr::core::rect<irr::s32> rectangle;


};

#endif

main.cpp:54: error: no matching function for call to `irr::video::IVideoDriver::draw2DImage(irr::video::ITexture*, irr::core::rect<irr::s32>, irr::video::SColor, bool)'
C:/Program Files/CodeBlocks/mingw32/include/Irrlicht/IVideoDriver.h:481: note: candidates are: virtual void irr::video::IVideoDriver::draw2DImage(irr::video::ITexture*, const irr::core::position2d<irr::s32>&)
C:/Program Files/CodeBlocks/mingw32/include/Irrlicht/IVideoDriver.h:498: note: virtual void irr::video::IVideoDriver::draw2DImage(irr::video::ITexture*, const irr::core::position2d<irr::s32>&, const irr::core::rect<irr::s32>&, const irr::core::rect<irr::s32>*, irr::video::SColor, bool)
C:/Program Files/CodeBlocks/mingw32/include/Irrlicht/IVideoDriver.h:523: note: virtual void irr::video::IVideoDriver::draw2DImage(irr::video::ITexture*, const irr::core::position2d<irr::s32>&, const irr::core::array<irr::core::rect<irr::s32>, irr::core::irrAllocator<irr::core::rect<irr::s32> > >&, const irr::core::array<irr::s32, irr::core::irrAllocator<irr::s32> >&, irr::s32, const irr::core::rect<irr::s32>*, irr::video::SColor, bool)
C:/Program Files/CodeBlocks/mingw32/include/Irrlicht/IVideoDriver.h:535: note: virtual void irr::video::IVideoDriver::draw2DImage(irr::video::ITexture*, const irr::core::rect<irr::s32>&, const irr::core::rect<irr::s32>&, const irr::core::rect<irr::s32>*, irr::video::SColor*, bool)

yop,
Comme dit dans l'erreur, tu appelles mal la fonction draw2Dimage :
elle doit avoir en paramètre (par exemple, il y a différentes surcharges possibles citées dans l'erreur) texture, destRec, soureRect, clipRect, color, alpha, ce qui doit te donner par exemple :
(dans la boucle)

driver->draw2DImage(afficherImage->get_interfaceMenu(),
                                  afficherImage->get_rectangle(),
                                  afficherImage->get_ImageSize() /* à implémenter ! */
                                  0
                                  SColor (255,255,255,255), 
                                  true);

j'ai suivi tes conseils et j'ai déjà résolu le problème du driver
je suis allé voir l'exemple 06, mais il y a un truc que j'ai pas compris :

c'est dans cette fonction

driver->draw2DImage(images, core::position2d<s32>(270,105),
				(time/500 % 2) ? imp1 : imp2, 0, 
				video::SColor(255,(time) % 255,255,255), true);

(time/500 % 2) ? imp1 : imp2

C'est un raccourci de if
ca se traduit par
if (time / 500 % 2)
valeur = imp1
else
valeur = imp2

ok merci

j'ai modifié mon code et maintenant la compilation marche (c'est déjà une bonne chose), mais l'image ne veut pas s'afficher.

voici le nouveau "code":

driver->draw2DImage(afficherImage->get_interfaceMenu(),
                                afficherImage->get_position0(),
                                afficherImage->get_rectangle(), 0,
                                SColor (255,255,255,255), true);

vérifie bien que le get_Rectangle retourne la taille de l'image

ma fonction rectangle et son contexte:

interfaceMenu = driver->getTexture ("interface.PNG");
    if (interfaceMenu == 0)
    {
        cout << "probleme de chargement de l'image" << endl;
        return 1;
    }

    //La transparence pour le fond
    driver->makeColorKeyTexture (interfaceMenu, video::SColor (0,255,0,255));

    //On récupère les dimensions de l'image
    dimension2d<s32> taille = interfaceMenu->getSize ();

    //On crée une position qui va représenter l'origine
    position2d<s32> position0;
    position0.X = 0;
    position0.Y = 0;
    //Et maintenant la position du coin bas droit du rectangle en se servant des dimensions de l'image
    position2d<s32> position1;
    position1.X = taille.Width;
    position1.Y = taille.Height;

    //On crée la variable rectangle
    rect<s32> rectangle;
    rectangle.UpperLeftCorner = position0;
    rectangle.LowerRightCorner = position1;

Performance warning, slow unlock of non power of 2 texture.

Salut,
Ca veut dire que ta texture n'est pas une puissance de 2 donc qu'elle ne respecte pas le standard 128*128 ou 128*256 ou 256*256 etc....

normal j'ai une 800*600
mais c'est pas grave si je laisse sa comme ça ?

bin si
Ca risque de merder/pas marcher sur certaines cartes graphiques.
En revanche je sais pas trop si ça vient de là

hmm c'est facheux

je résous (si vous pourriez m'aider sa serait plus rapide ^^) mon problème d'affichage et j'essaye ensuite de changer ça.
Par contre je ne vois pas comment faire pour mon pb n°1. Logiquement tout doit être bon, mais apparament c'est pas le cas.

Na avant tout,vérifi bien que tes textures sont toute en ^2 sinon on peut même pas avoir la certitude que ta carte va l'afficher et par conséquent si le problème vient de là on va tous perdre notre temps .

j'ai chargé qu'une seule image donc si l'erreur vient de quelque part c'est de là.
j'ai créé une image en 256*256 et l'erreur a disparu donc izguit tu avais raison
mais même en ayant changé cette image elle ne s'affiche toujours pas. Il doit y avoir une erreur quelque part

ideo::E_DRIVER_TYPE driverType = video::EDT_OPENGL;

        IrrlichtDevice *Device = createDevice(EDT_SOFTWARE, dimension2d<s32>(800, 600), 16,
                        false, false, false, 0);

très bonne remarque j'avais pas fais gaffe a sa.
Mais le problème est toujours là

personne n'a d'idée ?

c'est bon mon programme marche. Merci a ceux qui m'ont aider