Discussion :

[gizmo2937]

Bonjour à tous,

Je découvre les bases du C depuis peu et je "joue" actuellement avec la bibliothèque SDL.

Pour l'instant j'arrive à déplacer une image de façon instantanée en cliquant avec la souris (en positionnant l'image à la position event.button en x et y).
J'arrive aussi à faire en sorte que l'image suive le mouvement de la souris (event.motion en x et y).

Je n'arrive par contre pas à combiner les deux
Je souhaiterai que l'image suive le mouvement de la souris uniquement lorsque un des boutons de cette dernière est enfoncé.

Je travaille à partir d'une structure de ce type (avec ce code l'image suis le mouvement de la souris):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
SDL_EnableKeyRepeat(10,10);
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym) /*on regarde quelle touche a appuyée */
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_UP:
                        positionImage.y = positionImage.y -1;
                        break;
                    case SDLK_DOWN:
                        positionImage.y = positionImage.y +1;
                        break;
                    case SDLK_LEFT:
                        positionImage.x = positionImage.x -1;
                        break;
                    case SDLK_RIGHT:
                        positionImage.x = positionImage.x +1;
                        break;
                    default:
                        break;
                }
                break;
            case SDL_MOUSEMOTION:               
                    positionImage.x = event.motion.x;
                    positionImage.y = event.motion.y;                
                    break;
        }
 
        /* on efface l'ecran*/
        SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
        /*On fait les SDL_BlitSurface nécessaires*/
        SDL_BlitSurface(zozor,NULL,ecran,&positionImage);
 
        /*On met l'affichage à jour*/
        SDL_Flip(ecran);
    }

La partie au clavier fonctionne correctement; si je reste appuyé sur une touche le déplacement continue grâce au SDL_EnableKeyRepeat.

J'ai essayé, pour résoudre mon problème, d'utiliser une boucle do{ ... } while mais sans succès.

Avez-vous une piste quand à la structure à utiliser?

Merci beaucoup !

[Obsidian]

Bonjour,

Il existe les événements SDL_MOUSEBUTTONUP et SDL_MOUSEBUTTONDOWN. Tu peux te servir de l'un et l'autre pour fixer l'état d'un flag indiquant si l'on doit ou non déplacer ton image, et continuer à le faire sur un SDL_MOUSEMOTION en fonction de l'état de ce flag.

[gizmo2937]

Merci Obsidian !

Voici ce que j'ai fait en suivant ton conseil:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
SDL_EnableKeyRepeat(10,10);
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym) /*on regarde quelle touche a appuyée */
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                        break;
                    case SDLK_UP:
                        positionImage.y = positionImage.y -1;
                        break;
                    case SDLK_DOWN:
                        positionImage.y = positionImage.y +1;
                        break;
                    case SDLK_LEFT:
                        positionImage.x = positionImage.x -1;
                        break;
                    case SDLK_RIGHT:
                        positionImage.x = positionImage.x +1;
                        break;
                    default:
                        break;
                }
                break;
            case SDL_MOUSEBUTTONDOWN:
                sourisDown = 1;
                break;
            case SDL_MOUSEBUTTONUP:
                sourisDown = 0;
                break;
            default : break;
 
        }
 
        if (sourisDown)
        {
            positionImage.x = event.motion.x;
            positionImage.y = event.motion.y;
        }
 
        /* on efface l'ecran*/
        SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
        /*On fait les SDL_BlitSurface nécessaires*/
        SDL_BlitSurface(zozor,NULL,ecran,&positionImage);
 
        /*On met l'affichage à jour*/
        SDL_Flip(ecran);
    }

Je vais faire un tableau d'entier qui regroupera les flags pour toutes les touches du clavier et un autre pour les boutons de la souris.

Merci encore

[Obsidian]

De rien, mais je ne vois plus SDL_MOUSEMOTION dans ton dernier code ...

[gizmo2937]

J'ai juste défini la nouvelle position de l'image à la position actuelle de la souris lorsqu'un bouton est enfoncé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
if (sourisDown)
        {
            positionImage.x = event.motion.x;
            positionImage.y = event.motion.y;
        }

Je ne veux pas que l'image se déplace dès qu'un mouvement de la souris a lieu, mais bien qu'elle suive son mouvement lorsque je reste appuyé sur un de ses boutons.

