Faire des animations avec SDLP_Anim

Introduction du cours

Bienvenue dans mon tutoriel !

Ce dernier a pour but de vous apprendre à gérer des animations simplement grâce à un outil dont je suis l'auteur : SDLP_Anim.
Les utilisateurs de Dev-C++ auront une petite surprise dans ce tutoriel (ils ont quand même de la chance ceux-là) ! Les autres, eh bien, tant pis pour eux, na ! :D
Pour utiliser cet outil, vous aurez besoin d'avoir lu tout le tutoriel de M@teo21 sur le C/C++ (y compris la partie sur SDL).

Téléchargement

La première chose à faire est de télécharger le fichier ZIP qui contient le header pour que nos fonctions fonctionnent. :p
C'est ici : SDLP_Anim.zip !
Version actuelle de SDLP_Anim.h : 2.0 (2012).

Il se peut qu'une nouvelle version sorte et que vous ne le remarquiez pas. Dans ce cas, de nouvelles fonctions ajoutées dans ce tutoriel ne fonctionneront pas ! Il faudra alors remplacer l'ancien fichier par le nouveau qui est en téléchargement à côté de SDLP_Anim.zip.

Dès la version 2.0, la méthode de la bibliothèque change et nous passerons désormais avec la méthode standard dites "Static Library" soit l'installation d'un fichier .a et .h

WindowsCode::Blocks

Ouvrez le fichier compressé que vous avez téléchargé à l'aide de WinZip ou WinRar selon ce que vous avez. ;)
Commencez par prendre en compte le fichier de license (GNU GPL). Je sais que vous ne le lirez pas mais par principe, il est là.
Nous pouvons voir également 3 images différentes, conservez les car nous les utiliserons toutes pendant ce tutoriel. ;)
Finalement il ne nous reste plus que les fichiers qui vous permettront de faire des animations !

Plaçons d'abord le fichier d'en tête SDLP_Anim.h !
Vous allez placer ce fichier comme suit :
..\mingw32\include\SDLP_Anim.h
Ensuite, prenons notre deuxième fichier d'extension .a pour le mettre comme suit :
..\mingw32\lib\libSDLP_Anim.a

Et c'est tout ! :euh: :D

Dev-C++

La manipulation d'installation avec Dev-C++ est la même que celle de Code::Block. Vous devez placer vos deux fichiers dans le dossier mingw32 comme indiqué précédemment.

J'ai créé un template compatible avec Dev-C++ qui vous permettra de créer des projets SDL rapidement presque sans configuration !
Le fichier ZIP est disponible ici.
Décompressez le fichier et insérez le tout dans le dossier Templates.
Pour actionner le bouton, cliquez sur Nouveau projet. Puis, vous aurez le choix entre plusieurs types de programme comme la console. Cherchez Projet SDL puis cliquez dessus. Un code en SDL typique vient d'apparaître. Et ce n'est pas tout ! Avant, vous deviez mettre dans l'éditeur de lien -lmingw32, -lSDL, etc. Eh bien là, c'est déjà fait !

L'éditeur de liens contient ces fichiers: -lmingw32 -lSDLmain -lSDL -lSDL_image -lFMOD -lSDL_ttf ../../mingw32/lib/sdlgfx.lib.
Il se peut que vous n'ayez pas tout installé ; retirez les fichiers que vous n'avez pas installés.

Après l'installation de l'astuce, voilà ce que ça donne :

Bon certes, il n'y a pas d'icône mais c'est très pratique car on n'a pas besoin d'inclure à la main -lmingw32 -lSDLmain et surtout d'en rappeler.

Visual C++ 2010 Express

Il n'y a pas grand-chose qui change si ce n'est que nous n'utilisons plus mingw32 mais VC.
Mettez le header dans : ..\Microsoft Visual Studio 10\VC\include\SDLP_Anim.h
Et le fichier .a dans ..\Microsoft Visual Studio 10\VC\lib\libSDLP_Anim.a

Je ne connais pas bien cet IDE. Si un problème survient chez un bon nombre de Zéros, merci de me contacter par MP.

En général

