Normal Mapping Precision on iOS

Code:

attribute vec4 position;

attribute vec3 normal;

attribute vec3 binormal;

attribute vec3 tangent;

attribute vec2 texcoord0;

attribute vec4 color;



varying vec4 colorVarying;

varying vec2 texOut0;

varying vec3 v_viewDirection;

varying vec3 v_lightDirection;

varying vec3 v_normal;



uniform float translate;

uniform mat4 u_mvp_matrix;

uniform mat4 Projection;

uniform mat4 Modelview;

uniform mat4 ModelviewInverse;

uniform mat3 NormalMatrix;

uniform vec3 LightPosition;

uniform vec3 EyePosition;



void main() 

{

    vec3 vRed = vec3(1,0,0);

    

    gl_Position = Projection * Modelview * position;

    texOut0 = texcoord0;



    

    

    vec3 worldPosition = (Modelview * position).xyz;    

    vec3 normalWorld = normalize((NormalMatrix * normal).xyz);

    vec3 eyePositionWorld = (    ModelviewInverse *    vec4(EyePosition,1.0)).xyz;

    vec3 viewDirectionWorld = eyePositionWorld - position.xyz;

    

    vec3 lightPositionWorld = (    ModelviewInverse *    vec4(LightPosition,1.0)).xyz;

    vec3 lightDirectionWorld = lightPositionWorld - position.xyz;                

    

    mat3 tangentMat = mat3(tangent,binormal,normal.xyz);

    

    v_viewDirection = viewDirectionWorld * tangentMat;

    v_lightDirection = lightDirectionWorld * tangentMat;



}

Code:

precision highp float;

varying lowp vec4 colorVarying;

varying lowp vec2 texOut0;

varying mediump vec3 v_normal;



uniform sampler2D textureMap;

uniform sampler2D normalMap;

varying mediump vec3 v_viewDirection;

varying mediump vec3 v_lightDirection;





void main() 

{

    highp vec3 baseColor = texture2D( textureMap, texOut0.st).xyz;

    //lowp vec4 baseColor = vec4(1,1,1,1);

    highp vec3 nl = texture2D( normalMap, texOut0.st).xyz;    

    

    highp vec3 normal = normalize(nl.yxz * 2.0 -1.0);

    

    highp vec3 lightDirection = normalize(v_lightDirection);

    highp vec3 viewDirection = normalize(v_viewDirection);

    

    highp float nDotL = dot(normal, lightDirection);

    

    highp vec3 reflection = (2.0 * normal * nDotL) - lightDirection;

    

    highp float rDotV = max( 0.0,dot(reflection, viewDirection));

    

//    mediump vec4 ambient = vec4(0.1,0.1,0.1,1.0) * baseColor;

//    mediump vec4 diffuse = vec4(0.8,0.8,0.8,1.0) * nDotL * baseColor;

//    mediump vec4 specular = vec4(1,1,1,1) * pow(rDotV, 100.0);    

    //gl_FragColor= ambient + diffuse + specular;

    highp vec3 ambient = vec3(0.1,0.1,0.1) * baseColor;

    highp vec3 diffuse = vec3(1.0,1.0,1.0) * nDotL * baseColor;

    highp vec3 specular = vec3(1,1,1) * pow(rDotV, 100.0);

    gl_FragColor= vec4(ambient + diffuse + specular,1);

    

    //gl_FragColor= diffuse;

    //gl_FragColor = vec4(nl,1);



}