title: Normal Mapping and translation disrupts my lighting
body: <p>I got a normal mapping issue. I have a texture and a normal texture on each model loaded via the ASSIMP library. I am calculating the tangent vectors on each object with the help of the ASSIMP library so these should be fine. The objects work perfectly with normal mapping but as soon as I start translating one of the objects (thus influence the Model matrix with translations) the lighting fails. As you can see on the image, the floor (which is translated down the y axis) seems to lose most of its diffuse lighting and its specular lighting is in the wrong direction (it should be between the lightbulb and the player position)</p>
  
  <p><img src="https://i.stack.imgur.com/oY9N9.jpg" alt="Normal mapping gone wrong"></p>
  
  <p>It might have something to do with the normal matrix (although translations should be lost), maybe something with a wrong matrix used in the shaders. I am out of ideas and was hoping you could shed some insight into the issue.</p>
  
  <p>Vertex shader:</p>
  
  <pre><code>#version 330
  
  layout(location = 0) in vec3 position;
  layout(location = 1) in vec3 normal;
  layout(location = 2) in vec3 tangent;
  layout(location = 3) in vec3 color;
  layout(location = 4) in vec2 texCoord;
  
  // fragment pass through
  out vec3 Position;
  out vec3 Normal;
  out vec3 Tangent;
  out vec3 Color;
  out vec2 TexCoord;
  
  out vec3 TangentSurface2Light;
  out vec3 TangentSurface2View;
  
  uniform vec3 lightPos;
  uniform vec3 playerPos;
  
  // vertex transformation
  uniform mat4 model;
  uniform mat4 view;
  uniform mat4 projection;
  
  void main()
  {
      mat3 normalMatrix = mat3(transpose(inverse(model))); 
      Position = vec3(model * vec4(position, 1.0)); 
      Normal = normalMatrix * normal;
      Tangent = tangent;
      Color = color;
      TexCoord = texCoord;
  
      gl_Position = projection * view * model * vec4(position, 1.0);
  
      // Calculate tangent matrix and calculate fragment bump mapping coord space.
      vec3 light = lightPos;
      vec3 n = normalize(normalMatrix * normal);
      vec3 t = normalize(normalMatrix * tangent);
      vec3 b = cross(n, t);
      // create matrix for tangent (from vertex to tangent-space)
      mat3 mat = mat3(t.x, b.x ,n.x, t.y, b.y ,n.y, t.z, b.z ,n.z);
      vec3 vector = normalize(light - Position);
      TangentSurface2Light = mat * vector;
      vector = normalize(playerPos - Position);
      TangentSurface2View = mat * vector;
  }
  </code></pre>
  
  <p>Fragment Shader</p>
  
  <pre><code>    #version 330
  
  in vec3 Position;
  in vec3 Normal;
  in vec3 Tangent;
  in vec3 Color;
  in vec2 TexCoord;
  
  in vec3 TangentSurface2Light;
  in vec3 TangentSurface2View;
  
  out vec4 outColor;
  
  uniform vec3 lightPos;
  uniform vec3 playerPos;
  uniform mat4 view;
  uniform sampler2D texture0;
  uniform sampler2D texture_normal; // normal
  
  uniform float repeatFactor = 1;
  
  void main()
  {   
      vec4 texColor = texture(texture0, TexCoord * repeatFactor);
      vec4 matColor = vec4(Color, 1.0);
      vec3 light = vec3(vec4(lightPos, 1.0));
      float dist = length(light - Position);
      // float att = 1.0 / (1.0 + 0.01 * dist + 0.001 * dist * dist);
      float att = 1.0;
      // Ambient
      vec4 ambient = vec4(0.2);
      // Diffuse
      // vec3 surface2light = normalize(light - Position);
      vec3 surface2light = normalize(TangentSurface2Light);
      // vec3 norm = normalize(Normal); 
      vec3 norm = normalize(texture(texture_normal, TexCoord * repeatFactor).xyz * 2.0 - 1.0); 
      float contribution = max(dot(norm, surface2light), 0.0);
      vec4 diffuse = contribution * vec4(0.6);
      // Specular
      // vec3 surf2view = normalize(-Position); // Player is always at position 0
      vec3 surf2view = normalize(TangentSurface2View);
      vec3 reflection = reflect(-surface2light, norm); // reflection vector
      float specContribution = pow(max(dot(surf2view, reflection), 0.0), 32);
      vec4 specular = vec4(1.0) * specContribution;
  
      outColor = (ambient + (diffuse * att)+ (specular * pow(att, 3))) * texColor;
      // outColor = vec4(Color, 1.0) * texture(texture0, TexCoord);
  }
  </code></pre>
  
  <p><strong>EDIT</strong></p>
  
  <p>Edited the shader code to calculate everything in world space instead of pingponging between world and camera space (easier to understand and less error-prone).</p>