La librairie SDL en C [mots clefs]

Langage C

La librairie SDL

Pour ceux qui utilises le compilateur Mingw32(Dev-C++, Code::Block) Vous rrouverez la version adapté de la SDL dans le lien suivant:
http://www.libsdl.org/release/SDL-devel-1.2.11-mingw32.tar.gz
Sinon, recherchez la version adapté
sur le site ci-dessous:
http://www.libsdl.org/index.php

Partie I

Charger et arrêter la SDL

* SDL_Init : charge la SDL en mémoire (des malloc y sont faits).
* SDL_Quit : libère la SDL de la mémoire (des free y sont faits).

Dans la SDL il y a plusieurs parties:

Constante Description
SDL_INIT_VIDEO Charge le système d'affichage (vidéo).
C'est la partie que nous chargerons le plus souvent.
SDL_INIT_AUDIO Charge le système de son.
Vous permettra donc par exemple de jouer de la musique.
SDL_INIT_CDROM Charge le système de CD-Rom.
Vous permettra de manipuler votre lecteur de CD-Rom
SDL_INIT_JOYSTICK Charge le système de gestion du joystick.
SDL_INIT_TIMER Charge le système de timer.
Cela vous permet de gérer le temps dans votre programme (très pratique).
SDL_INIT_EVERYTHING Charge tous les systèmes listés ci-dessus à la fois.

Pour la charger, suffit de faire comme ça:
SDL_Init(CONSTANTE);
Là où il y a constante, c'est là où faut préciser la partie.

Pour choisir deux parties ou plus on met le symbole "|" entre chaque constante
exemple:
SDL_Init(CONSTANTE1 | CONSTANTE2 | CONSTANTE3 | etc... )

La fonction SDL_Init renvoie une valeur :

-1 en cas d'erreur
0 si tout s'est bien passé

Pour afficher le contenu d' une éreure avec la SDL on va faire la méthode ci-dessous:
fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
Cette méthode va créer un nouveau fichier et va l'appeler stderr.txt
Les éreures seront stockés dans SDL_GetError().

EXIT_FAILURE : valeur à renvoyer en cas d'échec du programme
EXIT_SUCCESS : valeur à renvoyer en cas de réussite du programme.

SDL_INIT_VIDEO

SDL_SetVideoMode() pour:
* La largeur de la fenêtre désirée (en pixels)
* La hauteur de la fenêtre désirée (en pixels)
* Le nombre de couleurs affichables (en bits / pixel)
* Des options (des flags)

Les options : comme pour SDL_Init on doit utiliser des flags pour définir des options. Voici les principaux flags que vous pouvez utiliser (et combiner avec le symbole "|") :

* SDL_HWSURFACE : les données seront chargées dans la mémoire vidéo, c'est-à-dire dans la mémoire de votre carte 3D. Avantage : cette mémoire est plus rapide. Défaut : il y a en général moins d'espace dans cette mémoire que dans l'autre (SDL_SWSURFACE).
* SDL_SWSURFACE : les données seront chargées dans la mémoire système (c'est-à-dire la RAM à priori). Avantage : il y a plein de place dans cette mémoire. Défaut : c'est moins rapide et moins optimisé.
* SDL_RESIZABLE : la fenêtre sera redimensionnable. Par défaut elle ne l'est pas.
* SDL_NOFRAME : la fenêtre n'aura pas de barre de titre ni de bordure.
* SDL_FULLSCREEN : mode plein écran. Dans ce mode, aucune fenêtre n'est ouverte. Votre programme prendra toute la place à l'écran, en changeant automatiquement la résolution de votre écran au besoin.
* SDL_DOUBLEBUF : mode double buffering. C'est une technique très utilisée dans les jeux 2D qui permet de faire en sorte que les déplacements des objets à l'écran soient fluides (sinon ça scintille et c'est moche).

Pour changer le nom de la fenêtre, il suffit de mettre la commande ci-dessous:

SDL_WM_SetCaption("Non de la fenêtre", "Nom de l' icone");
Je ne sais pas trop à quoi sert "nom de l' icone" mais bon...
Je vous conseille de mettre NULL à la place de "Nom de l' icone".

Pour faire une surface, on va utiliser le type suivant:
SDL_Surface

Pour dessiner des rectangles, on utilise la formule suivante:

SDL_FillRect(surface, NULL, couleur);

* Un pointeur sur la surface dans laquelle on doit dessiner (par exemple ecran).
* La partie de la surface qui doit être remplie. Si vous voulez remplir toute la surface (et c'est ce qu'on veut faire), envoyez NULL.
* La couleur à utiliser pour remplir la surface.

A mettre comme type devant une variable de couleur:

* Uint32 : un entier de longueur 32 bits (soit 4 octets, quant on sait que 1 octet = 8 bits Wink

)
* Uint16 : un entier codé sur 16 bits (2 octets)
* Uint8 : un entier codé sur 8 bits (1 octet)

La fonction qui permet de faire une couleur:
SDL_MapRGB();
* Le format des couleurs. Ce format dépend du nombre de bits / pixel que vous avez demandé avec SDL_SetVideoMode. Vous pouvez le récupérer, il est stocké dans la sous-variable ecran->format
* La quantité de rouge de la couleur
* La quantité de vert de la couleur
* La quantité de bleu de la couleur
La quantité de couleur varie de 0 à 255
exemple:
SDL_MapRGB(ecran->format, 255, 0, 0)

autre exemple:
Uint32 bleuVert = SDL_MapRGB(ecran->format, 17, 206, 112);

Si on veut veut un rectangle bleu vert on va faire ceci:
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 17, 206, 112));

