precision highp float;

    // Compiler should remove unneeded stuff
    uniform vec3 view_position;

    uniform vec3 light_globalAmbient;

    varying vec3 vPositionW;
    varying vec3 vNormalW;
    varying vec3 vTangentW;
    varying vec3 vBinormalW;
    varying vec2 vUv0;
    varying vec2 vUv1;
    varying vec4 vVertexColor;
    varying vec3 vNormalV;

    struct psInternalData {
        vec3 albedo;
        vec3 specularity;
        float glossiness;
        vec3 emission;
        vec3 normalW;
        mat3 TBN;
        vec3 viewDirW;
        vec3 reflDirW;
        vec3 diffuseLight;
        vec3 specularLight;
        float alpha;
        vec3 lightDirNormW;
        vec3 lightDirW;
        float atten;
        vec3 shadowCoord;
        vec2 uvOffset;
    };

    void getViewDir(inout psInternalData data) {
        data.viewDirW = normalize(view_position - vPositionW);
    }

    void getReflDir(inout psInternalData data) {
        data.reflDirW = normalize(-reflect(data.viewDirW, data.normalW));
    }

    void addAmbientConstant(inout psInternalData data) {
        data.diffuseLight += light_globalAmbient;
    }

    void getLightDirPoint(inout psInternalData data, vec3 lightPosW) {
        data.lightDirW = vPositionW - lightPosW;
        data.lightDirNormW = normalize(data.lightDirW);
    }

    float getFalloffLinear(inout psInternalData data, float lightRadius) {
        float d = length(data.lightDirW);
        return max(((lightRadius - d) / lightRadius), 0.0);
    }

    float getFalloffInvSquared(inout psInternalData data) {
        float sqrDist = dot(data.lightDirW, data.lightDirW);
        return 1.0 / sqrDist;
    }

    float getSpotEffect(inout psInternalData data, vec3 lightSpotDirW, float lightInnerConeAngle, float lightOuterConeAngle) {
        float cosAngle = dot(data.lightDirNormW, lightSpotDirW);
        return smoothstep(lightOuterConeAngle, lightInnerConeAngle, cosAngle);
    }

    uniform vec3 light0_color;
    uniform vec3 light0_direction;
    uniform vec3 fog_color;
    uniform float fog_start;
    uniform float fog_end;


    void getNormal(inout psInternalData data) {
        data.normalW = normalize(vNormalW);
    }

    vec4 texture2DAlbedo(sampler2D tex, vec2 uv) {
        return texture2D(tex, uv);
    }

    vec3 gammaCorrectOutput(vec3 color) {
        return color;
    }

    uniform sampler2D texture_diffuseMap;
    void getAlbedo(inout psInternalData data) {
        vec4 tex = texture2DAlbedo(texture_diffuseMap, vUv0);
        data.albedo = tex.rgb;
    }

    uniform float material_shininess;
    void getGlossiness(inout psInternalData data) {
        // Hack: On Mac OS X, calling pow with zero for the exponent generates hideous artifacts so bias up a little
        data.glossiness = material_shininess + 0.0001;
    }

    uniform float material_opacity;
    void getOpacity(inout psInternalData data) {
        data.alpha = material_opacity;
    }

    uniform vec3 material_emissive;
    vec3 getEmission(inout psInternalData data) {
        return material_emissive;
    }

    float getLightDiffuse(inout psInternalData data) {
        return max(dot(data.normalW, -data.lightDirNormW), 0.0);
    }

    vec3 combineColor(inout psInternalData data) {
        return data.albedo * data.diffuseLight;
    }


    void main(void) {
       psInternalData data;
       data.diffuseLight = vec3(0);
       data.specularLight = vec3(0);

       getNormal(data);
       getAlbedo(data);
       getOpacity(data);
       addAmbientConstant(data);

       data.lightDirNormW = light0_direction;
       data.atten = getLightDiffuse(data);
       data.diffuseLight += data.atten * light0_color;


       gl_FragColor.rgb = combineColor(data);
       gl_FragColor.rgb += getEmission(data);
       gl_FragColor.rgb = gammaCorrectOutput(gl_FragColor.rgb);
       gl_FragColor.a = data.alpha;
    }