Il aurait été mieux d'intégrer la nouvelle position de l'image dans un cas SDL_MOUSEMOTION du switch ?

[Obsidian]

Il aurait été mieux d'intégrer la nouvelle position de l'image dans un cas SDL_MOUSEMOTION du switch ?

Oui, car en l'occurrence, ce sont bien les SDL_MOUSEMOTION qui font débloquer l'appel SDL_WaitEvent(), même si tu les traites pas toi-même. En outre, ça ne fonctionne que parce que la structure de l'événement contient toujours les champs motion.x et motion.y et que la lib a la gentillesse de te les remplir même lorsque l'événement reçu n'a rien à voir (ce qui reste à vérifier, d'ailleurs).

Avec la X-Lib, tu ne pourrais pas l'écrire du tout et, dans le cas présent, un appui sur une touche ou tout autre événement trop lointain de la souris risque d'envoyer ton image n'importe où parce que les champs n'auront pas éte initialisés.

[gizmo2937]

J'ai apporté les modifications pour éviter les problèmes d'initialisation de la position de la souris.
J'ai ajouté aussi une gestion du débordement de la surface de l'écran par la souris.
Voici le code ajouté:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
case SDL_MOUSEMOTION:
                if (event.motion.x > ecran->w - 10)
                {
                    SDL_WarpMouse(ecran->w - 10, event.motion.y);
                }
                if (event.motion.y > ecran->h - 15)
                {
                    SDL_WarpMouse(event.motion.x,ecran->h - 15);
                }
                if (sourisDown)
                {
                    positionImage.x = event.motion.x;
                    positionImage.y = event.motion.y;
 
                }
                break;

J'hésite par contre quand à la présence de la fonction SDL_WarpMouse() dans mon cas SDL_MOUSEMOTION. Je sais que cette fonction génère justement un évènement de type SDL_MOUSEMOTION !
Est-ce que c'est "plus propre" de le sortir du cas de SDL_MOUSEMOTION ou est-ce que c'est pas gênant de le laisser là ?

Merci encore pour votre aide.

[Obsidian]

J'hésite par contre quand à la présence de la fonction SDL_WarpMouse() dans mon cas SDL_MOUSEMOTION. Je sais que cette fonction génère justement un évènement de type SDL_MOUSEMOTION !
Est-ce que c'est "plus propre" de le sortir du cas de SDL_MOUSEMOTION ou est-ce que c'est pas gênant de le laisser là ?

En l'occurence, ça ne fera pas grand chose puisque ton Warp ramène le pointeur de souris dans les limites que tu lui as imposé, donc le deuxième événement ne déclenchera pas de nouveau Warp. Par contre, faire deux Warps distincts pour modifier l'abscisse et/ou l'ordonnée, ce n'est pas très propre et c'est apte à te causer des ennuis.

Le sortir du case n'est pas une bonne idée non plus pour les mêmes raisons qu'au-dessus : la condition est évaluée à chaque événement reçu et pas seulement ceux qui sont relatifs à la souris, et tu n'es pas sûr que les champs soient toujours remplis. Là, c'est le pointeur de souris qui risquerait de se retrouver intempestivement ramené en bordure d'écran et, par voie de conséquence, l'image pointée si le bouton est enfoncé. Tout ceci pourrait te mener à considérer ta souris comme défectueuse alors qu'il s'agit d'un bug.

Enfin, je vois que tu as codé en dur les « marges » à ne pas franchir. Sache toutefois que le curseur de la souris est différent selon le système sous lequel tu tournes et le thème que l'utilisateur a choisi. En outre, la SDL elle-même te permet de changer de curseur.

[gizmo2937]

Ce qu'il faut si j'ai bien compris c'est qu'il soit impossible que les deux SDL_WarpMouse() soit appelés dans la même boucle (il faudrait que la souris soit placée pile dans le coin inférieur droite pour cela ! ).

Je ne veux pas faire un seul appel à la fonction comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
SI ( (dépassement en x) OU (dépassement en y) ) ALORS
	on corrige la position de la souris en x et en y
FIN SI

Cela ferait "sauter" la souris à une nouvelle position si le curseur ne déborde que sur un seul axe.

