Programmer en C++
SDL2 - Transparence d'une image

1. L'image : un rectangle

Lorsque nous superposons deux images de type "bmp", la dernière image affichée masque la précédente. Or si nous regardons de façons plus attentive, ce n'est pas l'objet que nous avons dessiné (ici un hélicoptère), mais la totalité du rectangle contenant l'image qui effectue ce masquage.
Il est évident que pour des questions de réalisme nous devons contourner ce défaut. Alors comment faire ?

La solution existe et elle est relativement simple :

• Premièrement choisir une couleur qui n'apparait pas dans l'objet : exemple un magenta RGB(255, 0, 255).
• Deuxièmement appliquez cette couleur sur toutes les surfaces que vous voulez rendre transparente.

Pour l'image de notre hélicoptère, celà donnerait ceci :

• Troisièmement et c'est la dernière étape, nous allons juste ajouter une ligne de code dans le programme.

Ou ça ?   Vous vous souvenez surement comment on crée une surface contenant une image. Par exemple ici avec l'image "helico.bmp", nous pourrions écrire :

// L'image "helico.bmp" est chargée dans une surface dont le pointeur est pSurfHelico
SDL_Surface *pSurfHelico = SDL_LoadBMP("helico.bmp");

Juste après avoir controlé que ce pointeur est valide, donc que l'image a bien été chargée, nous écrivons cette nouvelle ligne de code :

// C'est ici que nous indiquons la couleur qui doit être rendue transparente
SDL_SetColorKey(pSurfHelico, SDL_TRUE, SDL_MapRGB(pSurfHelico->format, 255, 0, 255));

On y trouve deux fonctions :

• SDL_MapRGB() qui permet de préciser le code couleur RGB qui sera utilisé pour la transparence, et
• SDL_SetColorKey() qui applique la transparence aux pixels concernés.

A partir de cette ligne, le programme peut continuer avec la transformation de la surface en texture qui conservera la transparence acquise dans cette image. Voilà c'est tout !

Vous trouverez ici un exemple de programme complet affichant l'hélicoptère sur un paysage.

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

using namespace std;

int main(int argc, char* argv[])
{
    cout << "Un hélico dans la prairie" << endl;

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

    // Création et initialisation d'une zone rectangulaire pour l'helico.
    SDL_Rect destRect;
    destRect.x = 150;
    destRect.y = 210;
    destRect.w = 200;
    destRect.h = 63;

    SDL_Init (SDL_INIT_VIDEO);
    pFenetre = SDL_CreateWindow(
            "Un helico dans la prairie", SDL_WINDOWPOS_CENTERED,
            SDL_WINDOWPOS_CENTERED, 600,
            400, SDL_WINDOW_SHOWN);

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

    // L'image de fond est chargé dans une surface
    SDL_Surface *pSurfaceFond = SDL_LoadBMP("fond.bmp");
    if (!pSurfaceFond)
    {
        cout << "Le fichier \"fond.bmp\" est introuvable" << endl;
    }
    // Transfert de l'image de la surface à une texture
    SDL_Texture *pTextureFond = SDL_CreateTextureFromSurface(pRendu, pSurfaceFond);
    SDL_FreeSurface(pSurfaceFond);     // La mémoire de surface est libérée

    // L'image de l'hélico est chargée dans une surface
    SDL_Surface *pSurfaceHelico = SDL_LoadBMP("helico.bmp");
    if (!pSurfaceHelico)
    {
        cout << "Le fichier \"helico.bmp\" est introuvable" << endl;
    }
    // C'est ici que nous indiquons la couleur qui doit être rendue transparente
    SDL_SetColorKey(pSurfaceHelico, SDL_TRUE,
                    SDL_MapRGB(pSurfaceHelico->format, 255 , 0 , 255 ));
    // Transfert de l'image de la surface à une texture
    SDL_Texture *pTextureHelico = SDL_CreateTextureFromSurface(pRendu, pSurfaceHelico);
    SDL_FreeSurface(pSurfaceHelico);     // La mémoire de surface est libérée
    // On dessine le paysage dans le rendu
    SDL_RenderCopy(pRendu, pTextureFond, nullptr, nullptr);
    SDL_DestroyTexture(pTextureFond);     // La mémoire de texture est libérée
    // On dessine l'helico à la position choisie dans le rendu
    SDL_RenderCopy(pRendu, pTextureHelico, nullptr, &destRect);
    SDL_DestroyTexture(pTextureHelico);     // 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 ce qu'on obtient :

Vous pouvez telechargez l'image du fond ici