Bonjour,

Je suis entrain de coder mes événements pour la manette XBOX360 PC, pour cela j'utilise SDL.
Tout ce passait bien lorsque je codais dans le main. Alors je me suis dis, pourquoi pas créer une classe CLEventReceiver pour la manette , une fois terminé mon code compile mais les événements ne fonctionnent plus.

Je vous laisse mon code, au cas où quelqu'un voit l'erreur, à tout les coups c'est ma classe qui est mal crée ...

CLEventReceiver .h

#include ...


class CLEventReceiver : public irr::IEventReceiver//On créé une classe CEventReceiver , fille de la classe IEventReceiver
{

public ://dans la partie publique , on va mettre les prototypes de nos fonctions

    CLEventReceiver(irr::scene::IAnimatedMeshSceneNode* Nperso,
                    irr::scene::ICameraSceneNode* camera3,
                    SDL_Event evenements);//On créé le constructeur , qui prend en parametre le node de notre modele(ici , Sydney , donc)

    virtual bool OnEvent(const SEvent& event);//Cette fonction est lancée en cas d'évenement

    void majPosMesh();//On met à jour la position de notre mesh
    void majAnimMesh();//On met à jour l'animation du mesh , si besoin est

private ://dans la partie privée , on met nos attributs

    irr::scene::IAnimatedMeshSceneNode* m_Nperso;//Le node que l'on va manipuler
    irr::scene::ICameraSceneNode* m_Ncamera3;//Le node que l'on va manipuler
    SDL_Event m_evenements;

    bool m_animrun;//Un booléen qui indique si l'animation du personnage est "courir"(EMAT_RUN) , ou pas
    bool m_isAvance;//Un booléen qui indique si on bouge , ou pas
    bool m_isCourrir;
    bool m_isMarcher;
};

CLEventReceiver::CLEventReceiver(irr::scene::IAnimatedMeshSceneNode* Nperso,
                                 irr::scene::ICameraSceneNode* camera3,
                                 SDL_Event evenements)//revoilà notre constructeur :)
{
    m_Nperso = Nperso;//On pointe le mesh passe en parametre.
    m_Ncamera3 = camera3;
    m_evenements = evenements ;

    m_animrun = true;//et comme l'animation n'est du coup pas "courir" , on met notre booléen à false aussi
    m_isAvance = false;//Par défaut , le modele est immobile .Donc le booléen qui indique si l'on bouge est à false
    m_isMarcher = false;
}

bool CLEventReceiver::OnEvent(const SEvent& event)//En cas d'évenement :
{
        switch(m_evenements.type)
        {
        case SDL_JOYBUTTONDOWN: //Cas appuie sur le bouton
            switch(m_evenements.jbutton.button)
            {
///////////////////////////////////////////////////LES BOUTONS////////////////////////////////////////////////////////
            case 0 :        //appuie sur le bouton 0 : A sur la manette
                /*speed=5;
                c.X +=  0.6*speed * sin(diry);
                c.Z -=  0.6*speed * - cos(diry);*/

                m_isAvance = true;
                m_isMarcher = true;
                break;
            case 1 :        //appuie sur le bouton 1 : B sur la manette
                /*speed=-5;
                c.X +=  0.6*speed * sin(diry);
                c.Z -=  0.6*speed * - cos(diry);*/
                break;
            case 2 :        //appuie sur le bouton 2 : X sur la manette
                break;
            case 3 :        //appuie sur le bouton 3 : Y sur la manette
                break;
            case 4 :        //appuie sur le bouton 4 : LB sur la manette
                break;
            case 5 :        //appuie sur le bouton 5 : RB sur la manette
                break;
            case 6 :        //appuie sur le bouton 6 : BACK sur la manette
                break;
            case 7 :        //appuie sur le bouton 7 : START sur la manette
                break;
            case 8 :        //appuie sur le bouton 8 : STICK GAUCHE sur la manette
                break;
            case 9 :        //appuie sur le bouton 9 : STICK DROITE sur la manette
                break;
            }

        }
}


