Les événements avec la SDL
 

Les événements. Sans eux, quasiment rien n'est possible en SDL. Ils sont supers simples à utiliser et en plus supers pratiques. Mais tout d'abord, voyons ce qu'est un événement.


Les événements

Un événement en SDL, est le fait que l'utilisateur touche à une interface Homme-machine comme le clavier, la souris, le joystick.

C'est-à-dire que lorsque vous appuyez sur une touche, cela créer un événement. Si vous la relachez cela en créer un autre, si vous bougez la souris, cliquez quelque part, etc.....

Le but de ce chapitre, est de voir comment "intercepter" ces événement et comment les reconnaître pour ensuite pouvoir réaliser des actions en fonction d'eux.


La boucle événementielle

Voici le principe:

Votre programme va lancer une boucle infinie en l'attente d'un événement. Une fois un événement détecté, la boucle va l'analyser, faire en fonction, puis recommencer ses tours jusqu'au nouvel événement, etc...

Voici donc une bouce infinie:

int continuer = 1;

while(continuer) //Booléen.
{

}

Il nous faut maintenant apprendre à récupérer les événements


Récupérer les événements

Les événements survenus seront stockés dans une variable de type SDL_Event.

Par exemple, pour créer une variable evenement:
 

SDL_Event evenement;

Enfin, pour récupérer l'éventuel événement survenu, il vous faut utiliser la fonction:

SDL_PollEvent ou SDL_WaitEvent (voir différence juste après) en donnant comme seul et unique argument l'adresse de votre variable de type SDL_Event.

Comme ceci:
 

SDL_PollEvent(&evenement);     ou    SDL_WaitEvent(&evenement);

Différence entre SDL_PollEvent et SDL_WaitEvent

La fonction SDL_WaitEvent est dite bloquante. C'est à dire que tant qu'aucun événement ne s'est présenté, il stopera net le prgramme. Alors que SDL_PoolEvent, lui, qu'il y ai ou non d'événement reçu, il ne bloquera rien du tout et fera continuer le programme normalement.


Reconnaître l'événement reçu

L'événement est donc stocké dans la variable evenement. Pour reconnaître cet événement, il suffit de tester les possibilités voulues. Nous allons faire ceci avec un switch bien qu'il soit possible de faire de simples conditions, mais le switch a l'avantage d'être plus lisible

Ce que je ne vous ai pas dit, c'est qu'en fait, le type de variable SDL_Event n'est rien d'autre qu'une structure. Ne vous étonnez donc pas d'écrire ceci pour faire le switch:
 

switch(evenement.type)
{

}

En faisant ceci, on analyse le type de l'événement. C'est à dire que l'on regarde si l'évenement est:

-Une touche appuyée.
-Une touche relâchée.
-Un mouvement de souris.
-Un clic de souris.
-Le relâchement du clic de souris.
-La croix rouge pour fermer la fenêtre.

Il ne s'agit donc que du type et non de l'événement!


Le clavier

Voyons tout d'abord les événements du clavier. Voici les macros (défines déjà définies) que l'on va utiliser:

SDL_KEYDOWN --> Si une touche est appuyée.
SDL_KEYUP --> Si une touche est relâchée.

Prenons un exemple de code concret: Vous souhaitez fermer la fenêtre lorsque l'on appuie sur une touche. Voici le code que vous utiliserez:

#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif

int main (int argc, char** argv)
{
    SDL_Init(SDL_INIT_VIDEO);

    SDL_Surface *ecran = NULL;
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

    int continuer = 1;
    SDL_Event evenement;

    while(continuer)
    {
        SDL_PollEvent(&evenement);

        switch(evenement.type)
        {
            case SDL_KEYDOWN:
            continuer = 0;
            break;
        }

    }

    SDL_Quit();
    return 0;
}


Compilez et lancez le programme (F9) et tadamm!! Une jolie fenêtre apparait! Appuyez sur n'importe qu'elle touche et....youpi! Elle disparait! :P

Vous venez d'utiliser vos premiers événéments avec la SDL Essayez de vous habituez à cela en faisant, par exemple, fermer la fenêtre en relâchant une touche, etc...

Voyons maintenant comment reconnaître la touche appuyée ou relâchée.

Pour cela, il suffit d'accéder au sous-sous-sous membre de votre structure, comme ceci:
 

evenement.key.sym.keysym

Il suffit donc de mettre cette variable dans un switch qui sera, lui, dans la condition de la touche enfoncée ou relâchée comme ceci:

#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif

int main (int argc, char** argv)
{
    SDL_Init(SDL_INIT_VIDEO);

    SDL_Surface *ecran = NULL;
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

    int continuer = 1;
    SDL_Event evenement;

    while(continuer)
    {
        SDL_PollEvent(&evenement);

        switch(evenement.type)
        {
            case SDL_KEYDOWN:

            switch(evenement.key.keysym.sym)
            {

            }

            break;
        }

    }

    SDL_Quit();
    return 0;
}