Il faudrait sinon que j'écrive quelque chose dans ce genre là:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
SI ( (dépassement en x) ET (pas de dépassement en y) ) ALORS
	on corrige en x uniquement
SINON SI ( (pas de dépassement en x) ET (dépassement en y) ) ALORS
	on corrige en y uniquement
SINON SI ( (dépassement en x) ET (dépassement en y) ) ALORS
	on corrige en x et en y
SINON
	l'image prend la position actuelle du curseur
FIN SI

Est-ce que c'est à une structure de ce type que tu pensais ?
Là il n'y aurait plus de risque de voir la fonction SDL_WarpMouse() appelée deux fois !

Qu'est-il conseillé d'utiliser pour la gestion des flags au niveau des touches ? Je pensais utiliser un tableau d'entiers mais ça risque de ne pas être simple pour faire la correspondance entre les codes SDLKey et leurs places dans le tableau
Je ne parle pas de la solution de créer des variables globales qui je sais est à proscrire !
Ou sinon on créer autant de variables de type int que de touches que l'on va utiliser dans son programme ( c'est vers cette solution que je tends mais elle me parait un peu bourrine ).

[Obsidian]

Je ne veux pas faire un seul appel à la fonction comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
SI ( (dépassement en x) OU (dépassement en y) ) ALORS
	on corrige la position de la souris en x et en y
FIN SI

Cela ferait "sauter" la souris à une nouvelle position si le curseur ne déborde que sur un seul axe.

C'est pourtant cela qu'il faut faire, mais en déterminant à l'avance les nouvelles positions de x et y, qui peuvent éventuellement rester inchangées. Le mieux est un opérateur ternaire :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
if ( (event.motion.x > ecran->w - 10)) ||
     (event.motion.y > ecran->h - 15) )
{
    SDL_WarpMouse (event.motion.x <= ecran->w - 10 ? event.motion.x : w-10,
                   event.motion.y <= ecran->h - 15 ? event.motion.y : h-15);
}

Du coup, le if() lui-même ne sert plus qu'à empêcher de déclencher un SDL_MouseWarp() si ce n'est pas nécessaire.

Qu'est-il conseillé d'utiliser pour la gestion des flags au niveau des touches ? Je pensais utiliser un tableau d'entiers mais ça risque de ne pas être simple pour faire la correspondance entre les codes SDLKey et leurs places dans le tableau

Si tu as un moyen de connaître la valeur maximale d'un SDLKey, alors tu fais un tableau de la même taille et tu utilises directement la valeur de ton SDLKey comme index dans ton tableau. À condition que ledit tableau ne soit pas trop grand bien sûr.

[gizmo2937]

Merci beaucoup Obsidian ! J'ai bien avancé ce matin grâce à tes conseils

