GLSL Shader Producing Unwanted Results - opengl

Question

I cannot get the following shader to work.
Vertex Shader
#version 430
in vec4 vPosition;
in vec4 vColor;
in vec2 vTexCoord;
in vec3 vNormal;
in vec3 vTangent;
in vec3 vBitangent;
//out vec4 color;
out vec2 texCoord;
uniform mat4 Model;
uniform mat4 View;
uniform mat4 Projection;
out vec3 LightDirection_cameraspace;
out vec3 Position_worldspace;
uniform vec3 LightPosition;
out vec3 EyeDirection_cameraspace;
out vec3 LightDirection_tangentspace;
out vec3 EyeDirection_tangentspace;
void main()
{
gl_Position = Projection * View * Model * vPosition;
Position_worldspace = (Model * vPosition).xyz;
vec3 vertexPosition_cameraspace = (View * Model * vPosition).xyz;
EyeDirection_cameraspace = vec3(0, 0, 0) - vertexPosition_cameraspace;
vec3 LightPosition_cameraspace = (View * vec4(LightPosition, 1)).xyz;
LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;
texCoord = vTexCoord;
mat4 ModelView = View * Model;
mat3 MV3x3 = mat3(ModelView);
vec3 vertexTangent_cameraspace = MV3x3 * vTangent;
vec3 vertexBitangent_cameraspace = MV3x3 * vBitangent;
vec3 vertexNormal_cameraspace = MV3x3 * vNormal;
mat3 TBN = transpose(mat3(
vertexTangent_cameraspace,
vertexBitangent_cameraspace,
vertexNormal_cameraspace
));
LightDirection_tangentspace = TBN * LightDirection_cameraspace;
EyeDirection_tangentspace = TBN * EyeDirection_cameraspace;
}
Fragment Shader
#version 430
in vec4 vColor;
in vec2 texCoord;
out vec4 fColor;
uniform sampler2D tex;
in vec3 Position_worldspace;
in vec3 EyeDirection_cameraspace;
uniform vec3 LightPosition;
//uniform sampler2D DiffuseTex; pretty much just tex
uniform sampler2D NormalTex;
uniform sampler2D SpecularTex;
in vec3 LightDirection_tangentspace;
in vec3 EyeDirection_tangentspace;
void main()
{
vec3 LightColor = vec3(1, 1, 1);
float LightPower = 50.0f;
//vec3 MaterialDiffuseColor = texture2D(tex, texCoord).rgb; // EDITABLE VALU 3 LINE
//vec3 MaterialAmbientColor = vec3(0.1, 0.1, 0.1) * MaterialDiffuseColor;
//vec3 MaterialSpecularColor = texture2D(SpecularTex, texCoord).rgb * 0.3;
vec3 MaterialDiffuseColor = vec3(0.5, 0.5, 0.5);
vec3 MaterialAmbientColor = vec3(0.1, 0.1, 0.1);
vec3 MaterialSpecularColor = vec3(1, 1, 1);
vec3 TextureNormal_tangentspace = normalize(texture2D(NormalTex, vec2(texCoord.x, texCoord.y)).rgb * 2.0 - 1.0); // EDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDIT this line if upside down
float distance = length(LightPosition - Position_worldspace);
vec3 n = TextureNormal_tangentspace;
vec3 l = normalize(LightDirection_tangentspace);
float cosTheta = clamp(dot(n, l), 0, 1);
vec3 E = normalize(EyeDirection_tangentspace);
vec3 R = reflect(-l, n);
float cosAlpha = clamp(dot(E, R), 0, 1);
fColor = vec4(MaterialAmbientColor + MaterialDiffuseColor * LightColor * LightPower * cosTheta / (distance*distance) + MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5) / (distance*distance), 1.0);
}
Here's an imgur album with photos including the diffuse, specular, and normal maps as well as the image the program produces. http://imgur.com/a/8MMU1
P.S. The shader DOES compile, it just does not produce the desired image.

Answer 1

Firstly, nice code! I've seen shaders far more difficult to read than that.
You can simplify the projection/view/model transformations so there are no duplicates...
vec4 worldPosition = Modle * vPosition;
vec4 cameraPosition = View * worldPosition;
vec4 clipPosition = Projection * cameraPosition;
gl_Position = clipPosition;
To transform the normal, you need a normal matrix (inverse transpose modelview), otherwise scales can mess things up.
It's pretty common to compute LightPosition_cameraspace outside the shader, since it doesn't change. You also don't need Position_worldspace as distance can be computed in camera/eye space. View * Model is pretty expensive, and can be computed once and passed in. Now that View isn't needed, you can simply replace both View and Model with the single ModelView matrix.
The binormal can be computed implicitly from the normal and tangent via a cross product. This saves a fair bit of storage and memory bandwidth. If your normal/tangent are not perpendicular it may be necessary to use two cross products to ensure all three are orthonormal.
The main problem seems to be in your last line...
fColor = vec4(
MaterialAmbientColor
+ (
MaterialDiffuseColor * LightColor * LightPower * cosTheta
/ (distance*distance)
)
+ (
MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5)
/ (distance*distance)
)
, 1.0);
LightPower is scaling your diffuse and specular components. Change to the following
float attenuation = 1.0/distance*distance; //just for readability
fColor = vec4(
MaterialAmbientColor
+ (
MaterialDiffuseColor * LightColor * cosTheta * attenuation
)
+ (
MaterialSpecularColor * LightColor * pow(cosAlpha, LightPower) * attenuation
)
, 1.0);
If after this you're still not seeing the right result, you'll have to start doing some debugging of each variable to narrow down the trouble maker. For example, as #user1118321 suggested check the colours aren't just black or something. Check your LightDirection_tangentspace with fColor = vec4(l,1) - you might look for (0,0,1)/blue for the parts that face the light directly. Make sure tangent/normals/light position are non-zero, the normal texture is bound etc (fColor = vec4(n,1)).