Pour maintenant savoir quelle touche est enfoncée, il suffit de mettre dans ce nouveau switch:

 

case MACRO_TOUCHE:
//Actions à réaliser si cette touche est enfoncée.
break;

MACRO_TOUCHE est différent pour chaque touches. Par exemple pour la touche "e" c'est SDLK_e. Il faut donc marquer:




L'avantage est qu'il y a même les touches comme entrée, les flèches directionnelles, imprim' écran, F1, etc....


Connaisant cela, nous allons créer un programme qui affiche une fenêtre et qui quitte si l'on appui sur Escape ou si l'on clique sur la croix. Essayez de le faire seul, ce n'est pas très dur


Correction:


#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif

int main (int argc, char** argv)
{
    SDL_Init(SDL_INIT_VIDEO);

    SDL_Surface *ecran = NULL;
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

    int continuer = 1;
    SDL_Event evenement;

    while(continuer)
    {
        SDL_PollEvent(&evenement);

        switch(evenement.type)
        {
            case SDL_QUIT:
            continuer = 0;
            break;

            case SDL_KEYDOWN:

            switch(evenement.key.keysym.sym)
            {
                 case SDLK_ESCAPE:
                 continuer = 0;
                 break;
            }

            break;
        }

    }

    SDL_Quit();
    return 0;
}


Essayez de compiler sans lancer l'application pour voir (Contrôle + F9): codeblocks vous affiche plus de 233 warnings 0.0

Il s'agit tout le temps du même:


Pour régler ce problème, il suffit de rajouter dans le switch evenement.key.keysym.sym:

default:
break;

Ce qui donne le code final suivant:

#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif

int main (int argc, char** argv)
{
    SDL_Init(SDL_INIT_VIDEO);

    SDL_Surface *ecran = NULL;
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

    int continuer = 1;
    SDL_Event evenement;

    while(continuer)
    {
        SDL_PollEvent(&evenement);

        switch(evenement.type)
        {
            case SDL_QUIT:
            continuer = 0;
            break;

            case SDL_KEYDOWN:

            switch(evenement.key.keysym.sym)
            {
                 case SDLK_ESCAPE:
                 continuer = 0;
                 break;

                 default:
                 break;
            }

            break;
        }

    }

    SDL_Quit();
    return 0;
}


Compilez et lancez le programme (F9) et ...... votre fenêtre s'affiche sans erreurs, sans warnings, et quitte quand on appuie sur escape ou lorsque l'on clique sur la croix!


Alors, heureux? :P

Voyons maintenant, juste rapidemment, la souris, car elle n'est pas compliquée du tout


La souris

Pour cela, c'est exactement la même chose qu'avec le clavier mais en plus simple car il y a moins de possibilité!

Déjà, pour savoir si un bouton de la souris est enfoncé, on utilise:

            case SDL_MOUSEBUTTONDOWN:
            break;


Et pour un bouton relâché on fait:

            case SDL_MOUSEBUTTONUP:
            break;




Ensuite, il suffit de faire comme tout à l'heure, c'est à dire un switch Mais on utilise plus la même variable. Il faut prendre celle-ci:


Pour finir, il suffit de tester les possibilités voulues avec les macros suivantes (oui je suis gentil je vous donne la liste :P):

Pour les clics:

SDL_BUTTON_LEFT                        Clic du bouton gauche de la souris.
SDL_BUTTON_MIDDLE                   Clic du bouton du milieu de la souris.
SDL_BUTTON_RIGHT                      Clic du bouton droit de la souris.


Pour la molette:

SDL_BUTTON_WHEELDOWN         Roulette de la molette vers le haut.
SDL_BUTTON_WHEELUP               Roulette de la molette vers le bas.


Bon oui c'était court


Donc par exemple si vous souhaitez fermer la fenêtre lors d'un clic droit, il suffit de faire ceci:



#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif

int main (int argc, char** argv)
{
    SDL_Init(SDL_INIT_VIDEO);

    SDL_Surface *ecran = NULL;
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

    int continuer = 1;
    SDL_Event evenement;

    while(continuer)
    {
        SDL_PollEvent(&evenement);

        switch(evenement.type)
        {
            case SDL_QUIT:
            continuer = 0;
            break;

            case SDL_MOUSEBUTTONDOWN:

            switch(evenement.button.button)
            {
                 case SDL_BUTTON_RIGHT:
                 continuer = 0;
                 break;

                 default:
                 break;
            }

            break;
        }

    }

    SDL_Quit();
    return 0;
}



Mais pour l'instant elle est pas terriblement originale notre fenêtre C'est pour cela que nous allons voir dans le chapitre suivant comment la personnaliser!




Notre première fenêtre avec la SDL                                      Personnalisons notre fenêtre!