void CLEventReceiver::majPosMesh()//fonction de mise à jour de la position
{
core::vector3df c =m_Nperso->getPosition();     
core::vector3df d= m_Nperso->getRotation();

float diry = ((d.Y+12)*3.1415926535897)/180; // +12 ajuste le pivot du model
int speed;

    if(m_Nperso != 0 && m_isAvance == true){            

            if(m_isMarcher == true && m_isCourrir == false)
                {
                speed=5;
                c.X +=  0.6*speed * sin(diry);
                c.Z -=  0.6*speed * - cos(diry);
                m_animrun == true;
                m_animrunCourrir == false;
                }
                else speed=0;

            if(m_isCourrir == true && m_isMarcher == true)
                {
                speed=9;
                c.X +=  0.6*speed * sin(diry);
                c.Z -=  0.6*speed * - cos(diry);
                m_animrun == false;
                m_animrunCourrir == true;
                }
                else speed=0;

    }
        m_Nperso->setPosition(c);
        m_Nperso->setRotation(d);
}

void CLEventReceiver::majAnimMesh()//Ici , on met à jour l'animation
{
...
}

...
  irr::IrrlichtDevice* device = irr::createDevice(irr::video::EDT_OPENGL,irr::core::dimension2d<irr::u32>(1024,768),32);
  irr::video::IVideoDriver* driver = device->getVideoDriver ();
  irr::scene::ISceneManager* sceneManager = device->getSceneManager ();

int main ( int argc, char** argv )
{
    irr::scene::IAnimatedMesh* perso;
    perso = (irr::scene::IAnimatedMesh*)sceneManager->getMesh("model/perso22.b3d");  /*testbox5.X*/ //ennemi12.b3d ennemi15.b3d
    irr::scene::IAnimatedMeshSceneNode* Nperso = sceneManager->addAnimatedMeshSceneNode(perso);
    Nperso->setMaterialTexture(0, driver->getTexture("images/skin6.jpg"));
    Nperso->setMaterialFlag(irr::video::EMF_LIGHTING, false);
    Nperso->setPosition(irr::core::vector3df(0.0,0.0,100.0)) ;
    Nperso->setScale(vector3df(0.1,0.1,0.1));
    Nperso->setAnimationSpeed(0);

    irr::scene::ICameraSceneNode *camera3 = sceneManager->addCameraSceneNode();
    camera3->setFarValue(camera3->getFarValue() + 40000.0f);
    camera3->setNearValue(0.3f); //0.03f

    if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) <0)
        return EXIT_FAILURE;
    SDL_JoystickEventState(SDL_ENABLE); //On active les événements de la manette

    SDL_Event evenements;


    SDL_Joystick *manette1; //on crée le joystick
    manette1 = SDL_JoystickOpen(0); //On l'assigne au numéro 0

    FILE* fichier = NULL;
    fichier = fopen("Joystick.txt","w+");// on crée un fichier Joystick.txt

    if(fichier != NULL)
    {
        fprintf(fichier," INFORMATIONS SUR LA MANETTE PC :  \
 \
");
        fprintf(fichier,"  Il y a %d joysticks connéctés. \
 \
", SDL_NumJoysticks());                   // On écrit il y a combien de joystick (manette)
        for(int i=0; i<SDL_NumJoysticks(); i++)
        {
            fprintf(fichier,"   Nom du joystick numero %d : %s \
",i,SDL_JoystickName(i));               // on écrit les noms des joysticks
            fprintf(fichier,"   Nombre de boutons         : %d \
",SDL_JoystickNumButtons(manette1));    // nombre de boutons
            fprintf(fichier,"   Nombre d'axes             : %d \
",SDL_JoystickNumAxes(manette1));       // nombre d'axes
            fprintf(fichier,"   Nombre de chapeaux        : %d \
",SDL_JoystickNumHats(manette1));       // nombre de chapeaux
            fprintf(fichier,"   Nombre de trackballs      : %d \
\
 ",SDL_JoystickNumBalls(manette1));      // nombre de trackballs
            fclose(fichier);                                                                             // on ferme le fichier
        }

    }
    else
        return EXIT_FAILURE;

//////////////////////////////RECEPTEUR EVENNEMENTS/////////////////////////////

    CLEventReceiver receiver(Nperso,
                             camera3,
                             evenements);//On créé un objet instance de la classe CEventReceiver : c'est notre capteur d'évènements

    device->setEventReceiver(&receiver);//on définit cet objet comme le capteur pour notre device