Pour faire une mise à jour de l' écran on utilise la fourmule suivante:

SDL_Flip(ecran);

Pour créer sa propre surface délimité:
SDL_CreateRGBSurface();

8 paramètres:
Je vais en citer que 4 pour le moment.

* Une liste de flags (des options). Vous avez le choix entre :
o SDL_HWSURFACE : la surface sera chargée en mémoire vidéo. Il y a moins d'espace dans cette mémoire que dans la mémoire système (quoique, avec les cartes 3D qu'on sort de nos jours...), mais cette mémoire est plus optimisée et accélérée.
o SDL_SWSURFACE : la surface sera chargée en mémoire système où il y a beaucoup de place, mais cela obligera votre processeur à faire plus de calculs. Si vous aviez chargé la surface en mémoire vidéo, c'est la carte 3D qui aurait fait la plupart des calculs.

* La largeur de la surface (en pixels)
* La hauteur de la surface (en pixels)
* Le nombre de couleurs (en bits / pixel)

exemple:
rectangle = SDL_CreateRGBSurface(SDL_HWSURFACE, 220, 180, 32, 0, 0, 0, 0);
penser à libérer après l' espace alloué avec la commande suivante:
SDL_FreeSurface(rectangle);
Bien sûr avant la commande qui vous fera quitter le programme.

La fonction SDL_BlitSurface(); permet de coller la surface limitée:
Elle doit posséder 4 paramètres:
* La surface à coller (ici, ce sera rectangle)
* Une information sur la partie de la surface à coller (facultative). Ca ne nous intéresse pas car on veut coller toute la surface, donc on enverra NULL
* La surface sur laquelle on doit coller, c'est-à-dire ecran dans notre cas.
* Un pointeur sur une variable contenant des coordonnées. Ces coordonnées indiquent où devra être collée notre surface sur l'écran (la position quoi Wink

)

Positionner en haut à gauche de l'écran:
SDL_Rect position;

position.x = 0;
position.y = 0;

Plus loin:

SDL_BlitSurface(rectangle, NULL, ecran, &position);

Charger une image:

SDL_LoadBMP("nom_de_l_image.bmp"); // Permet de charger le BMP.

SDL_WM_SetIcon(SDL_LoadBMP("sdl_icone.bmp"), NULL); // Pour afficher une icone.
/*La fonction SDL_WM_SetIcon doit être appelée avant que la fenêtre ne soit ouverte, c'est-à-dire qu'elle doit se trouver avant SDL_SetVideoMode dans votre code source.
Une icône doit être de 16 * 16 pixels... Avec la SDL on doit faire une icône sur 32*32 pixels*/

SDL_SetColorKey(variable, SDL_SRCCOLORKEY, SDL_MapRGB(zozor->format, 0, 0, 255)); //Fonction permettant de rendre transparente une couleur!
/* Les parmêtres de cette fonction sont les suivants:
# La surface qui doit être rendue transparente (ici c'est zozor)
# Une liste de flags. Utilisez SDL_SRCCOLORKEY pour activer la transparence, 0 pour la désactiver.
# Indiquez ensuite la couleur qui doit être rendue transparente. J'ai utilité SDL_MapRGB pour créer la couleur au format nombre (Uint32)*/

SDL_SetAlpha(zozor, SDL_SRCALPHA, 128); // Couleur transparente Alpha
/* * La surface en question (zozor)
* Une liste de flags. Mettez SDL_SRCALPHA pour activer la transparence, 0 pour la désactiver.
* Très important : la valeur Alpha de la transparence. C'est un nombre compris entre 0 (image totalement transparente, donc invisible) et 255 (image totalement opaque, comme s'il n'y avait pas de transparence alpha)
*/

La SDL peut aussi gérer les types suivants:
* TGA
* BMP
* PNM
* XPM
* XCF
* PCX
* GIF
* JPG
* TIF
* LBM
* PNG
Mais pour ça, il vous faudra la libraire SDL_Image.
Elle se trouve dans le lien ci-dessous:
http://www.libsdl.org/projects/SDL_image/release/SDL_image-devel-1.2.5-VC6.zip
Et pour l' inclure, il suffit de faire...
#include <SDL/SDL_image.h>
dans votre code.

Evénements! ( Clavier, souris, etc..)
Clavier:

SDL_Event variable;
// Permet de traiter des événements via cette variable..
SDL_WaitEvent(&variable); /* Cette fonction bloque le programme tant qu' il n' y a pas eu d' événements*/
SDL_PollEvent(&variable); /* Même chose que la fonction a_ dessus sauf que cette fonction ne bloque pas le programme*/
//(variable.type) dans une fonction, cela permet de stocker le type de la variable
SDL_QUIT: // C' est la chose qui permet de quitter le programme
SDL_KEYDOWN : //quand une touche du clavier est enfoncée
SDL_KEYUP : //quand une touche du clavier est relâchée
event.key.keysym.sym /* Cette variable permet de récupérer la valeur de la touche appuyée*/
SDL_EnableKeyRepeat(parmètre1, paramètre2);
/*
Voici les deux paramètres:
* La durée (en millisecondes) pendant laquelle une touche doit rester enfoncée avant d'activer la répétition des touches.
* Le délai (en millisecondes) entre chaque génération d'un évènement SDL_KEYDOWN une fois que la répétition a été activée.
*/

// Petite aide: Rappel:
ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
// Ajouter la constante SDL_DOUBLEBUF pour faire deux écrans qui s' altèrnent.
/* Ecran A envoye l' image tandis que l' écran B prépare la future image
ensuite
Ecran B envoye l' image tandis que l' écran A prépare la future image
etc.. etc..
La SDL_DOUBLEBUF permet d' éviter de faire scintiller l' écran.
*/

Souris:

SDL_MOUSEBUTTONDOWN //Moment on appuye sur le bouton de la sourie.
SDL_MOUSEBUTTONUP //Moment où on relache la sourie.
SDL_MOUSEMOTION //Moment où la sourie se déplace.

SDL_BUTTON_LEFT //clic avec le bouton gauche de la souris.
SDL_BUTTON_MIDDLE /*clic avec le bouton du milieu de la souris (tout le monde n'en a pas forcément un).*/
SDL_BUTTON_RIGHT //clic avec le bouton droit de la souris.
SDL_BUTTON_WHEELUP //molette de la souris vers le haut.
SDL_BUTTON_WHEELDOWN //molette de la souris vers le bas.

variable.button.button // Pour récupérer la valeur du bouton appuyé
event.button.x // Pour récupérer l' emplacement de la sourie en x lorsqu' on clique
event.button.y // Pour récupérer l' emplacement de la sourie en y lorsqu' on clique

event.motion.x // Pour récupérer les coordonnées de la sourie en x
event.motion.y // Pour récupérer les coordonnées de la sourie en y

