J´ai une image au format PNG, dans cette image certains pixels sont transparents : comment faire pour que les pixels transparents soient transparents quand je les rends avec OpenGL.

Pour charger la texture, j´applique la méthode du site de JYY et ensuite je l´affiche sur un quad comme sur le site de JYY.

J´ai déjà utilisé plusieurs méthodes pour la transparence mais je n´ai pas trouvé la bonne et en plus, je ne suis pas un pro de la transparence sous OpenGL.

On va peut être me dire de rechercher mais si quelqu´un sait comment faire, je le remercie de dire comment.

Je pense que le problème vient des arguments à passer dans glBlendFunc();

va voir les tutoriaux de nehe :

http://nehe.gamedev.net

le tutorial 7 ou 8 parle de blending, et puis nehe c´est un must en openGL, si veux apprendre, et si l´anglais ne t´effrais pas.

Vérifie aussi le truc suivant :
si tu t´appuies sur les valeurs alpha des pixels, vérifie que la fonction qui charge ton PNG prend en charge la lecture du canal alpha.

Sinon, en effet, le tuto de Nehe est fabuleux

En fait, je charge une image avec SDL sur 24 bits (si je fais sur 32, ça plante sans que je sache pourquoi) et ensuite, à l´aide d´une fonction je transforme tout les pixels violets en pixels transparents puis j´envoie la texture à OpenGL (je travaille en RAM tout le long).

Le principal problème est que si j´utilise glEnable(GL_BLEND) avec glBlendFunc(GL_SRC_ALPHA, GL_ONE) et bien les pixels transparents ne sont plus visibles mais tout le reste de l´image est rendu transparent au 2/3 (environ). Etrangement, tout ce que j´ai essayé avec les fonctions d´Alpha Test n´a pas réussi à faire disparaître les pixels transparents.

En fait, je programme une sorte de librairie 2D/3D basée sur SDL et OpenGL et qui aurait pour but de permettre de programmer sous OpenGL de la même façon qu´avec SDL pour créer des jeux en 2D mais tout en profitant des accélérations 3D, du système de caméra pour le scrolling, des zooms, etc.

Je viens de trouver mon problème :
Quand je charge une texture avec OpenGL, je le fais comme sur le site de JYY et du coup, je dit à OpenGL que je travaille sur 3 couleurs. Comment faire pour le faire travailler sur les quatres couleurs R, G, B et A ?

Comment fait-on avec OpenGL pour charger une texture en gérant le canal alpha ?

Salut
dans le programme que je fais, je n´utilise pas encore la composante alfa, mais au chargement des .BMP (je n´utilise que ça pour l´instant), j´ai ca :

for (i=0; i < infoheader.biWidth*infoheader.biHeight; i++)
{
// We load an RGB value from the file
fread(&rgb, sizeof(rgb), 1, l_file);

// And store it
l_texture[j+0] = rgb.rgbtRed; // Red component
l_texture[j+1] = rgb.rgbtGreen; // Green component
l_texture[j+2] = rgb.rgbtBlue; // Blue component
l_texture[j+3] = 255; // Alpha value
j += 4; // Go to the next position
}

sachant que ´l_texture´ est la donnée des infos de l´image. (tu vois : vu que je n´utilise pas encore le canal alfa, je mets 255...)
Ensuite, on lie la texture à ogl avec ca (apres quelques autres manip):

glTexImage2D(
GL_TEXTURE_2D, //target
0, //mipmap level
4, //nb couleurs
infoheader.biWidth, //largeur
infoheader.biHeight, //hauteur
0, //largeur du bord
GL_RGBA, //type des couleurs
GL_UNSIGNED_BYTE, //codage de chaque composante
l_texture //Image
);

Oui, c´est comme ça que lie ma texture à opengl mais en utilisant SDL. Mais quand je fais ça, j´obtiens un écran tout noir

Dans mon programme, au lieu de mettre l_texture en dernier paramètre de ma fonction, je met :

surface->pixels

Est-ce que le problème pourrait venir de là ?

• en dernier paramètre de la fonction glTexImage2D()

unsigned char *l_texture;

chez moi, donc si c´est lebon type... ensuite, reste a vérifier les tailles de l´image, voir si t´as les bonnes et si tu les mets bien en paramètre de glTexImage2D()

Arf, moi le type c´est SDL_Surface
Je charge mes images avec SDL. Peut-être que le problème vient de là, peut-être que SDL est incapable de charger une image contenant un canal alpha ?

Est-ce que SDL peut charger des images avec un canal alpha ?

Aldebran > ça n´a rien a voir avec les capacités de SDL : SDL_LoadBMP ne charge pas des images en utilisant le canal Alpha pour la raison simple :

Les BMP ne gerent pas d´alpha

Sinon, rien ne t´empeche de charger l´image, de la copier en 32 bits, du locker l´image, et de modifier le canal Alpha des pixels désirés, puis ensuite de la monter en tant que texture OpenGL.
J´ai des fonctions qui permettent de faire ça...