Voici le programme complet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <SDL_image.h>
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *image = NULL;
    SDL_Event event;
    int continuer = 1;
    //tableau pour gérer l'état des touches (clavier, souris, etc)
    int touches[324] ={0};
 
    SDL_Init(SDL_INIT_VIDEO);
 
    SDL_WM_SetIcon(SDL_LoadBMP("sdl_icone.bmp"),NULL); //On choisi l'icone du programme
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
    SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
    SDL_WM_SetCaption("Gestion des evenements",NULL); //Titre de la fenetre entre""
 
    image = SDL_LoadBMP("image.bmp");
    //on fait disparaitre le fond de l'image (couleur unie)
    SDL_SetColorKey(image,SDL_SRCCOLORKEY, SDL_MapRGB(image->format,0,0,255));
    SDL_Rect positionImage;
 
    positionImage.x = ecran->w /2 - image->w /2;
    positionImage.y = ecran->h /2 - image->h /2;
    SDL_BlitSurface(image,NULL,ecran,&positionImage);
    SDL_Flip(ecran);
 
    //SDL_EnableKeyRepeat(10,10);
    while(continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            //on redimensionne la surface ecran si l'utilisateur redimensionne la fenêtre
            case SDL_RESIZABLE:
                ecran = SDL_SetVideoMode(event.resize.w, event.resize.h, 32, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
                SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
                break;
            case SDL_QUIT:
                continuer = 0;
                break;
            case SDL_KEYDOWN:
                touches[event.key.keysym.sym] = 1; //on repère quelle touche est appuyée
                break;
            case SDL_KEYUP:
                touches[event.key.keysym.sym] = 0; //on repère quelle touche est relachée
 
            case SDL_MOUSEBUTTONDOWN: //on repère quel bouton est appuyée
                touches[event.button.button] = 1;
                break;
            case SDL_MOUSEBUTTONUP: //on repère quel bouton est relachée
                touches[event.button.button] = 0;
                break;
 
            case SDL_MOUSEMOTION:
                if ( (event.motion.x > ecran->w - 10) ||
                (event.motion.y > ecran->h - 15) )
                {
                    SDL_WarpMouse (event.motion.x <= ecran->w - 10 ? event.motion.x : ecran->w-10,
                    event.motion.y <= ecran->h - 15 ? event.motion.y : ecran->h-15);
                }
                if (touches[SDL_BUTTON_LEFT])
                {
                    positionImage.x = event.motion.x;
                    positionImage.y = event.motion.y;
                }
                break;
            default : break;
        }
 
        if (touches[SDLK_ESCAPE])
        {
            continuer = 0;
        }
 
        /* on efface l'ecran*/
        SDL_FillRect(ecran,NULL,SDL_MapRGB(ecran->format,255,255,255));
 
        /*On fait les SDL_BlitSurface nécessaires*/
        SDL_BlitSurface(image,NULL,ecran,&positionImage);
 
        /*On met l'affichage à jour*/
        SDL_Flip(ecran);
    }
 
    SDL_FreeSurface(image);
    SDL_Quit(); //On arrete la SDL
 
    return EXIT_SUCCESS;
}

Les codes touches de la SDL commencent à 0 et se terminent à 323 (de SDLK_FIRST à SDLK_LAST).
Je suis passé du mode plein écran à un mode fenêtré.
Je ne connaissait pas l'opérateur ternaire et effectivement c'est assez pratique !
Bon je sais dans le programme tel qu'il est, il n'y a pas besoin de gérer de débordement, mais c'est pour s'entraîner !

Pour le problème de curseur, je pense cacher le curseur système et mettre à la place un curseur que j'importerai via un fichier image. Comme ça quel que soit l'OS utilisé, se sera le même et je pourrai utiliser la largeur et la hauteur de ce curseur au lieu de mettre des marges en dur.

[Obsidian]

Bonjour,

Voici le programme complet :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
…
 
    //tableau pour gérer l'état des touches (clavier, souris, etc)
    int touches[324] ={0};

Les codes touches de la SDL commencent à 0 et se terminent à 323 (de SDLK_FIRST à SDLK_LAST).

Si tu as des constantes prédéfinies, alors il faut les utiliser, et pas coder en dur la taille du tableau. Sinon, en changeant de plateforme, tu risques un plantage.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

    int touches[SDLK_LAST+1] = {0};

Et si tu veux être puriste, tu tiens compte de FIRST aussi pour gagner de la place :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

    int touches[SDLK_LAST-SDLK_FIRST+1] = {0};

Mais cela t'oblige à mettre « -SDLK_FIRST » partout où tu utiliseras ton tableau.

Je suis passé du mode plein écran à un mode fenêtré.
Je ne connaissait pas l'opérateur ternaire et effectivement c'est assez pratique !
Bon je sais dans le programme tel qu'il est, il n'y a pas besoin de gérer de débordement, mais c'est pour s'entraîner !

C'est-à-dire que si tu interceptes la souris, pense quand même à laisser une échappatoire à l'utilisateur, Parce que le Alt-F4 (tu es sous Windows, au fait ?), ça va bien cinq minutes.

Pour le problème de curseur, je pense cacher le curseur système et mettre à la place un curseur que j'importerai via un fichier image. Comme ça quel que soit l'OS utilisé, se sera le même et je pourrai utiliser la largeur et la hauteur de ce curseur au lieu de mettre des marges en dur.

Tu peux aussi récupérer les dimensions du curseur actuel en début de programme. Cependant, es-tu sûr d'avoir besoin de faire cela ? Généralement, c'est le point de visée que l'on essaie de maintenir dans la fenêtre, peu importe si le reste déborde…