Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

[Shaders] Effet brouillard


Sujet :

OpenGL

  1. #1
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    228
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 228
    Points : 86
    Points
    86
    Par défaut [Shaders] Effet brouillard
    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 :

    Nom : Fog2.jpg
Affichages : 90
Taille : 28,3 Ko

    Voici ce que je suis censé obtenir :

    Nom : Fog1.jpg
Affichages : 88
Taille : 34,6 Ko

    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é :

    Nom : Fog3.jpg
Affichages : 89
Taille : 21,8 Ko

    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.

  2. #2
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    24 509
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 24 509
    Points : 180 489
    Points
    180 489
    Billets dans le blog
    50
    Par défaut
    Bonjour,

    Pour moi, la valeur z varie entre 0 et 1. Ce sont les coordonnées X et Y qui sont entre -1 et 1.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    juin 2005
    Messages
    1 934
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 37
    Localisation : France, Somme (Picardie)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2005
    Messages : 1 934
    Points : 10 153
    Points
    10 153
    Billets dans le blog
    4
    Par défaut
    De mon côté j'applique le brouillard en view space, plutôt qu'en clip space

    EDIT:
    Je m'étais basé sur ce lien : http://in2gpu.com/2014/07/22/create-fog-shader/
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  4. #4
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    228
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 228
    Points : 86
    Points
    86
    Par défaut
    Merci pour vos réponses, j'ai finalement résolu le problème en effectuant l'inversion un peu plus loin dans le code.

+ Répondre à la discussion
Cette discussion est résolue.

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo