Discussion :

[Ekinoks]

Salut !

Je cherche à rendre transparent une couleur dans une image importé.
Apres toute les recherches que j’ai pu faire, il me faut apparemment utiliser l’alpha-blending.
Malheureusement, j’arrive avec cela qu’a rentre TOUTE l’image plus ou mois transparent et pas seulement une seul couleur :’(

J’ai vue que dans le tutorial de loulou sur « la réalisation d’un moteur 3D en C++ » a un moment il se sert de ça : http://loulou.developpez.com/tutorie.../partie6/#L4.2
Mais le petit souci c’est que je n’arrive pas a voir comment es que il a fait :^/

Si non j’ai vu plain d’autre site qui parle de ca comme : http://eraquila.iquebec.com/site/delphi/opengl/gl6.htm mais il n’explique que comment rentre tout l’objet transparent :^/

J’ai donc une class pour importer une image :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
void Ctexture::cree(char * image)
{
    AUX_RGBImageRec *texture1;
    texture1 = auxDIBImageLoad(image);
    glGenTextures (1, &texture);
    glBindTexture (GL_TEXTURE_2D, texture);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);  
    glTexImage2D(GL_TEXTURE_2D, 0, 3, texture1->sizeX, texture1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, texture1->data);
}

Une foi l’image importé comme ceci et sélectionné sans oublié d’activer le GL_TEXTURE_2D, je veux l’afficher en appliquent un alpha-blending pour rendre une seul couleur transparent comme le noir, le blanc ou autre ...
Donc d’après que j’ai pu voir par ci par là cela devrais ressemblé a une truc du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
glEnable(GL_BLEND);   
glBlendFunc( ??? , ???);  // je ne sais pas trop quoi m'étre ladedans ...
glColor4f( ??? ); // cette fonction est elle nécessaire ?
        glBegin (GL_QUADS);                       
            glTexCoord2f(0.0,1.0);
            glVertex3f ( 2, 2,-5);              
 
            glTexCoord2f(1.0,1.0);
            glVertex3f ( -2, 2,-5);       
 
            glTexCoord2f(1.0,0.0);
            glVertex3f ( -2, -2,-5);            
 
            glTexCoord2f(0.0,0.0);
            glVertex3f ( 2, -2,-5);        
        glEnd ();

Merci de votre aide.

[Laurent Gomila]

Tu ne peux pas spécifier directement une couleur de transparence.

C'est à toi, lors du chargement de ta texture, de parcourir tous ses pixels et de remplacer ladite couleur par un alpha nul (ce qui implique d'avoir un canal alpha dans le format de pixel utilisé pour ta texture).

Ensuite tu peux utiliser l'alpha-blending en (SRC_ALPHA, ONE_MINUS_SRC_ALPHA), ou bien l'alpha test.

[Ekinoks]

Tout d’abord merci pour ta réponse si rapide

Donc si j’ai bien compris, il n’existe aucune fonction qui peu rendre une couleur invisible directement, c’est a moi d’inspecter tout les pixels de l’images ?
Et donc si c’est le cas, si je veux une premier foi rendre le blanc transparent et une deuxièmement foi rendre le noir transparent, je devrais importer deux foi la même images en cherchent un coup les pixels noir et un coup les pixels blanc ?

Merci

[Laurent Gomila]

Et donc si c’est le cas, si je veux une premier foi rendre le blanc transparent et une deuxièmement foi rendre le noir transparent, je devrais importer deux foi la même images en cherchent un coup les pixels noir et un coup les pixels blanc ?

A priori oui.

Tu peux aussi utiliser un format de fichier qui gère le canal alpha (tga, png), et remplir correctement celui-ci avec ton logiciel de dessin préféré, au lieu d'utiliser une couleur de transparence. Après ça dépend de ton appli.

[Ekinoks]

Tu peux aussi utiliser un format de fichier qui gère le canal alpha (tga, png), et remplir correctement celui-ci avec ton logiciel de dessin préféré, au lieu d'utiliser une couleur de transparence.

Tu veux dir que si j'utilise un de ces formats, je n'aurai pas a parcourir tous les pixels de l'image lors du chargement ?

[djo.mos]

Il y'a peut être une solution sans Alpha, mais ça marche pas très bien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
glAlphaFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);

De cette façon, les parties noires de l'image ne seront pas affichées !

Mais comme l'a dir Loulou24, la meilleure façon serait d'intervenir au niveau du chargeur de textures et d'ajouter une composante Alpha à partir des pixels, y'a pas mieux.

[Ekinoks]

Ok, merci
Je crois que je commence à comprendre.
Pour pouvoir rendre une couleur transparente, il faut qu'il y est une composante Alpha, et comme les .bmp ne peuvent pas être charger avec cette composante Alpha, il faut soit la créé soit même en ajoutant une composante Alpha à partir des pixels, soit utiliser une autre exemption comme les .tga ou les .png