Maintenant, nous allons configurer notre IDE favori. :)
Pour se faire, il suffit de créer un projet, et comme avec M@théo21, de "linker" notre fichier .a !
Allez dans les configurations de votre projet, et à l'endroit correspondant où l'on rentre les fichiers .lib et .a.
Vous pouvez maintenant ajouter le fichier .a dans cette liste.
Ou copiez-collez cette ligne permettant de configurer les bibliothèques pour la SDL, SDL_image et SDLP_Anim :
-lmingw32 -lSDLP_Anim -lSDLmain -lSDL -lSDL_image
Enregistrez et le tour est joué ! ^^

Il est important de placer -lSDLP_Anim avant -lSDLmain et le reste

Vous aurez ceci après vos manipulations (j'ai utilisé Dev-C++ mais ça devrait être presque pareil pour les autres) :

Exemple de placement des fichiers .a et .h pour mingw32

Mac OS (Xcode) & Linux

Je ne sais pas comment vous aider si vous êtes dans ce cas. :(

Animation normale

Nous allons maintenant commencer les choses sérieuses !

Je vous demande de créer un nouveau projet et de le compléter tout au long du chapitre. Normalement, votre fichier .c est vide en ce moment.

Accrochez-vous, ça va secouer !

Les fonctions, nous en raffolons

Prenons un code SDL de base (ayant inclus SDL_image). Recopiez-le dans votre fichier .c.

#include <stdlib.h> #include <stdio.h> #include <SDL.h> #include <SDL_image.h> int main(int argc, char *argv[]) { SDL_Surface *ecran = NULL; SDL_Event event; int continuer = 1; SDL_Init(SDL_INIT_VIDEO); ecran = SDL_SetVideoMode(200, 200, 32, SDL_HWSURFACE); SDL_WM_SetCaption("Animations en SDL !", NULL); while (continuer) { SDL_WaitEvent(&event); switch(event.type) { case SDL_QUIT: continuer = 0; break; } SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0)); SDL_Flip(ecran); } SDL_Quit(); return EXIT_SUCCESS; }

On va partir du tout début pour que vous n'oubliiez rien. Complétez votre fichier .c à l'aide de toutes les fonctions présentes.

ecran = SDL_SetVideoMode(200, 200, 32, SDL_HWSURFACE);

Vous avez tous remarqué que si, avec ce code, on blitte une image, elle va scintiller (si vous doutez, essayez :p ) !
On va régler tout ça en mettant en place le double buffering. :)

ecran = SDL_SetVideoMode(200, 200, 32, SDL_HWSURFACE | SDL_DOUBLEBUF); SDL_WaitEvent(&event);

Nous allons mettre SDL_PollEvent car une animation n'a pas besoin d'événement pour se mettre à fonctionner.

SDL_PollEvent(&event);

Heu... Tu n'aurais pas oublié le header par hasard ? :-°

Bien vu. ;)
Dans l'exemple du tutoriel, on trouve ceci dans l'en-tête du fichier .c.

#include <stdlib.h> #include <stdio.h> #include <SDL.h> #include <SDL_image.h> #include <SDLP_Anim.h>

Vous n'allez devoir retenir qu'une seule structure. Voici un exemple de son utilisation.

SDLP_Anim *Anim;

On a créé notre surface Anim. Ça serait bien de libérer sa mémoire, non ?
Pour cela, on va utiliser SDLP_FreeAnim !
Placez-le juste avant le SDL_Quit();.

SDLP_FreeAnim(Anim);

Et le tour est joué ! ;)

Maintenant, nous allons charger l'animation. Reprenez les images qui étaient dans le dossier compressé. Nous allons utiliser Feu.bmp. Je vais vous présenter le prototype de la fonction de chargement d'animation.

Mettez l'image dans le dossier de l'exécutable. Sinon, elle ne pourra pas être chargée avec l'exemple qui va suivre.

SDLP_Anim* SDLP_LoadAnim(char *SurfaceAnim, int nbPicture, int coter, long temps, int Loop, int Actif, int Util);

Vous allez définir toutes les options de l'animation :

• char *SurfaceAnim : entrez ici le chemin de l'exécutable à l'image ;

• int nbPicture : nombre d'images à séparer dans celle qui a été déclarée plus haut (l'image sera coupé en parts égales) ;

• int coter : définir ici le sens de défilement. Utilisez les definesSDLP_GAUCHE, SDLP_DROITE, SDLP_HAUT ou SDLP_BAS. Si je prends SDLP_HAUT par exemple, l'animation sera coupée et animée de l'image tout en bas vers l'image tout en haut (on monte) ;

