[GLSL] récupérer une variable à la fin de l'exécution

Bonjour,

J'essaie de faire un fragment shader pour calculer la moyenne des niveaux de gris de mon image (image de type niveau de gris bien sur ^^)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

//Fragment Shader   uniform sampler2D texture; varying float somme;   void main(void) { float nx, ny; nx = gl_TexCoord[0].x; ny = gl_TexCoord[0].y; somme += texture2D(texture,vec2(nx, ny)).r; // vu que l'on est en niveau de gris les 3 composantes ont la mm valeur   gl_FragColor = gl_Color; }

---

le problème est que je n'ai pas trouvé comment récupérer ma variable "somme" à la fin de l'exécution (et je me demande si c'est faisable. A ce que j'ai lu, varying sert à passer une variable d'un vertex shader à un fragment shader mais pas à ressortir une variable.

Merci d'avance de votre aide.

C'est impossible (corrigez moi si je me trompe), mais tout ce que tu pourras ressortir d'un pixel shader c'est la couleur de ce texel via gl_FragColor.

C'est malheureusement ce qui me semblait, c'est pour ca que je demandais pour voir si je n'avais pas raté une subtilité:oops:

C'est effectivement impossible de récupérer la valeur d'une variable dans un shader.

Mais on peut feinter pour la visualiser ... sous forme de couleur ! Au début c'est un peu dur à bien associer les variations de couleurs avec la valeur associer mais à la longue on y arrive bien et on trouve ça très artistique :P

Code:

---

gl_FragColor = vec4(vec3(somme / 100.), 1.);

---

Tu obtiendras visuellement en niveau de gris ta variation par fragment de ton niveau de gris.
Et comme les composantes rgba sont comprises entre 0. et 1. divise par une certaine valeur afin que la valeur soit <= 1. et ne pas voir que du blanc partout. J'ai divisé par 100. pour l'exemple, tatonne juste pour trouver la bonne valeur qui fasse ni trop blanc ni trop noir !

Oui, j'ai pensé a le dire, puis de récuperer ca via glReadPixel, mais c'est franchement pas tres adapté =]... si tu veux utiliser le GPU pour autre chose que des shaders, il faut utiliser cuda !

Ben mon but c'etait de faire calculer au GPU la moyenne des niveaux de gris de ma texture (ou du moins la somme, j'aurai fait la division en dehors pour avoir la moyenne)

En fait il faut utiliser ce que l'on appelle la technique de réduction pour avoir les meilleures performances (j'ai eu le cours ce matin :D). En gros tu calcules ta moyenne sur quatre pixels qui se touchent, ça te génère une image deux fois plus petite, tu refais ça jusqu'à arriver à une image de 1 et c'est la moyenne de ton image de base.

Le pipeline a générer est plutôt simple. Tout d'abord tu définis ton viewport en rendu projection orthogonale avec en résolution la taille de ta texture divisée par deux (peut-être -1 pour pas sortir de la texture...) et tu y dessines un quad qui remplie ton viewport (non texturé rien du tout... je crois). Ceci va avoir pour effet d'appeler ton fragment program une fois pour chaque pixel de ton viewport (tu auras ainsi les coordonnées (x,y)). De là tu fais le fragment shader suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

uniform sampler2D texture;   void main(void) { float x, y; x = gl_Position.x * 2; // On double pour arriver à la bonne position vu qu'on génère sur un viewport deux fois plus petit que la texture y = gl_Position.y * 2; moyenne = (texture2D(texture,vec2(x,y)) + texture2D(texture,vec2(x+1,y)) + texture2D(texture,vec2(x,y+1)) + texture2D(texture,vec2(x+1,y+1))) / 4;   gl_FragColor = moyenne; }

---

Et donc tu fais le rendu dans un FBO qui va l'envoyer dans une texture. Tu reprends cette texture, tu refais un viewport deux fois plus petite que cette nouvelle texture, tu recommences... Jusqu'à taille 1 et là t'as plus qu'à lire la valeur dans ton FBO. C'est très très rapide sachant que sur les architectures direct x 10 tu fais la moyenne de 4 pixels en un cycle cpu (de plus rien ne sert de faire le calcul que sur la composante r, c'est parallélisé donc ça se fait aussi en un cycle sur les composantes rgba).

Voiloù !