while (device->run()) {
        driver->beginScene(true, true, irr::video::SColor(0,255,255,255));

        SDL_PollEvent(&evenements);
        SDL_JoystickUpdate();

    receiver.majPosMesh();//a chaque frame , on appelle la fonction qui met à jour la position du Mesh
    receiver.majAnimMesh();//a chaque frame , on appelle la fonction qui , si besoin est  , modifie l'animation du mesh

    sceneManager->drawAll ();
    driver->endScene ();
    }
    device->drop ();
    SDL_JoystickClose(manette1);
    SDL_Quit();
    return EXIT_SUCCESS;
}

Juste une question. Pourquoi tu n'utilises pas la gestion d'événement d'irrlicht (irr::SEvent::SJoystickEvent). Pour l'avoir utilisé plein de fois, je n'ai jamais eu de problème. Surtout qu'il y a des chances pour qu'irrlicht utilise la SDL pour les événements, donc c'est réinventer la roue.

Bin enfait j'ai appris à programmé tout seul , alors je ne sais pas me servir d'une doc, si j'ai pas un tuto clair j'avance pas.
Alors vue que je connais un peut la SDL je me suis lancé sur ce qu'il me paraissait le plus simple, même si c'est pas le plus logique niveau code.
Du coup j'ai résolu mon problème, j'avais juste à recréer une fonction adapté :

CLEventReceiver .cpp

