Discussion :

[djfab]

Bonjour à tous,

Je voudrais savoir quelle est la méthode pour faire une vitre en fait, est-ce qu'on doit obligatoirement mettre une texture en png qui soit transparente ? Ou est-ce qu'il y a une autre technique, je voudrais juste activer une transparence et pouvoir dire le taux de transparence, mais j'ai pas trouvé comment faire.

[Bob.Killer]

il faut te servir de la composante alpha du matériel ou de la couleur

tu peut activer le blending (mélange des couleurs) avec :

Code :

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

glEnable(GL_BLEND); // je crois...

[bigquick]

Salut,

et tu peux (ou dois? je ne sais plus ...) alors préciser la fonction utilisée pour gérer la transparence. Voici celle qu'on utilise généralement, et qui fonctionne bien si tes primitives (triangles, quads, polygones, ...) sont triées back-to-front, c'est à dire d'abord celles qui sont loin, puis celles qui sont plus près:

Code :

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

1
2
3
4
5
6
7
glEnable(GL_BLEND);  // activer la transparence
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);   // gérer la transparence en fonction de la composante alpha de la source
glColor3f(1,1,1,0.5);   //   à moitié transparent
 
// ... dessine ta vitre
 
glDisable(GL_BLEND);  // desactiver la transparence

Avec cette fonction, la transparence sera fonction de la composante alpha de la couleur (0=transparent, 1=opaque).

Dans ton exemple, il faudra donc dessiner d'abord ce qui se trouve derrière la vitre, puis la vitre. C'est comme ça, on ne peut rien y faire, à part quelques techniques obscures (recherche depth peeling sur google si tu veux), on doit focement trier ses objets pour obtenir une belle transparence sans bugs


Regarde ces liens pour plus de détails si tu veux:
http://www.mevis.de/~uwe/opengl/glBlendFunc.html
http://www.opengl.org/resources/faq/...ansparency.htm

Voilà

bigquick

[djfab]

Merci beaucoup !!! Ca marche du tonnerre

[Ruffi]

Salut

Voila, j'ai un aussi un probleme de transparence alors je vais recycler ce topic plutot qu'en creer un nouveau (en esperant que le resolu ne vous empechera pas de me repondre)


Je fait actuelement un petit moteur de particule, et j'aimera que mes particules deviennent de plus en plus transparentes jusqu'a disparaitre.
Pour cela, je contait utiliser le blending.
Mais etant donné que mes particules sont texturé (mais je n'utilise pas de composante alpha directement de la texture), j'ai l'impression qu'il ne tient pas attention de l'alpha dans le glColor4f

J'ai regardé la façon dont celui-ci est fait sur NeHe :
glColor4f(1.0f,1.0f,1.0f,0.5f);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
mais là, quelque soit la valeur que je donne en alpha, la particule est a demi transparente.

J'ai essayé en mettant la valeur alpha dans le material ambiant, mais ça ne veux pas marcher non plus.

[bigquick]

Salut,

Juste une question au passage:
Pourquoi glBlendFunc(GL_SRC_ALPHA,GL_ONE); ? J'ai essayé de me pencher sur les équations utilisées, et ça donne ça (en vrac ):

Pour la composante rouge (c'est pareil pour les autres)

Code :

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

1
2
 
final red = min( max_red , source_red * source_scale_red   +   dest_red * dest_scale_red )

Or, avec GL_ONE comme destination, ça donne (dest_scale = 1)

Code :

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

final red = min( max_red ,  source_red * source_alpha / max_alpha   +   dest_red )

ce qui fait que tu auras toujours un peu de la couleur de destination dans ta couleur finale, contrairement à GL_ONE_MINUS_SRC_ALPHA, qui fera que plus ta source est transparente, moins on verra ta destination:

Code :

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

final red = min( max_red ,  source_red * source_alpha / max_alpha   +   dest_red * ( 1 - source_alpha / max_alpha ) )

Non ?
Enfin remarque si ça vient de Nehe, il doit y avoir une raison

[Ruffi]

voici le lien vers la leçon de nehe:

http://nehe.gamedev.net/data/lessons....asp?lesson=08

mais c'est vrai que je ne pense pas que GL_ONE soit une bonne solution.

J'avais lu sur un site une explication, qui expliquait de façon assez clair la façon dont marchait glBlendFunc : http://iquebec.ifrance.com/eraquila/...opengl/gl6.htm

mais malgré ça, je comprend pas pourquoi j'arive pas a choisir le coeficient de blending.
Si ma texture en tga aurai un champ alpha, est-ce qu'il le prendrai par defaut ? (ce qui ne m'interesse pas car je veux modifier cette valeur de blending)

[Ruffi]

Arf, j'ai essayé avec une texture contenant des info de transparance, et il les utilise.

Est-ce possible d'ajouter une autre valeur de transparence (blending avec les info de la texture + par un paramettre d'alpha qui sera calculé celon "l'age" de la particule).

