Au chapitre précédent, nous avions transmis un pointeur nul à chacun des deux derniers arguments de la fonction ci-dessous :
int
SDL_RenderCopy(SDL_Renderer
*pRendu,
SDL_Texture *pTextureImage,
const
SDL_Rect *srcrect,
const
SDL_Rect *dstrect)
Dans cette partie, nous allons uniquement nous intéresser à l'argument noté "dstrect".
Plus clairement il désigne le rectangle de destination de l'image.
Nous savons déjà que lui transmettre un pointeur nul force l'image à recouvrir totalement
la fenêtre. Que se passe-t-il si cette fois nous lui transmettons un pointeur désignant un
objet rectangle ?
Tout simplement l'image sera étirée ou comprimée afin de s'adapter aux dimensions "w" et "h"
du rectangle. Les coordonnées "x" et "y" positionnerons le coin supérieur gauche de l'image
dans la fenêtre.
Essayons de suite en ajoutant juste avant la fonction SDL_RenderCopy() :
SDL_Rect rect;
rect.x
= 50;
rect.y
= 20;
rect.w
= 100;
rect.h
= 100;
Nous réécrivons maintenant la fonction SDL_RenderCopy() en lui donnant le nouveau pointeur :
SDL_RenderCopy(pRendu, pTextureImage, nullptr, &rect);
Notez la présence de l'esperluette
"&"
devant "rect" car la fonction attend ici une
adresse.
Maintenant si nous effectuons toutes ces modifications dans le programme du chapitre
précédent alors nous obtenons :
Nous savons placer une image où nous le désirons dans une fenêtre.
Voyons maintenant comment mouvoir cette image pour donner un peu de vie à notre rendu.
Premièrement il nous faut apporter une modification à la boucle des événements.
Jusqu'à présent, souvenez vous, nous utilisions la fonction SDL_WaitEvent().
Hors cette fonction à l'inconvénient de bloquer la boucle en absence d'événement,
ce qui inévitablement bloquera notre animation. Nous devons donc la remplacer par :
SDL_PollEvent(&evenement);
Cette nouvelle fonction récupère l'événement comme la précédente, mais cette fois laisse
le programme se poursuivre si aucun événement n'apparait.
C'est parfait pour ce que nous devons faire.
Deuxièmement, c'est dans cette boucle qui maintenant tourne continuellement que nous allons
gérer le déplacement de l'image.
A chaque tour de la boucle il nous faudra :
• Calculer la nouvelle position de l'image animée en fonction ou non des
nouveaux événements.
• Redessiner le fond de la fenêtre (ce qui efface l'ancien contenu).
• Redessiner l'image animée à sa nouvelle position.
• Temporiser la boucle au besoin si l'animation est trop rapide.
Voici un exemple qui provoque le déplacement d'une image enfonction de l'appuie
sur les touches "4" et "6" du pavé numérique :
int attendre =
1;
SDL_Event evenement;
while(attendre)
{
SDL_PollEvent(&evenement);
switch(evenement.type)
{
case SDL_QUIT:
attendre =
0;
break;
case SDL_KEYDOWN:
if(evenement.key.keysym.sym
== SDLK_KP_4)
rect.x -= 10;
if(evenement.key.keysym.sym
== SDLK_KP_6)
rect.x += 10;
break;
}
// Le fond est redessiné
SDL_SetRenderDrawColor(pRendu,
0,
0,
0,
255);
SDL_RenderClear(pRendu);
// L'image animée est redessinée à sa nouvelle position
SDL_RenderCopy(pRendu,
pTextureImage,
nullptr,
&rect);
// Actualisation de la fenêtre
SDL_RenderPresent(pRendu);
}
C'est un exemple simple qui n'évite pas a l'image de sortir de la fenêtre. Je pense que vous pourrez facilement l'incorporer sans trop de difficultés à l'un des programmes complets vu dans les chapitres précédents.