[GLSL] Parallax mapping

Version imprimable

Hello.

J'essaye de faire du parallax mapping mais ça ne semble fonctionner que quand la caméra est dans certaine position ! pourquoi ?

Si je définit ma caméra comme ceci :
gluLookAt(eye.x, eye.y, eye.z, dir.x, dir.y, dir.z, top.x, top.y, top.z);
est-ce que le vecteur de vue que je doit envoyer à mon fragment shader est-il égal à normalize(dir-eye) ?

Voici le code du vertex shader:
Code:

1 2 3 4 5 void main() { gl_TexCoord[0] = gl_MultiTexCoord0; gl_Position = ftransform(); }
Et le code du fragment shader :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 uniform sampler2D diffuseTexture; //diffuse texture uniform sampler2D heightMap; //height map uniform vec3 viewVector; //dir-eye void main() { float height = texture2D(heightMap, gl_TexCoord[0].st).r; float displacement = (height * 0.04) - 0.02; vec2 newTexCoord = vec2((normalize(viewVector) * displacement)) + gl_TexCoord[0].st; gl_FragColor = texture2D(diffuseTexture, newTexCoord); }
Edit : Est-ce que le "parallax mapping" et le "parallax occlusion mapping" sont la même chose ?

merci

19/09/2007, 08h55
smashy

ton code ne ressemble pas du tout a un code de parallax mapping. :cry:

L'idee du parallax mapping, c'est de lancer un rayon pour chaque pixel d une surface a partir de l oeil. Il s'agit alors, pour le triangle concerne de trouver un decalage des coordonnees de texture due a fait que le triangle n'est pas plat mais bossele (texture d elevation) et le rayon peut donc etre intercepte.

Il s agit donc de faire plusieurs lecture de la texture d elevation pour trouver a quel moment le rayon est intercepte (deja tu n en fait qu une seule)

Ensuite, pour travailler correctement, il faut commencer par trouver ton rayon :

ce rayon est finalement le vecteur qui par du centre de l oeil vers le sommet du triangle (tu le calcul au niveau du vertex shader , et tu peux le retrouver dans ton fragment par interpolation -> il s agit donc d'un varying et pas d un uniforme). Ce que tu utilises c 'est la direction global de ta camera qui est finalement le rayon qui part de l oeil droit devant ... ce rayon est constant sur toute la scene !!!)

note : il faut veiller a exprimer ce rayon dans le repere local a la surface . on utilise pour cela le tangeant space (mots cles tangeant , normal et binormal)

Si tu veux de bon exemples, tu dois pouvoir en trouver sur les SDK nvidia ou ATI.

Si tu as RenderMonkey (chez ati) , je peux te transmettre un exemple que j aui fait.

Quant au parallax occlusion mapping, il s agit de trouver les ombres qu'une surface bosselee produits sur elle meme (meme probleme d intersection avec un rayon qui par d un point de la surface vers la source lumineuse)

Merci bien,

C'est vrai que j'ai en peu merdé pour mon vecteur mais maintenant je pense qu'il est bon :

Vertex shader :
Code:

1 2 3 4 5 6 7 8 9 varying vec3 viewVector; uniform vec3 eye; //position de l'oeil void main() { viewVector = normalize(ftransform().xyz - eye); gl_TexCoord[0] = gl_MultiTexCoord0; gl_Position = ftransform(); }
Par contre pour le reste, c'est encore assez flou dans ma tête, pourrais-tu m'envoyer l'exemple que tu as fait ? petitg1987 [a] gmail.com, merci.

Gloups, j'ai oublié l'espace local dans tout ça. J'ai aussi trouvé un fragment shader sur le net et re-voici mon nouveau code:

vertex shader:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
varying vec3 viewVector;
uniform vec3 eye;
attribute vec3 tangent;
 
void main()
{
	//local space
	vec3 n = normalize(gl_NormalMatrix * gl_Normal);
	vec3 t = normalize(gl_NormalMatrix * tangent);
	vec3 b = cross(n, t);
 
	vec3 tmpViewVector = normalize(ftransform().xyz - eye);
 
	viewVector.x = dot(tmpViewVector, t);
	viewVector.y = dot(tmpViewVector, b);
	viewVector.z = dot(tmpViewVector, n);
 
	gl_TexCoord[0] = gl_MultiTexCoord0;
	gl_Position = ftransform();
}

fragment program:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
varying vec3 viewVector;
uniform sampler2D diffuseTexture;	//diffuse texture
uniform sampler2D heightMap;		//height map
 
void main()
{	
	float fDepth = texture2D(heightMap, gl_TexCoord[0].st).r;
	vec2 vHalfOffset = normalize(viewVector).xy * (fDepth) * 0.05;
 
	fDepth = (fDepth + texture2D(heightMap, gl_TexCoord[0].st + vHalfOffset).r) * 0.5;
	vHalfOffset = normalize(viewVector).xy * (fDepth) * 0.05;
 
	fDepth = (fDepth + texture2D(heightMap, gl_TexCoord[0].st + vHalfOffset).r) * 0.5;
	vHalfOffset = normalize(viewVector).xy * (fDepth) * 0.05;	
 
	gl_FragColor = texture2D(diffuseTexture, gl_TexCoord[0].st + vHalfOffset);
}

Biensur, le résultat n'est pas correcte :(