[bigquick]

Je ne sais pas si tu peux cumuler les deux, mais dans ton cas si j'ai bien compris tu ne veux pas te servir de celle de la texture, c'est ça ?

Parceque je crois que lors du chargement de la texture, tu peux lui préciser qu'il ne doit pas tenir compte de la composante alpha... j'ai pas la doc sous la main mais il me semble que c'est possible...

... peut être en précisant à glTexImage2D que tu as 4 composantes, mais que c'est du GL_RGB (pour qu'il force l'alpha à 1) ?

(bon c'est un post en live, mais on sait jamais, et ça fait toujours une piste )

[Ti-R]

Pour choisir ton coefficient de "blending" utilise

Code :

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

glColor4f(1.,1.,1.,coef_blending);

A placer juste devant ton objet qui possède la texture transparente.

[bigquick]

glColor4f(1.0f,1.0f,1.0f,0.5f);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
mais là, quelque soit la valeur que je donne en alpha, la particule est a demi transparente.

le problème est que ça ne marche pas, car visiblement, la texture utilisée pour texturer l'objet est un TGA avec couche alpha; c'est donc cette couche alpha qui est utilisée à la place du 4ème paramètre de glColor4f.

Mais Ruffi, tu ne nous a pas dit, avec glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) ça te donne quoi ? Toujours rien ?

[Ruffi]

Oups, desolé de pas avoir repondu plus tot

Finalement, j'utilise glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA), vu que finalment j'utilise la composante alpha de mes particules pour que le rendu des "flames" soit plus simpatique. Cela donne donc une transparance identique pour toutes les particules (alors que j'aimerai pouvoir les faire "disparaitre" petit à petit)

Je n'arive donc pas à lui modifier sa valeur d'alpha blending.
Une solution serai de passer ça via un pixel shader en Cg (ça tombe bien, je voulais m'y mettre), mais il existe surement une solution moins extreme.

Le projet utilisant ce moteur de particule étant a rendre d'ici une semaine, et vu que ce n'est pas une des choses demandé dans le sujet, je pense que je me limiterai à ça dans un premier temps. Je reviendrai dessus plus tard

Mercià tous de m'avoir aidé

[Ti-R]

Pour choisir ton coefficient de "blending" utilise

Code :

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

glColor4f(1.,1.,1.,coef_blending);

A placer juste devant ton objet qui possède la texture transparente.

Relit mon post Ruffi !
Si tu animes la valeur coef_blending de 1 à 0, tu auras ton effet de particule qui disparaît

[bafman]

si la texture est mise en GL_MODULATE, alors l'alpha passé par glColor4* module l'alpha de la texture d'origine, par contre si elle est mise en GL_REPLACE, alors elle la remplace... pas trop compliqué...
sinon pour ton equation de blending, tu a fait (a mon avis) une erreure...
quand tu te met en GL_SRC_ALPHA, GL_ONE, cela signifie que la particule est ajoutée au resultat final en fonction de son alpha (le GL_ONE permet de dire qu'on garde l'image d'origine).On parle de blending additif . ce procédé est tres pratique pour crée des effets de saturation de couleur , par exemple pour du feu, si tu donne une couleure RGB (1,0.1,0.1), les particules vont s'ajouter et ainsi, au centre ou tu a plus de particules, la couleur tendra vers le blanc alors qu'au bors ca tendra vers le rouge. c'est nettement plus proche de la realitée... et surtout, le gros aventage de cette methode est de ne pas avoir a prendre en compte l'ordre d'affichage des particules (0.5 + 0.3 = 0.3 + 0.5 donc pas de probleme)

par contre avec GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA, tu n'utilise plus du blending additif, et donc l'ordre entre en compte, il te faut donc trier tes particules en fonction de l'effet desiré (de la plus proche a la plus eloignée ou l'inverse). Les particules etant dynamiques, il faut donc recalculer la distance a la camera a chaque frame et re trier toutes les particules, ce qui demande enormement de calcule, sinon, tu aura des artefactes d'affichage, et surtout, le resultat ne corresplondra pas à la réalitée que tu voulait modeliser...
Neanmoins, le trie de particules peut permettre de retirer des propriétées sur ces particules qui te permettent d'accelerer un peut leur rendu, mais ce sera toujours plus lent qu'avec du blending additif...

[Ruffi]

Ti-R, merci de ton code mais j'avais essayé et ça marchait pas.

le problème est que ça ne marche pas, car visiblement, la texture utilisée pour texturer l'objet est un TGA avec couche alpha; c'est donc cette couche alpha qui est utilisée à la place du 4ème paramètre de glColor4f.

Sinon, j'utilisais GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA en enlevant l'ecriture sur le zbuffer (avec glDepthMask()), ce qui rendait bien. mais la technique que tu me popose avec GL_SRC_ALPHA, GL_ONE donne un rendu tres simpatque, que j'ai finalement adopté