C’est bien ça ?

[Laurent Gomila]

Tout à fait

[Ekinoks]

Ok, merci pour votre aide =)
et bravo Loulou24 pour ton tutorial sur le moteur 3d même si mes compétence ne sont pas encore suffisante pour arrivé a tout comprendre :^p

[bafman]

quelque precisions sur tout ca :
je considere ici que la texture est chargée avec les valeure alpha correctement positionnée.
une fois cette texture chargée, tu a 3 possibilitée :
- alpha test
- alpha blending
- alpha test + alpha blending

avec l'alpha test, tu aura une coupe franche dans tes texel... soit il est visible, soit il est invisible. ca donne un effet tres crenelée a la texture, et surtout si la texture est etendu, tu risque de voir apparaitre la couleur du texel supprimé sur les bords. par contre l'aventage de l'alpha test est qu'il est effectué plus vite dans le pipeline de rendu, il est donc plus rapide et surtout ne pose pas de problemes d'ordre de rendu.

avec l'alpha blending la coupure est nettement plus douce car la valeure alpha est interpolé est donc les fragments disparaissent plus progressivement, et un voit nettement moins la couleur du textel clippé. par contre, pour la carte graphique, ce n'est pas une réelle methode de clipping, dont il te faudra desactiver l'ecriture dans le depth buffer, et surtout, le fragment parcours l'ensemble du pipeline de rendu, c'est a dire qu'il sera ecrit dans le color buffer même si il est entierement transparent... c'est relativement lent. et un autre gros probleme, c'est qu'on touche a la transparence alpha, ce qui implique que l'ensemble des faces transparentes doivent etre rendu de la plus lointaine à la plus proche dans cet ordre... c'est tres lourd a effectué et le tri est encore une consommation de ressources supplementaire...

la troisieme methode : l'alpha test + alpha blending permet de cumuler a la fois les aventage mais (malheureusement) les desaventages.
elle est legerement plus rapide que l'alpha blending simple car l'alpha test va clipper le fragment transparent avant la fin du pipeline, le rendu aura la même qualitée qu'avec l'alpha blending, on peut conserver le deph test activé, mais par contre on conserve les probleme de tri des faces...

bref maintenant c'est a toi de choisir la methode que tu prefere... ah si, pour info : il semblerais que sur les cartes ATI on soit obligé d'activer le blending pour pouvoir faire de l'alpha test... oui c'est completement idiot et ca ne respecte pas les standard openGL... mais en même temps j'ai bien dit ATI hein (d'ailleur ca a peut etre été corrigé sur les drivers plus recents, je n'ai pas verifié )

[Ekinoks]

Ha ok, c’est bon a savoir ça... donc pour un affichage plus rapide un alpha test est souhaitable. Faut que je fasse une petite recherche pour voir commence ça marche pour le rajouter a mon gestionnaire de texture, merci pour cette info

Si non, pour ce que ça intéresse voici mon gestionnaire de texture ça peu toujours servire bien qu’il ne soit pas très évolué :^/

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
class Ctexture
{
    unsigned texture;
 
    public :
        void cree(char * image);
        void select(void);
 
        void Ctexture(char * image)
        {
            ILuint id;
            GLuint g_textureID;
            int format;
 
            ilInit();
            ilGenImages(1, &id);
            ilBindImage(id);
            ilLoadImage(image);
 
            glGenTextures(1, &texture);
            glBindTexture(GL_TEXTURE_2D, texture);
            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
            glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);  
 
            glTexImage2D(GL_TEXTURE_2D, 0, ilGetInteger(IL_IMAGE_BPP), ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, ilGetInteger(IL_IMAGE_FORMAT), GL_UNSIGNED_BYTE, ilGetData());
 
            if(ilGetInteger(IL_IMAGE_BPP) == 4)
                alpha = 1;
            else
                alpha = 0;
 
            ilBindImage(0);
            ilDeleteImages(1, &id);
            ilShutDown();
        }
 
        void Ctexture(void)
        {
            glEnable(GL_TEXTURE_2D);
            glBindTexture (GL_TEXTURE_2D, texture);
            if(alpha == 1)
            {
                glEnable(GL_BLEND);   
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
            }else
            {
                glDisable(GL_BLEND); 
            }
        }
};
//pour importer une image : 
//Ctexture nomtexture;
//nomtexture.cree("nom_du_fichier");
//
//pour utiliser la texture :
//nomtexture.select();

de cette manier, si on importe une texture contenant une composante Alpha comme les .png par exemple, l’alpha-blending s’active, si non la texture s’affiche sans alpha-blending.

Si vous avez des remarques sur cette exporter n’hésité surtout pas à les dire

Merci à tous pour votre aide !