Discussion :

[Bart_lx]

Bonjour tout le monde,
alors voici mon problème,
Je souhaite afficher un batiment en 3d avec toutes les faces transparentes, pour l'instant je suis arriver à tout afficher sans problème en opaques, mais lorsque je passe en transparent, il s'avère que seul certains éléments soient transparents.

Exemple : sur une maison contenant 4 murs, les murs ouest et sud laisseront apparaitre en transparence l'interieur de la maison, alors que les murs nord et resteront opaques (je les affiche pourtant de la meme manière).

Un collegue m'a dit qu'il fallait que je trie l'ordre d'affichage de mes faces selon la distance entre la caméra et la face, cependant vu que mon objet contient un enorme nombre de faces j'ai peur que sa rame, donc je vous demande si il existe une fonction permettant de faire fonctionner le Z-Buffer avec la transparence...

Merci de m'avoir lu, en esperant avoir été clair .

[Laurent Gomila]

Pour qu'un objet soit visible derrière une surface non opaque, il faut forcément qu'il ait été affiché avant cette dernière (sinon le Z-test le virera du rendu). Donc non, pas d'alternative au tri de toutes les faces transparentes.

[bigquick]

Est-ce qu'il y a des cas ou le fait de desactiver l'écriture dans le Z-buffer peut suffire ?

On trouve souvent ce type de code sur le net:

Code :

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

1
2
3
4
glDepthMask(GL_TRUE);
// render opaque polygons
glDepthMask(GL_FALSE);
// render transparent polygons

Et ça semble marcher, sans avoir eu à trier les faces transparentes de la plus éloignée à la plus proche. Et en y reflechissant un peu, je ne vois pas pourquoi ça ne fonctionnerait pas

Est-ce que vous pouvez nous éclairer la dessus ?

[Laurent Gomila]

Ca fonctionne dans le cas de blending additif, càd que l'ordre d'affichage des faces transparentes importe peu. Pour le reste, càd les formules de blending dont l'ordre source / dest est important, ça ne fonctionnera pas.

[bigquick]

Ah OK, merci pour les précisions !
D'ailleurs je viens de voir dans la FAQ ():

Code :

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

SRC_ALPHA, INV_SRC_ALPHA : Attention néanmoins à l'utilisation de cette fonction ; pour qu'elle donne un resultat valide, il faut que les faces soient affichées de la plus lointaine à la plus proche, on parle de transparence dépendante de l'ordre d'affichage.

C'est donc dommage, glDepthMask ne suffira pas si on veut une gestion correcte de la transparence

[shenron666]

Et tu ne peux pas rassembler tes faces par blocs ?

[Bart_lx]

Bon je suis en train de classer mes faces par ordre du coup.
Pour l'instant je vais travailler avec chaque faces puis apres jessairai de voir objet par objet...

Merci de vos réponses

[bafman]

attention aussi à ne pas avoir de face qui se coupent quand tu les rangent par distance...

[Bart_lx]

Voila le classement des faces est fini.

Je classe mon vecteur contenant toute les faces par distance entre la position de la caméra et le barycentre de la face, j'utilise pour cela une methode de tri par dycotomie.
Je recalcule l'ordre des faces à chaque déplacement de caméra selon les x,y ou z.

Cependant comme je le pensais, ça rame enormément, ça devient meme carrément pas présentable au moindre déplacement de caméra.

Auriez vous une méthode permettant de gerer ce problème sans que les performances soit réduites à néant ?

[Laurent Gomila]

Utilise std::sort (C++) ou qsort (C) pour le tri, tu auras déjà un algo optimal et une implémentation sûre. Si ça rame toujours il faudra penser à d'autres optimisations, genre partitionner ton espace pour ne pas traiter tous les polygones.

[bigquick]

Tu pourrais peut-être utiliser le sort() de la STL qui est surement plus rapide que ton tri par dichotomie [no offense ]

Pour l'appeler, il faudra surement que tu fasse un foncteur du genre:

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
struct TriDistanceCamera
{
       TriDistanceCamera( Camera& c )  :   m_Cam(c)   {}
 
       operator bool( const Face& f1, const Face& f2 )
       {
            Vector3D d1 = f1.getBarycentre().getDistanceCarree( m_Cam.getPos() );
            Vector3D d2 = f2.getBarycentre().getDistanceCarree( m_Cam.getPos() );
 
            return  (d1<d2);
       }
 
       Camera&  m_Cam;
};
 
 
{
      //   vector<Face>  m_aFaces;
 
      TriDistanceCamera  tri(maCamera);
      std:sort( m_aFaces.begin(), m_aFaces.end(), tri ) 
}

Ou quelquechose du genre
Pour optimiser encore, il faudrait avant de trier supprimer de ce vecteur les faces qui ne sont pas dans le frustum, ou, mieux encore, ne jamais les avoir ajoutées... Par exemple comme le dit Loulou24 avec un bon partitionnage de l'espace.


(edit: bien sur, si tu es en C++, mais j'imagine que c'est le cas si tu parles de vecteur de faces ...)

[Bart_lx]

J'avais omis ce detail pour eviter de vous effrayer mais je suis en fait en JOGL ( java opengl ) donc pas de fonction C ou C++.
Je recherche donc une fonction de tri en java...

Pour le partitionnement de l'espace, c'est une bonne idée mais cela risque de rendre mon travail bien plus poussé... cependant si sa rame encore avec la fonction optimale de tri je m'y pencherai dessus.

Merci de ton aide

[bigquick]

Ah oui, il y a aussi des vecteurs en Java c'est vrai
Mais je suis sur que les containeurs de Java possèdent aussi des méthodes de tri optimisées.