SDL_ShowCursor(paramètre); /* Cette fonction permet de faire disparaitre le curseur de la sourie ou de le faire réaparraitre et cette fonction prend en paramètre les paramètres ci-dessous:*/

SDL_DISABLE : masque le curseur de la souris
SDL_ENABLE : réaffiche le curseur de la souris

SDL_WarpMouse(paramètre1, paramètre2);
/*Permet de placer la sourie à l' endroit choisis.
paramètre1 = position x de la sourie
paramètre2 = position y de la sourie*/

Joysticks:
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK);
printf("Il y a %ld joysticks connectés\n", SDL_NumJoysticks()); /* La fonction
SDL_NumJoysticks() permet de savoir combien il y a de joystick branché sur port usb ou jeu */
SDL_JoystickName(x); /* ¨Permet de savoir le nom d' un joysticks x la valeur du joysticks
*/
SDL_Joystick *joystick = NULL; // Pointeur qui pointera sur le joystick choisis.
SDL_JoystickEventState(SDL_ENABLE); /* Active la gestion des évènements des joysticks. */
joystick = SDL_JoystickOpen(0); //Charge le joystick 0 ( le premier )

printf("----> %d boutons\n", SDL_JoystickNumButtons(joystick));/*Affiche donc le nombre de boutons à l' écran*/
printf("----> %d axes\n", SDL_JoystickNumAxes(joystick));/* Affiche le nombre d' axes à l'écran*/
printf("----> %d trackballs\n", SDL_JoystickNumBalls(joystick));/* Affiche le nombre de trackballs à l' écran*/
printf("----> %d chapeaux\n", SDL_JoystickNumHats(joystick));/*Affiche le nombre de chapeaux à l' écran.*/

SDL_JOYBUTTONDOWN : //appui sur un bouton
SDL_JOYBUTTONUP : //relâchement d'un bouton

//La variable à utiliser:
event.jbutton.button
/* J' vous laisse décomposer la sous sous variable. ^^ C'est la même que celle du clavier
et de la sourie, on a juste modifié la sous variable. Smile

*/
event.jaxis.value // Variable pour connaitre l' inclinaison du joystick.
// Pour vérifier ceci, on va faire une condition avec switch et rajouter un if dans la case.
case SDL_JOYAXISMOTION:{
if (event.jaxis.value < -3200 || event.jaxis.value > 3200)
{
/* Le manche (ou le stick) a été déplacé de sa position initiale */
}
break; /* Cette méthode, je pense, doit être utilisée par tous les makers
qui se servent du joystick dans leur projet.
En tout cas, moi, c'est celle là que j' utiliserai... Mais pour l' instant, je n' ai pas encore
eu locasion de faire un jeu qui se servirait du joystick ( bien sûr, au moment où j' écris.)...
Mais je pense que ce ne serait tardé. ^^*/
}
// Bon, pour savoir exactement la direction incliné, on va se servir de la variable:
event.jaxis.axis
/*
0 si c'est un mouvement dans l'axe gauche-droite.
1 si c'est un mouvement dans l'axe haut-bas.
J' vous laisse chercher comment faire!
C'est tout simple! ^^
Une condition en (positif ou négatif selon les axes: haut-gauche =-() droite-bas =+())
Et aprés l' instruction. Razz

Oh!! DUR xD*/

SDL_JoystickClose(joystick);//Pour fermer la gestion de l' événement joystick

La librairie à utiliser quand on a installé la SDL est la suivante:
( celle de base de la SDL)
#include <SDL/SDL.h>

Langage C

La librairie SDL

PartieII

Les événements d' une fenêtre:

ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_RESIZABLE);
event.resize.w//Permet de savoir la dimmension d' une fenêtre. en x
event.resize.h//Permet de savoir la dimmension d' une fenêtre. en y

SDL_ACTIVEEVENT /* Elle est générée lorsqu' il y a le focus.
Le focus, c'est lorsque la fenêtre est visible à l' écran et lorsque la sourie
est dedans. ^^
*/
//Voilà quelque variable pour ce thème en plus!

