Programmer en C++
SDL2 - Des images

1. Introduction

Pour commencer simplement, nous ne traiterons dans cette partie que les images de type "BMP". L'installation de librairies spécifiques sera nécessaire ensuite pour manipuler d'autres formats.

2. Afficher une image dans une fenêtre

Au préalable, toute image doit être chargée dans une "surface". Une surface est tout simplement un espace mémoire spécifique, qui est attribué à une image. La fonction retourne alors un pointeur de type "SDL_Surface" désignant cette zone mémoire. C'est ce pointeur qui servira ensuite aux diverses manipulations.
Syntaxe de cette fonction :

SDL_Surface *SDL_LoadBMP(const char *file)

"file" représente le nom de l'image à charger avec éventuellement le chemin nécessaire pour le trouver sur le disque.

Exemple : Supposons que le nom de l'image à charger soit "mur.bmp", et que nous donnions le nom d' "image" au pointeur désignant la surface. Alors nous écrirons :

SDL_Surface *image = SDL_LoadBMP("mur.bmp");

Attention, il ne faudra pas oublier de libérer la mémoire utilisée par cette surface avant de quitter le programme, ce qui se fera ici en écrivant :

SDL_FreeSurface(image);

Puisque l'image peut accidentellement se retrouver séparée du programme, il est prudent de vérifier que le chargement a été bien réalisé. On teste ici le pointeur qui contiendra NULL en cas d'absence de l'image.

if (!image)
{
    cout << "erreur de chargement de l'image" << endl;
}

L'étape suivante transforme notre surface en texture. Je reconnais qu'on n'a pas fait ici dans la simplicité, mais il semblerait que cette étape soit essentielle pour des raisons de compatibilités avec le processeur graphique.
On écrira :

SDL_Texture *pTextureImage = SDL_CreateTextureFromSurface(pRendu, image);

Nous venons de créer un pointeur de type "SDL_Texture" que nous avons nommé "pTextureImage". La fonction SDL_CreateTextureFromSurface() assure le transfert de l'image de la surface vers la texture en adaptant au besoin le format.
A ce stade, de la mémoire peut être libérée en détruisant le pointeur de surface ("image"). Il n'y a aucune conséquence sur l'image elle-même qui se trouve maintenant dans la texture.

Nous voilà arrivé maintenant au moment de placer notre image dans la fenêtre. Enfin !
La syntaxe de la fonction permettant cet affichage est :

int SDL_RenderCopy(SDL_Renderer *pRendu, SDL_Texture *pTextureImage,
                const SDL_Rect *srcrect, const SDL_Rect *dstrect)

Les deux premiers arguments transmis, sont respectivement le pointeur de rendu qui permet de désigner la "destination" (l'espace mémoire d'affichage de la fenêtre), puis le pointeur de texture qui désigne la "source" (la mémoire contenant l'image. Pour l'instant nous allons ignorer les deux paramètres restant, qui nous verrons plus loin permettrons de préciser la modalité de transfert de cette image.
Retenez juste qu'en fournissant un pointeur "NULL" à ces deux paramètres, l'image entière sera appliquée en totalité sur la fenêtre. Voilà c'est parti écrivons :

SDL_RenderCopy(pRendu, pTextureImage, nullptr, nullptr);

Maintenant que l'image est passée dans le rendu, nous pouvons libérer la mémoire de texture.

SDL_DestroyTexture(pTextureImage);

Il ne vous reste plus qu'à actualiser la fenêtre pour admirer votre belle image, mais ça vous savez faire maintenant.
Voici le programme complet :

#include <iostream>
#include <SDL.h>

using namespace std;

int main(int argc, char* argv[])
{
    cout << "Image avec SDL" << endl;

    SDL_Window *pFenetre = 0;
    SDL_Renderer *pRendu = 0;

    SDL_Init (SDL_INIT_VIDEO);
    pFenetre = SDL_CreateWindow(
            "Image avec SDL", SDL_WINDOWPOS_CENTERED,
            SDL_WINDOWPOS_CENTERED, 600,
            400, SDL_WINDOW_SHOWN);

    pRendu = SDL_CreateRenderer(pFenetre, -1, SDL_RENDERER_ACCELERATED);

    // L'image est chargée dans une surface
    SDL_Surface *image = SDL_LoadBMP("mur.bmp");
    if (!image)
    {
        cout << "erreur de chargement de l'image" << endl;
    }
    // Transfert de l'image de la surface à une texture
    SDL_Texture *pTextureImage = SDL_CreateTextureFromSurface(pRendu, image);
    SDL_FreeSurface(image);     // La mémoire de surface est libérée
    // On applique l'image dans la fenêtre
    SDL_RenderCopy(pRendu, pTextureImage, nullptr, nullptr);
    SDL_DestroyTexture(pTextureImage);     // La mémoire de texture est libérée

    // Actualisation de la fenêtre
    SDL_RenderPresent(pRendu);

    int attendre = 1;
    SDL_Event evenement;

    // Boucle d'evenements
    while(attendre)
    {
        SDL_WaitEvent(&evenement);
        switch(evenement.type)
        {
            case SDL_QUIT:
                attendre = 0;
                break;
        }
    }

    SDL_DestroyRenderer(pRendu);
    SDL_DestroyWindow(pFenetre);
    SDL_Quit ();

    return EXIT_SUCCESS;
}

Voici le résultat :

L'image peut être téléchargée ici