Bonjour tout le monde,

Je voudrais savoir comment faire pour que mon IGUIEnvironment du main soit le même que celui que j'utilise dans ma classe.
Je m'explique : je crée des boutons dans une classe AfficherImage et leur donne a chacun une image différente. Le seul problème c'est que la compilation plante quand je fais ça.
J'ai essayé d'ajouter un constructeur en me basant sur le modèle de constructeur pour le driver qu'on m'avais donné. La compilation marche mais le programme m'affiche une erreur. J'aimerais savoir pourquoi ?

Voila a quoi ressemble mon constructeur:

AfficherImage::AfficherImage(IGUIEnvironment *irrguienv)
{
   guienv = irrguienv;
}

Il faudrait que tu nous montres plus de code, le problème vient certainement de l'utilisation que tu en fais, pas de son initialisation.
Sinon, moi je préfère passer le device en paramètre : grâce à lui, tu peux récupérer (entre autres) le guienv (device->getGUIEnvironment ()) le gestionnaire de scènes (device->getSceneManager ()) et le driver vidéo (device->getVideoDriver ())

voila le code:

AfficherImage.cpp

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

AfficherImage::AfficherImage(IVideoDriver *irrdriver)
{
   driver = irrdriver;
}

AfficherImage::AfficherImage(IGUIEnvironment *irrguienv)
{
   guienv = irrguienv;
}

int AfficherImage::imageBouton()
 {
    lienJoueur = driver->getTexture ("Interface/base/interface_hors_jeu/menu_principal/lien/lien_joueur.PNG");
    if (lienJoueur == 0)
    {
        cout << "probleme de chargement de l'image" << endl;
        return 1;
    }

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

    lienOption = driver->getTexture ("Interface/base/interface_hors_jeu/menu_principal/lien/lien_options.PNG");
    if (lienOption == 0)
    {
        cout << "probleme de chargement de l'image" << endl;
        return 1;
    }

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

    lienCredits = driver->getTexture ("Interface/base/interface_hors_jeu/menu_principal/lien/lien_devs.PNG");
    if (lienCredits == 0)
    {
        cout << "probleme de chargement de l'image" << endl;
        return 1;
    }

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

    lienQuitter = driver->getTexture ("Interface/base/interface_hors_jeu/menu_principal/lien/lien_quitter.PNG");
    if (lienQuitter == 0)
    {
        cout << "probleme de chargement de l'image" << endl;
        return 1;
    }

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

    boutonJoueur = guienv->addButton(core::rect<s32>(214,99,379,227), 0, 1, L"");
	boutonOptions = guienv->addButton(core::rect<s32>(388,99,553,227), 0, 2, L"");
    boutonCredits = guienv->addButton(core::rect<s32>(214,305,379,432), 0, 3, L"");
    boutonQuitter = guienv->addButton(core::rect<s32>(388,305,553,432), 0, 4, L"");

    boutonJoueur->setImage(lienJoueur);
    boutonOptions->setImage(lienOption);
    boutonCredits->setImage(lienCredits);
    boutonQuitter->setImage(lienQuitter);
 }

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

#ifndef DEF_AFFICHER_IMAGE
#define DEF_AFFICHER_IMAGE

class AfficherImage
{
  public:

    AfficherImage(irr::video::IVideoDriver* irrdriver);
    AfficherImage(irr::gui::IGUIEnvironment *irrguienv);
    ~AfficherImage();

    int afficherMenu();
    int imageBouton();

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

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

        return lienJoueur;
    }

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

        return lienOption;
    }

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

        return lienCredits;
    }

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

        return lienQuitter;
    }

   private:

    irr::IrrlichtDevice *Device;
    irr::video::IVideoDriver* driver;
    irr::gui::IGUIEnvironment* guienv;
    irr::video::ITexture *interfaceMenu;
    irr::core::position2d<irr::s32> position0;
    irr::core::position2d<irr::s32> position1;
    irr::core::rect<irr::s32> rectangle;
    irr::gui::IGUIButton* boutonJoueur;
    irr::gui::IGUIButton* boutonCredits;
    irr::gui::IGUIButton* boutonOptions;
    irr::gui::IGUIButton* boutonQuitter;
    irr::video::ITexture *lienJoueur;
    irr::video::ITexture *lienOption;
    irr::video::ITexture *lienCredits;
    irr::video::ITexture *lienQuitter;
};

#endif

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

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

#pragma comment(lib, "Irrlicht.lib")
AfficherImage* afficherImage;


int main()
{
    IrrlichtDevice *Device = createDevice(EDT_OPENGL, 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 = new AfficherImage(driver);
    afficherImage = new AfficherImage(guienv);

    afficherImage->afficherMenu();
    afficherImage->imageBouton();

    Device->setResizeAble(true);


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

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


        driver->draw2DImage(afficherImage->get_interfaceMenu(),
                            afficherImage->get_position0(),
                            afficherImage->get_rectangle(), 0,
                            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;
}

Bon, l'erreur vient de ton main. Tu déclares un AfficherImage avant le main, mais tu veux l'initialiser deux fois

    afficherImage = new AfficherImage(driver);
    afficherImage = new AfficherImage(guienv);

Passer le device en paramètre de quoi (^^')?

AfficherImage::AfficherImage(IrrlichtDevice* device)
{
   Device=device;
   driver=device->getVideoDriver ();
   guienv=Device->getGUIEnvironment ();
}

d'accord. Je vais essayer de l'appliquer.

Merci beaucoup

De rien