So I'm working on implementing parallax mapping but have run into a little bit of a problem. The parallax mapping works in some places but looks inverted in other places. My first thought was that my TBN matrix was screwed up seeing as I was generating it on the gpu, so I switched to precomputed tangents but I still have the problem. Normal mapping works great so I decided it wasn't the TBN matrix. So heres my code anyone know whats wrong? attached is a picture illustrating the problem.

Vertex shader:


varying vec3 v;
varying vec4 VaryingTexCoord0;
varying vec3 vnormal;
varying mat3 TBN;
attribute vec3 tangent;
void main(void)
{
vnormal = normalize(gl_NormalMatrix * gl_Normal);
vec3 ntangent = normalize(gl_NormalMatrix * tangent);

vec3 bitangent = cross(vnormal, ntangent); //get the bitangent perpendicular to the normal and tangent

TBN = mat3(ntangent, bitangent, vnormal); //construct the TBN matrix

v = vec3(gl_ModelViewMatrix * gl_Vertex);
VaryingTexCoord0 = gl_MultiTexCoord0;
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}


Important part of the fragment shader:


vec3 finalnormal;
vec3 eyevec = normalize(-v);

vec2 transformedTexcoord;

vec4 ntexcolor;
if(bump_on > 0)
{
vec3 view = normalize(eyevec * TBN);

float height = (texture2D(height_texture, vec2(VaryingTexCoord0)).r * 0.04) - 0.03; //grab height from a heightmap

transformedTexcoord = (height * view.xy) + vec2(VaryingTexCoord0); //transform the texcoord based on the height

ntexcolor = texture2D(normal_texture, transformedTexcoord); //sample the normal map with the transformed texcoord

vec3 normal = normalize(ntexcolor.rgb * 2.0 - vec3(1.0)); //turn that sample into a normal vector

finalnormal = normalize(TBN * normal); //multiply that by the tbn matrix to get the final normal
}


Is it always safe to generate the bitangent from the normal and the tangent? I can imagine that with some funky UV mapping it'd be possible for your bitangent to be incorrect. I seem to remember that to be safe when generating an NBT you're best off with a tangent, a bitangent and a sign bit/scalar with which to generate the normal in the correct direction.

That said, I'd be surprised if that particular floor mesh did have the sort of odd UV mapping that would have caused this, so perhaps the problem lies elsewhere.

The Image loader I use (SDL_Image) loads images upside down so I flip the uv-coords to compensate, might that have something to do with it? also as a more accurate description of the problem, the effect is correct on the right side of the player but wrong on the left side and this will anomaly will remain even as the player moves around always on their left.

you're best off with a tangent, a bitangent and a sign bit/scalar with which to generate the normal in the correct direction.

Wow I added the sign bit and it works but for some reason I need to invert the sign bit.