使用法线贴图的OpenGL hieghtmap渲染

Question

I'm trying to render heightmap with normal map, using OpenGL and GLSL. What I have so far: quadtree grid with height being updated in vertex shader based on heightmap. Generated normal texture Example od simillar one: http://www.leadwerks.com/wiki/images/0/08/Terr16.JPG

Terrain don't have tangents or vertex normals. I can't get my light system working without those attributes. I'm guessing that I have to use TBN matrix to produce vectors correctly. But how to do it without vertex normal or tangent? Is there any simpler way than complicated reproducing of everything? Is it really leak of normal transformation? Or my whole way of light calculation is wrong? Code fragments:

VS:

vec4 pos=vertex_position;//grid position (only x,z)
pos.y=((texture(heightmap_tex,uv_coords).x)*scale_height);
pos.w=1.0;//to be safe
vec4 P=viewMatrix*pos;
vec3 L=mat3(MVmatrix)*vec3(worldLightPos)-P.xyz;
Out.lightDir=L;
vec3 V=-P.xyz;
Out.eyeDir=V;
Out.texCOORD=uv_coords;
gl_Position = MVPmatrix * pos;

FS:

vec3 V=normalize(In.eyeDir);
vec3 L=normalize(In.lightDir);
vec2 norm_texture=texture(texturenormal,In.TexCoord).xy*2.0-vec2(1.0);
vec3 N=normalize(vec3(norm_texture,sqrt(1.0-dot(norm_texture.xy, norm_texture.xy))*2.0-vec3(1.0)));//unpacking from 2 channel
vec3 R=reflect(-L,N);//phong
vec3 specular=pow(max(dot(R,V),0.0),shininess)*specularColor;//phong
vec3 diffuse=max(dot(N,L),0.1)*vec3(texColor);//phong

Right now terrain is getting brighter/darker based on camera left/right rotation. So it's far from correct.

Answer 1

I've done this by sampling the height map on the neighboring vertices and calculating the normals with the result. So for vertex (x,y), I sample the height map at that point. Then I also sample it at (x+1,y) and (x, y+1) and take the cross product of the resulting vectors. So my vertex shader looks something like this:

vec3 calculateNormal (float y0, float y1, float y2)
{
    vec3    p1  = gl_Vertex.xyz;
    vec3    p2  = gl_Vertex.xyz;
    vec3    p3  = gl_Vertex.xyz;
    p2.x += vertexDelta.x;
    p3.z += vertexDelta.y;

    p1.y = y0;
    p2.y = y1;
    p3.y = y2;

    return normalize(gl_NormalMatrix * cross(p3 - p1, p2 - p1));
}

void main ()
{
    vec4    heightSample  = texture2DRect(heightMap, gl_MultiTexCoord3.xy);
    vec4    heightSampleX = texture2DRect(heightMap, gl_MultiTexCoord4.xy);
    vec4    heightSampleY = texture2DRect(heightMap, gl_MultiTexCoord5.xy);
    ...
    normal = calculateNormal (heightSample, heightSampleX, heightSampleY);
}

This assumes that the vertices are uniformly spaced in the x and y directions by vertexDelta.xy . It also assumes you've set up the texture coordinates of texture units 3, 4, and 5. Texture unit 3 contains the actual texture coordinates of the height map. Texture unit 4 is the same thing but moved over by the distance between the vertices in the x direction. Texture unit 5 is the same as texture unit 3, but with the coordinates moved by the y distance between vertices. (You could calculate the distance in the vertex shader, but it becomes a dependent look-up which is slower.)