• long temps : définir ici le temps entre chaque image (en millisecondes) ;

• int Loop : choisir ici le nombre de fois où l'image va être animée. Utilisez SDLP_INFINI ou un nombre supérieur ou égal à 1. ;

• int Actif : définir ici l'état de l'animation en utilisant SDLP_ARRETER, SDLP_PAUSE ou SDLP_LANCER ;

• int Util : stipulez ici si l'animation doit se jouer seule ou à l'appui sur une touche. Utilisez les definesSDLP_NORMAL ou SDLP_TOUCHE.

• N'oubliez pas que cette fonction retourne vos configurations vers une variable de type SDLP_Anim.

Nous verrons comment utiliser l'animation par événement plus tard.

Voici les détails des différents états dont peuvent être assignés l'animation :

SDLP_ARRETER

Votre animation n'apparait pas/disparait.
Celle-ci s'arrête et reviens à la 1ère image découpée.
Si le nombre de boucles n'est pas infini, celui-ci revient au début.

SDLP_PAUSE

Votre animation reste présente mais se fige sur l'instant où elle était.
Il n'y a pas d'écarts de temps et quand l'animation reprend, elle reprend là où elle s'était arrêtée.
Le nombre de boucles est conservée.

SDLP_LANCER

Permet de lancer l'animation depuis n'importe quelle état.

Anim=SDLP_LoadAnim("Feu.bmp", 4, SDLP_DROITE, 1000, SDLP_INFINI, SDLP_LANCER, SDLP_NORMAL);

Ça va ? Vous suivez ? N'hésitez pas à relire si cela s'avère nécessaire !
Ça devient intéressant, non ? :p

Maintenant, il faut définir la position de l'animation dans la fenêtre.
Déclarez une variable du type SDL_Rect ! Faites comme moi, appelez-la pAnim.

SDL_Rect pAnim; /* Chargement de l'animation. */ pAnim.x=0; pAnim.y=0;

Nous avons chargé notre animation. Mais ce n'est que dans la « tête » de l'ordinateur ça. Nous, on veut que ça s'affiche, non ? NON ? :lol:
Nous allons utiliser la fonction de blittage la plus simple qui n'ait jamais existé. :D
Son prototype l'est aussi :

void SDLP_BlitAnim(SDLP_Anim *str, SDL_Surface *ecran, SDL_Rect pos);

• SDLP_Anim *str : entrez ici votre variable d'animation ;

• SDL_Surface *ecran : surface qui gère la fenêtre, souvent appelée ecran ou screen ;

• SDL_Rect pos : inscrivez ici votre variable de position.

Mais si je charge une animation avec comme état SDLP_ARRETER, l'animation n'apparaîtra jamais ?!

Qu'ouïe-je ? Effectivement, il faut bien une fonction pour changer l'état de notre animation ! ^^
Là voici avec son prototype :

void SDLP_SetEtatAnim(SDLP_Anim *str, int Etat);

• SDLP_Anim *str : entrez ici votre variable d'animation ;

• int Etat : Entrez votre variable d'état (voir ci-dessus, il y en a trois seulement).

Il serait utile de savoir dans quel état est l'animation, voici la fonction qui permet de vous renseigner sur cela :

int SDLP_GetEtatAnim(SDLP_Anim *str);

• SDLP_Anim *str : entrez ici votre variable d'animation ;

• Renvoi une valeur de type INT. Comparez les comme ceci :

  if (SDLP_GetEtatAnim(Anim)==SDLP_LANCER)

Voilà ! Nous avons nos fonctions maintenant. ;)
Maintenant que vous savez faire des animations, nous allons mettre vos talents en pratique ! :p

Fonctions annexes

Ne grillez pas cette partie ! Plusieurs fonctions vous seront bien utiles (indispensables) pour gérer vos animations correctement.
Imaginons-nous un problème. Vous savez comme moi que la largeur/hauteur d'une surface en SDL s'écrit de cette facon :

SDL_Surface *Surface = NULL; Surface->w // Largeur Surface->h // Hauteur

Cependant, nous ne connaissons pas la largeur/hauteur de notre image d'animation.
Il existe trois fonctions différentes pour répondre à ce problème :

void SDLP_GetWHSurfaceAnim(SDLP_Anim *str, int *w, int *h);

• SDLP_Anim *str : Entrez ici votre variable d'animation ;