* event.active.gain : indique si l'évènement est un gain (1) ou une perte (0). Par exemple, si la fenêtre est passée en arrière-plan c'est une perte (0), si elle est remise au premier plan c'est un gain (1).
* event.active.state : c'est une combinaison de flags indiquant le type d'évènement qui s'est produit. Voici la liste des flags possibles :
o SDL_APPMOUSEFOCUS : la souris vient de rentrer ou de sortir de la fenêtre.
Il faut regarder la valeur de event.active.gain pour savoir si elle est rentrée (gain = 1) ou sortie (gain = 0) de la fenêtre.
o SDL_APPINPUTFOCUS : l'application vient de recevoir le focus du clavier ou de le perdre. Cela signifie grosso modo que votre fenêtre vient d'être mise au premier plan ou en arrière-plan.
Il faut regarder la valeur de event.active.gain pour savoir si la fenêtre a été mise au premier plan (gain = 1) ou en arrière-plan (gain = 0).
o SDL_APPACTIVE : l'applicaton a été iconifiée, c'est-à-dire réduite dans la barre des tâches (gain = 0), ou restaurée dans son état normal (gain = 1).

if ((event.active.state & SDL_APPMOUSEFOCUS) == SDL_APPMOUSEFOCUS) /*Cette condition nous permet de savoir si il y a eu un changement de focus de la sourie. */
if ((event.active.state & SDL_APPACTIVE) == SDL_APPACTIVE)
// C'est le même modèle pour les autres...
if ((event.active.state & SDL_APPACTIVE) == SDL_APPACTIVE)
{
if (event.active.gain == 0) /* La fenêtre a été réduite en barre des tâches */
pause = 1;
else if (event.active.gain == 1) /* La fenêtre a été restaurée */
pause = 0;
}//Pause vaudra 1 lorsque la fenêtre sera iconée.

Delay, Ticks

SDL_Delay(); /*permet de mettre en pause le programme un certain nombre de millisecondes.*/
SDL_GetTicks(); /*retourne le nombre de millisecondes écoulées depuis le lancement du programme.*/

Faire dormir un programme X ms:

void SDL_Delay(Uint32 ms);//Type la fonction..
SDL_Delay(1000);//Attend une seconde soit 1000ms
/* Rappel:
1000 millisecondes = 1 seconde
750 millisecondes = 3/4 seconde
500 millisecondes = 1/2 seconde
250 millisecondes = 1/4 seconde */

Connaitre le temps d' exécution d' un programme:

SDL_GetTicks(); /* renvoye le temps qui s'est écoulé durant la durée d' éxécution du programme. */

Uint32 SDL_GetTicks(void); /* mais cette fonction est remise à 0 au bout de 49 jours, il me semble...*/

Créer un timer:

SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER); //Préparation du timer.
SDL_AddTimer(); //
SDL_SetTimer(); //

SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param);//Prototype... A mettre dans un".h" ou dans le fichier ".c"

/* Les 3 paramètres de la fonction sont:
1: L'intervalle de temps (en ms) entre chaque appel de la fonction
2: Le nom de la fonction à appeler. On appelle cela un callback : le programme se charge de rappeler cette fonction de callback régulièrement.
3: Les paramètres à envoyer à votre fonction de callback.*/

SDL_TimerID timer; // Variable pour stocker le numéro du Timer */
timer = SDL_AddTimer(30, mouvementPicture, &positionPicture); /* Démarrage du Timer
Voici les paramètres de cette fonction:
1: Il sera appelé toutes les 30ms
2: Il appellera la fonction de callback mouvementPicture
3: Il lui enverra comme paramètre un pointeur sur la position de la picture pour qu'il puisse la modifier.*/

//La fonction pour bouger ma picture sera la suivante:
Uint32 mouvementPicture(Uint32 intervalle, void *parametre);

//Fonction et l' instruction de la fonction:
Uint32 mouvementPicture(Uint32 intervalle, void *parametre)
{
SDL_Rect* positionPicture = parametre; /* Conversion de void* en SDL_Rect* */
positionPicture->x++;

return intervalle;
}
/* Les deux paramètres de cette fonction sont:
1: L'intervalle de temps qui sépare 2 appels de la fonction
2: Le paramètre "personnalisé" que vous avez demandé à envoyer à la fonction. Ce paramètre est un pointeur sur void. C' est donc un pointeur qui peut pointer sur n'importe quoi : un int, une structure personnalisée, ou comme ici un SDL_Rect*/

