Discussion :

[KevinduC]

Bonsoir, je suis entrain d'essayer de recoder le brouillard OpenGL avec les shaders, j'ignore si mon raisonnement est bon mais j'ai eu l'idée d'utiliser le paramètre z de la variable "gl_FragCoord" qui est comprise entre -1 et 1 d'après ce que j'ai cru comprendre en me renseignant sur Google (Dites-moi si je me trompe). Voici le code de mon fragment shader :

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
uniform sampler2D tex;
uniform bool isTextured;
 
uniform bool enableFog=false;
 
uniform float fogStart;
uniform float fogEnd;
uniform vec3 fogColor;
 
uniform float near;
uniform float far;
 
void main(void)
{
    float visibility;
	const float depth=((near-far)/2)*gl_FragCoord.z+(near+far)/2;		//Calcul profondeur pixel
 
	if(!isTextured)
		gl_FragColor=gl_Color;
	else
		gl_FragColor=texture2D(tex,gl_TexCoord[0].st)*gl_Color;
 
	if(enableFog)
	{
		visibility=(fogEnd-depth)/(fogEnd-fogStart);		//Calcul visibilité selon profondeur (Linéaire)
		visibility=clamp(visibility,0,1);
 
		gl_FragColor[0]=(gl_FragColor[0]-fogColor[0])*visibility+fogColor[0];
		gl_FragColor[1]=(gl_FragColor[1]-fogColor[1])*visibility+fogColor[1];
		gl_FragColor[2]=(gl_FragColor[2]-fogColor[2])*visibility+fogColor[2];
		//Couleur finale du pixel (visibility=0 => Couleur brouillard, visibility=1 => Couleur normale)
	}
}

Voici ce que j'obtiens alors :



Voici ce que je suis censé obtenir :



Vous remarquerez que j'ai obtenu l'inverse du résultat recherché, rien de plus simple me direz-vous : Il suffit d'inverser la pente de ma courbe en faisant :

Code :

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

const float depth=((far-near)/2)*gl_FragCoord.z+(near+far)/2;

Mais malheureusement, je n'obtiens pas le résultat recherché :



Voici mon code côté appli :

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
void WTR_BeginFog(const float start,const float end,const float near,const float far,const GLuint programID)
{
    float couleur[4];
    GLint activeFog_Shader,debutFog_Shader,finFog_Shader,couleurFog_Shader,near_Shader,far_Shader;
 
    //...Détermination couleur
 
    if(programID==0)
    {
        //
    }
 
    else
    {
        activeFog_Shader=glGetUniformLocation(programID,"enableFog");
        debutFog_Shader=glGetUniformLocation(programID,"fogStart");
        finFog_Shader=glGetUniformLocation(programID,"fogEnd");
        couleurFog_Shader=glGetUniformLocation(programID,"fogColor");
        near_Shader=glGetUniformLocation(programID,"near");
        far_Shader=glGetUniformLocation(programID,"far");
 
        glUniform1i(activeFog_Shader,true);
        glUniform1f(debutFog_Shader,start);
        glUniform1f(finFog_Shader,end);
        glUniform3f(couleurFog_Shader,couleur[0],couleur[1],couleur[2]);
        glUniform1f(near_Shader,near);
        glUniform1f(far_Shader,far);
    }
}

Je ne comprends pourquoi le simple fait d'inverser le courbe ne résout pas le problème, j'ai essayé plusieurs solutions durant des heures mais sans succès. Je raisonne en considérant que gl_FragCoord.z vaut -1 lorsque la profondeur est égale à near et 1 lorsqu'elle est égale à far, peut-être que je me trompe mais si c'est le cas je n'aurais même pas dû obtenir le résultat inversé.

Bref toute aide sera la bienvenue, merci par avance.