« Programmation avec la SDL/La transparence » : différence entre les versions

Contenu supprimé Contenu ajouté
m Petit oubli
Ajout de contenu.
Ligne 7 :
 
== Les modes de fusions ==
=== Présentation ===
 
En fait, un pixel n'est composé au départ que du rouge, du vert et du bleu. Au total, pour mémoriser une couleur, on utilise donc 3 octets répartis entre les trois couleurs primaires. Mais vous savez qu'un ordinateur n'aime guère les nombres impairs, et qu'il adore les puissances de 2. Pour stocker une couleur, on utilise donc 4 octets. Comme il restait un octet de libre, on a ajouté un canal alpha complètement fictif. En fait, celui-ci va être utilisé au moment où l'on va vouloir afficher le pixel à l'écran. Il indique seulement à quel point nous devons prendre en compte la couleur du pixel qui va être remplacé (la destination) par le pixel qu'on veut afficher (la source). Pour cela, il existe de très nombreuses façons de calculer la couleur du pixel résultant de la superposition de la destination et de la source que l'on appelle des modes de fusion (''blend mode'' en anglais). La SDL n'en compte que trois :
Ligne 37 ⟶ 36 :
|}
 
===Renderer Enet pratiquetextures ===
En pratique, on n'utilise que le mode SDL_BLENDMODE_BLEND. Par conséquent, si vous n'avez pas compris ce qui précèdent, utilisez ce mode sans vous poser de questions. Pour l'appliquer au renderer, il suffit d'utiliser la fonction
Le mode de transparence par défaut est SDL_BLENDMODE_BLEND. En pratique, pour récupérer le mode de fusion d'une texture, on utilise le fonction suivante :
<source lang = "c">
int SDL_GetTextureBlendModeSDL_SetRenderDrawBlendMode(SDL_TextureSDL_Renderer* texturerenderer, SDL_BlendMode* blendMode);
</source>
Pour l'appliquer à une texture, il suffit d'utiliser :
<source lang = "c">
int SDL_SetTextureBlendMode(SDL_Texture* texture, SDL_BlendMode blendMode);
</source>
 
Comme presque toujours dans la SDL, les fonctions pour récupérer le mode de fusion existent aussi. Celle-ci demandent en argument un pointeur de SDL_BlendMode qui sera rempli par le mode de fusion de la texture ou du renderer.
Pour changer le mode de fusion d'une texture, on a :
 
<source lang = "c">
int SDL_SetTextureBlendMode(SDL_Texture* texture, SDL_BlendMode *blendMode);
int SDL_SetRenderDrawBlendMode(SDL_Renderer* renderer, SDL_BlendMode *blendMode);
</source>
 
Vous demandez probablement pourquoi il existe une fonction permettant de modifier le mode de fusion du renderer. En réalité, étant donné qu'il n'y a rien "derrière" le renderer, cette transparence ne va s'appliquer au pixels du renderer mais plutôt aux fonctions de dessin associées au renderer, ''même quand le renderer n'es pas la cible des modifications''. En revanche, lorsqu'on applique une transparence aux texture, celle-ci s'exprimera lorsqu'on affichera la texture sur le renderer : on verra en transparent les pixels du renderer derrière la texture. Il est important de comprendre cette différence car le résultat n'est pas le même. Le mieux pour s'en rendre de compte est de la voir sur un exemple.
 
En supposant que le fond du renderer est noir, affichez une texture dont le fond est bleu et où l'on a tracé un superbe carré rouge totalement transparent. Voici le code correspondant :
<source lang = "c">
SDL_Rect texture_pos = {0,0,0,0};
int SDL_SetTextureBlendMode(SDL_Texture* texture,SDL_BlendMode blendMode);
texture = SDL_CreateTexture(renderer,SDL_PIXELFORMAT_RGBA8888,SDL_TEXTUREACCESS_TARGET,100,100);
SDL_QueryTexture(texture,NULL,NULL,&texture_pos.w,&texture_pos.h);
 
SDL_SetRenderDrawBlendMode(renderer,SDL_BLENDMODE_NONE);
SDL_SetTextureBlendMode(texture,SDL_BLENDMODE_BLEND);
 
SDL_SetRenderDrawColor(renderer,0,0,255,255);
SDL_SetRenderTarget(renderer,texture);
SDL_RenderFillRect(renderer,&texture_pos);
SDL_SetRenderDrawColor(renderer,255,0,0,0);
SDL_Rect rectangle = {20,20,50,50};
SDL_RenderFillRect(renderer,&rectangle);
SDL_SetRenderTarget(renderer,NULL);
</source>
 
En essayant les différentes possibilités avec SDL_BLENDMODE_BLEND et SDL_BLENDMODE_NONE, vous devriez obtenir :
Dans les deux cas, les fonctions renvoient l'habituel 0 pour signaler que tout s'est bien passé et une valeur négative sinon. Les prototypes parlent d'eux-même, je n'en dirai donc pas plus.
*Si ni le renderer, ni la texture n'ont leur transparence activée, le carré apparaît rouge. Ceci s'explique par le fait que la transparence n'est pas du tout activée.
*Si la transparence du renderer est activée mais pas celle de la texture, le carré apparaît bleu : en effet, on a dessiné un carré transparent sur un fond bleu.
*Si la transparence de la texture est activée mais pas celle du renderer, le carré apparaît noir : en effet, on a en quelque sorte remplacé le fond bleu par un carré transparent.
*Si la transparence est activée pour les deux, le carré apparaît bleu : on dessine d'abord un carré transparent sur fond bleu, puis on affiche ce fond bleu (qui lui, n'est pas transparent).
 
Il apparaît donc que la gestion de la transparence n'est pas toujours aisée avec la SDL. Si vous avez eu du mal à suivre, le mieux serait peut-être d'essayer les différentes possibilités pour obtenir le résultat que vous souhaitez.
 
==Les surfaces==
Des fonctions similaire existent pour les surfaces (il suffit de remplacer texture par surface). Cependant, elles ne sont utiles que pour le fonctions de '''blit''' qui ne sont pas traitées dans ce livre étant donné qu'elles sont obsolètes puisqu'elles n'utilisent pas l'accélération matérielle.