//Et pour stopper le timer, on va utiliser:
SDL_RemoveTimer(timer);

Afficher du texte à l' écran dans une fenêtre avec la librairie SDL_ttf (Vous pouvez la trouver sur les liens de la SDL [plus haut]):
//A inclure:
#include <SDL/SDL_ttf.h>

TTF_Init(); //démarre SDL_ttf.
TTF_Quit(); //arrête SDL_ttf.

TTF_GetError(); // Les éreurs de la librairie SDL_ttf se trouvent dans cette fonction..

TTF_OpenFont(p1; p2); // ouvre un fichier de police (.ttf)
TTF_CloseFont(variable); // ferme une police ouverte.
// variable = le pointeur qui pointe sur la police
/*p1 = Le nom du fichier de police (au format .ttf) à ouvrir. L'idéal c'est de mettre le fichier de police dans le répertoire de votre projet. Exemple de fichier : arial.ttf (pour la police Arial).

p2 = * La taille de la police à utiliser. Vous pouvez par exemple utiliser une taille de 22.
Ce sont les mêmes tailles que celles que vous avez dans un logiciel de texte comme Word.*/

/* Pointeur:*/
TTF_Font *police = NULL;

// Vous pourrez trouver des polices à cet emplacement si vous êtes sous windows:
C:/Windows/Fonts
/* Quand on choisit une police, il faut les renommer si le nom de la police
possède des charactères bizarres...
Mettez le nom de la police en minuscule et retirer les charactères spécifiques*/

police = TTF_OpenFont("angelina.ttf", 65); // on choisit la police.

//Type de police:

/*
Solid c'est la technique la plus rapide. Le texte sera rapidement écrit dans une SDL_Surface. La surface sera transparente mais n'utilisera qu'un niveau de transparence (on a appris ça il y a quelques chapitres). C'est pratique, mais le texte ne sera pas très joli, pas très "arrondi" surtout s'il est écrit gros. Utilisez cette technique lorsque vous devez souvent changer le texte (par exemple pour afficher le temps qui s'écoule ou le nombre de FPS d'un jeu).
Shaded cette fois, le texte sera joli. Les lettres seront antialiasées, le texte apparaîtra plus lisse. Il y a un défaut par contre : le fond doit être d'une couleur unie. Pas moyen de rendre le fond de la SDL_Surface transparente en Shaded.

Blended c'est la technique la plus puissante, mais elle est lente. En fait, elle met autant de temps que Shaded à créer la SDL_Surface. La seule différence avec Shaded, c'est que vous pouvez blitter le texte sur une image et la transparence sera respectée (contrairement à Shaded qui imposait un fond uni). Attention : le calcul du blit sera plus lent que pour Shaded.
*/

TTF_RenderText_Solid();
TTF_RenderText_Shaded();
TTF_RenderText_Blended();

//Définir une couleur pour la police:

SDL_Color couleurNoire = {0, 0, 0};

texte = TTF_RenderText_Blended(police, "Affiche couleurNoire!", couleurNoire);/*lire le message qui doit s' afficher. Smile

Ca écrira "Affiche couleurNoire" */

/*Pour faire mettre de la police en gras, italique ou autre:
TTF_SetFontStyle(p1, p2); /*p1 = Variable de la police p2 = indique l' état de la police
par:
* TTF_STYLE_NORMAL : normal.
* TTF_STYLE_BOLD : gras.
* TTF_STYLE_ITALIC : italique.
* TTF_STYLE_UNDERLINE : souligné.
On peut les combiner avec le symbole "|"
*/
sprintf(); // comme fprintf ou printf sauf que elle change un char en nombre.

/* Pour positionner du texte là où on veut, on va utiliser la même variable que un bitmap
sauf qu' on va le mêttre avant le blit. */

» La librairie FMOD en C [mots clefs]
» C/C++ [mots cléfs]
» Ruby [mots clefs]
» Programmation 3d avec OpenGL (mots clefs)