bool CLEventReceiver::process_events() //En cas d'événnement MANETTE X360
{
SDL_Event m_evenements;
SDL_PollEvent(&m_evenements);

        switch(m_evenements.type)
        {
///////////////////////////////////////////////////LES BOUTONS////////////////////////////////////////////////////////
        case SDL_JOYBUTTONDOWN: //Cas appuie sur le bouton
            if (m_evenements.jbutton.button == 0) { //appuie sur le bouton 0 : A sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 1) { //appuie sur le bouton 1 : B sur la manette
                m_isRecule = true;
            }
            if (m_evenements.jbutton.button == 2) { //appuie sur le bouton 2 : X sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 3) { //appuie sur le bouton 3 : Y sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 4) { //appuie sur le bouton 4 : LB sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 5) { //appuie sur le bouton 5 : RB sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 6) { //appuie sur le bouton 6 : BACK sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 7) { //appuie sur le bouton 7 : START sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 8) { //appuie sur le bouton 8 : STICK GAUCHE sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            if (m_evenements.jbutton.button == 9) { //appuie sur le bouton 9 : STICK DROITE sur la manette
                m_isAvance = true;
                m_isMarcher = true;
            }
            break;

        case SDL_JOYBUTTONUP: //Cas RELACHE du bouton
            if (m_evenements.jbutton.button == 0) { //RELACHE sur le bouton 0 : A sur la manette
                m_isAvance = false;
                m_isMarcher = false;
            }
            if (m_evenements.jbutton.button == 1) { //RELACHE sur le bouton 1 : B sur la manette
                m_isRecule = false;
               // m_isMarcher = false;
            }
            if (m_evenements.jbutton.button == 2) { //RELACHE sur le bouton 2 : X sur la manette
            }
            if (m_evenements.jbutton.button == 3) { //RELACHE sur le bouton 3 : Y sur la manette
                m_isAvance = false;
                m_isMarcher = false;
            }
            if (m_evenements.jbutton.button == 4) { //RELACHE sur le bouton 4 : LB sur la manette
            }
            if (m_evenements.jbutton.button == 5) { //RELACHE sur le bouton 5 : RB sur la manette
                m_isAvance = false;
                m_isMarcher = false;
            }
            if (m_evenements.jbutton.button == 6) { //RELACHE sur le bouton 6 : BACK sur la manette
            }
            if (m_evenements.jbutton.button == 7) { //RELACHE sur le bouton 7 : START sur la manette
           }
            if (m_evenements.jbutton.button == 8) { //RELACHE sur le bouton 8 : STICK GAUCHE sur la manette
                m_isAvance = false;
                m_isMarcher = false;
            }
            if (m_evenements.jbutton.button == 9) { //RELACHE sur le bouton 9 : STICK DROITE sur la manette
            }
            break;
///////////////////////////////////////////////////////LES AXES/////////////////////////////////////////////////////////////////////
        case SDL_JOYAXISMOTION : //Cas mouvement des axes
                if(m_evenements.jaxis.axis == 0 && m_evenements.jaxis.value < - 5000) //Mouvement vers la gauche NUMERO 0 = STICK GAUCHE
                {
                m_isAvance = true;
                m_isMarcher = true;
                }
                else {
                        m_isAvance = false;
                        m_isMarcher = false;
                }
                if(m_evenements.jaxis.axis == 0 && m_evenements.jaxis.value >  5000) //Mouvement vers la DROITE NUMERO 0 = STICK GAUCHE
                {
                }
                if(m_evenements.jaxis.axis == 1 && m_evenements.jaxis.value <  -5000) //Mouvement vers la HAUT NUMERO 1 = STICK GAUCHE
                {
                }

                if(m_evenements.jaxis.axis == 1 && m_evenements.jaxis.value >  5000) //Mouvement vers la BAS NUMERO 1 = STICK GAUCHE
                {
                }

                if(m_evenements.jaxis.axis == 2 && m_evenements.jaxis.value < -5000) //BOUTON AXE RT NUMERO 2
                {
                }
                if(m_evenements.jaxis.axis == 2 && m_evenements.jaxis.value > 5000) //BOUTON AXE LT NUMERO 2
                {
                }

                if(m_evenements.jaxis.axis == 3 && m_evenements.jaxis.value < - 5000) //Mouvement vers la HAUT NUMERO 3 = STICK DROIT
                {
                }
                if(m_evenements.jaxis.axis == 3 && m_evenements.jaxis.value >  5000) //Mouvement vers la BAS NUMERO 3 = STICK DROIT
                {
                }
                if(m_evenements.jaxis.axis == 4 && m_evenements.jaxis.value < - 5000) //Mouvement vers la GAUCHE NUMERO 3 = STICK DROIT
                {
                }
                if(m_evenements.jaxis.axis == 4 && m_evenements.jaxis.value >  5000) //Mouvement vers la DROITE NUMERO 3 = STICK DROIT
                {
                }
                 break;
/////////////////////////////////////////////////LES CHAPEAUX//////////////////////////////////////////////////////////////////////
        case SDL_JOYHATMOTION:
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_UP) //SI CHAPEAU HAUT
                {
                m_isAvance = true;
                m_isMarcher = true;
                //break;
                }
                else {
                        m_isAvance = false;
                        m_isMarcher = false;
                }
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_DOWN) //SI CHAPEAU BAS
                {
                }
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_RIGHT) //SI CHAPEAU DROITE
                {
                }
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_RIGHTDOWN) //SI CHAPEAU BAS DROITE
                {
                }
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_RIGHTUP) //SI CHAPEAU HAUT DROITE
                {
                }
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_LEFT) //SI CHAPEAU GAUCHE
                {
                }
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_LEFTDOWN) //SI CHAPEAU BAS GAUCHE
                {
                }
                if(m_evenements.jhat.hat == 0 && m_evenements.jhat.value == SDL_HAT_LEFTUP) //SI CHAPEAU HAUT GAUCHE
                {
                }
                break;
        }

}

     virtual bool process_events();

...
while (device->run()) {

        driver->beginScene(true, true, irr::video::SColor(0,255,255,255));


        SDL_JoystickUpdate();

    receiver.majPosMesh();//a chaque frame , on appelle la fonction qui met à jour la position du Mesh
    receiver.majAnimMesh();//a chaque frame , on appelle la fonction qui , si besoin est  , modifie l'animation du mesh
    receiver.process_events();
   
    sceneManager->drawAll ();
    driver->endScene ();
    }
    device->drop ();
    SDL_JoystickClose(manette1);
    SDL_Quit();
    return EXIT_SUCCESS;
}

Salut,
Les "if" à rallonge je suis pas fan, tu devrais essayer de caser ça au minimum dans un switch case .
Sinon, il est vrai que d'utiliser directement Irrlicht aurait été plus approprié mais bon, si t'es plus à l'aise sur SDL....
A+