Les surfaces et la création de couleur

Les surfaces

Avec la SDL, vous utilisez des surfaces. Ce sont des sortes de calques pour ceux qui maitrisent les bases de l'infographie.


Comme son nom l'indique, c'est une surface que l'on colle sur la fenêtre pour l'afficher.
Voici le mode de fonctionnement de ces surfaces: Si vous souhaitez avoir une fenêtre avec un fond rouge, il suffit de:

1) Créer une surface.
2) "Colorier" cette fenêtre en rouge.
3) Coller cette surface sur la surface représentant l'écran.
4) Mettre à jour l'écran.

Rien de bien compliqué Voyons donc comment, tout d'abord, créer une surface.


La création d'une surface

Comme nous l'avons déjà vu rapidement dans le chapitre de création d'une fenêtre, il nous faut créer le type de variable SDL_Surface.
 

Chaque surface que l'on créera, dans l'avenir, sera un pointeur il faut donc impérativement écrire:
 

 

SDL_Surface *maSurface = NULL;

Voilà, tout simplement pour la création d'une surface. Simple non? D'ailleurs, rappelez-vous toujours que l'écran est une surface classique avant tout


Coloriez une surface

Tout d'abord il vous faut...créer une surface Pour ce tuto, nous allons directement colorier l'écran
 

SDL_Surface *ecran = NULL;

Ensuite, il faut savoir, qu'une surface, est rectangulaire. Voici le prototype de la fonction permettant de "colorier" votre surface:
 

int SDL_FillRect(SDL_Surface* dst, const SDL_Rect* rect, Uint32 color);
 

Cette fonction retourne 0 si tout c'est bien passé ou un nombre négatif en cas d'erreur.

 

-Le premier paramètre désigne la surface à colorier.
-Le second désigne l'endroit de cette surface à colorier. Nous allons ici tout colorier mais il est possible de ne le faire qu'à un certain endroit comme nous le verrons d'ici la fin de ce chapitre.
-Le troisième et dernier paramètre désigne la couleur à utiliser.

Pour ce troisième paramètre nous allons utiliser une autre fonction de la SDL, qui retourne justement un Uint32 et qui prend, comme arguments, les valeurs RGB de la couleur voulue au final.

Prenons un exemple:

Nous souhaitons colorier en blanc notre écran.
Pour cela procédons par étapes:

1) Nous créons une surface nommée écran et construisons une fenêtre comme je vous l'ai déjà expliqué dans les chapitres précédents

Code:

#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;   //On créer notre surface.
    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;
}



2) On colorie notre surface écran avec la fonction SDL_FillRect comme ceci:
 

    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));

PS: Le premier paramètre de la fonction SDL_MapRGB(celle qui créer un Uint32) est un membre de la strucure "ecran".

Nous avons donc:

#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;   //On créer notre surface.
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

//On colorie cette surface.
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));

    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 et .... la fenêtre est noire --"

Normal! :P Nous avons bien colorié notre surface mais virtuellement. Il faut maintenant dire à la SDL de mettre à jour notre programme, ce qui aura pour effet de réafficher la surface écran modifiée, et par conséquant, afficher une belle fenêtre au fond blanc!

Pour mettre à jour une surface, il suffit d'utiliser cette fonction:
 

SDL_Flip(surface);

Après avoir effectué les modifications voulues. Ici, la surface à mettre à jour est ecran, il suffit donc d'écrire ce code-ci:


#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;   //On créer notre surface.
    ecran = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);

//On colorie cette surface.
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
    SDL_Flip(ecran); //On met à jour l'écran.

    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;
}

Et après compilation, cela nous donne:
 

Génial non?
Amusez-vous à changer la couleur de ce fond en réécrivant le code à chaque fois
Cela vous fera un bon exercice
Voyons maintenant comment coller une surface sur une autre grâce à la SDL


Le collage de surfaces

Vous avez jusqu'ici appris à modifier directement une surface et à mettre à jour l'écran. Seulement, cette utilisation est très rare pour les jeux 2D par exemple.
Dans un projet de type jeux vidéo, le programmeur préfère "coller" une surface sur une autre c'est beaucoup plus simple et intuitif.

Voici la fonction permettant de "coller" une surface sur une autre:
 

SDL_BlitSurface(surfaceSource, source, surfaceDefinition, &position);

-Le premier paramètre désigne la surface à coller.
-Le second désigne l'endroit de la surface à copier. Personnellement, je colle tout le temps toute l'image voulue donc on le laissera à NULL pour la suite de ce tutoriel
-Le troisième paramètre désigne la surface de destination (celle où l'autre surface sera collée par-dessus).
-Le dernier paramètre désigne la position à laquelle coller la surface sur l'autre. Pour ce faire, il nous faut utiliser un nouveau type de variable qui est SDL_Rect, comme ceci:

SDL_Rect position;

Cette variable est une struture contenant 4 membres:

position.x
position.y
position.w
position.h

Ici, comme nous allons faire un "collage classique" nous allons juste renseigner les axes X et Y.
(x = horizontal, Y = vertical) comme ceci par exemple:

SDL_Rect position;
position.x = 10;
position.y = 20;

Donc pour "coller" une surface sur une autre à cette position, il nous faudra donc écrire:


SDL_Rect position;
position.x = 10;
position.y = 20;



Avant de voir à quoi cette fonction peut bien servir dans des cas concrets, nous allons nous intéresser à l'affichage d'images avec la SDL. Vous verrez qu'après ce chapitre, vous serez en mesure de faire des choses de plus en plus intéressantes avec la SDL




Personnalisons notre fenêtre                                                               Afficher des images