#include "Uniforms.glsl"
#include "Samplers.glsl"
#include "Transform.glsl"
#include "ScreenPos.glsl"
#include "Lighting.glsl"
#include "Fog.glsl"


#ifdef NORMALMAP
	varying vec4 vTexCoord;
    varying vec4 vTangent;
	#ifdef MODELNORMAL
		varying vec2 vModelTexCoord;
	#endif
#else
    varying vec2 vTexCoord;
#endif

varying vec3 vNormal;
varying vec4 vWorldPos;

#ifdef PERPIXEL
    #ifdef SHADOW
        varying vec4 vShadowPos[NUMCASCADES];
    #endif
    #ifdef SPOTLIGHT
        varying vec4 vSpotPos;
    #endif
    #ifdef POINTLIGHT
        varying vec3 vCubeMaskVec;
    #endif
#else
    varying vec3 vVertexLight;
    varying vec4 vScreenPos;
    #ifdef ENVCUBEMAP
        varying vec3 vReflectionVec;
    #endif
    #if defined(LIGHTMAP) || defined(AO)
        varying vec2 vTexCoord2;
    #endif
#endif

//varying vec3 vDetailTexCoord;

uniform sampler2D sWeightMap0;
uniform sampler2DArray sDetailMap1;

#ifdef NORMALMAP
	uniform sampler2DArray sNormal2;
	#ifdef MODELNORMAL
		uniform sampler2D sModelNormal3;
	#endif
#endif

uniform vec2 cTilingFactors;

#ifdef MODELNORMAL
vec3 combineNormals(vec3 n1, vec3 n2)
{
	vec3 t=n1*vec3(2,2,2)+vec3(-1,-1,0);
	vec3 u=n2*vec3(-2,-2,2)+vec3(1,1,-1);
	vec3 r=t*dot(t,u)/t.z-u;
	return r;
}
#endif


void VS()
{
    mat4 modelMatrix = iModelMatrix;
    vec3 worldPos = GetWorldPos(modelMatrix);
    gl_Position = GetClipPos(worldPos);
    vNormal = GetWorldNormal(modelMatrix);
    vWorldPos = vec4(worldPos, GetDepth(gl_Position));

	#ifdef NORMALMAP
        vec3 tangent = GetWorldTangent(modelMatrix);
        vec3 bitangent = cross(tangent, vNormal) * iTangent.w;
        vTexCoord=vec4(GetTexCoord(worldPos.xz*vec2(1.0/cTilingFactors.x, 1.0/cTilingFactors.y)), bitangent.xy);
        vTangent = vec4(tangent, bitangent.z);
		#ifdef MODELNORMAL
			vModelTexCoord=GetTexCoord(iTexCoord);
		#endif
    #else
        vTexCoord = GetTexCoord(worldPos.xz*vec2(1.0/cTilingFactors.x, 1.0/cTilingFactors.y));
    #endif
    //vDetailTexCoord = worldPos.xyz * 0.8;

    #ifdef PERPIXEL
        // Per-pixel forward lighting
        vec4 projWorldPos = vec4(worldPos, 1.0);

        #ifdef SHADOW
            // Shadow projection: transform from world space to shadow space
            for (int i = 0; i < NUMCASCADES; i++)
                vShadowPos[i] = GetShadowPos(i, vNormal, projWorldPos);
        #endif

        #ifdef SPOTLIGHT
            // Spotlight projection: transform from world space to projector texture coordinates
            vSpotPos = projWorldPos * cLightMatrices[0];
        #endif

        #ifdef POINTLIGHT
            vCubeMaskVec = (worldPos - cLightPos.xyz) * mat3(cLightMatrices[0][0].xyz, cLightMatrices[0][1].xyz, cLightMatrices[0][2].xyz);
        #endif
    #else
        // Ambient & per-vertex lighting
        #if defined(LIGHTMAP) || defined(AO)
            // If using lightmap, disregard zone ambient light
            // If using AO, calculate ambient in the PS
            vVertexLight = vec3(0.0, 0.0, 0.0);
            vTexCoord2 = iTexCoord1;
        #else
            vVertexLight = GetAmbient(GetZonePos(worldPos));
        #endif

        #ifdef NUMVERTEXLIGHTS
            for (int i = 0; i < NUMVERTEXLIGHTS; ++i)
                vVertexLight += GetVertexLight(i, worldPos, vNormal) * cVertexLights[i * 3].rgb;
        #endif

        vScreenPos = GetScreenPos(gl_Position);

        #ifdef ENVCUBEMAP
            vReflectionVec = worldPos - cCameraPos;
        #endif
    #endif
}

void PS()
{
    // Get material diffuse albedo
    vec4 weights0 = texture(sWeightMap0, vTexCoord.xy).rgba;
    vec3 vDetailTexCoord=vWorldPos.xyz*0.8;

	vec3 n1=vec3(0.5,0,0.86602540378443864676372317075294);
	vec3 n3=vec3(0.5,0,-0.86602540378443864676372317075294);

	vec3 nrm = normalize(vNormal);
	vec4 blending;
	blending.y=abs(nrm.y);
	blending.x=clamp((abs(dot(nrm, n1))-0.5),0,1)*2;
	blending.z=clamp((abs(nrm.x)-0.5),0,1)*2;
	blending.w=clamp((abs(dot(nrm,n3))-0.5),0,1)*2;
	float b=blending.x+blending.y+blending.z+blending.w;
	blending=blending/b;

	vec4 tex1=texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 4))*blending.x +
		texture(sDetailMap1, vec3(vDetailTexCoord.zy, 4))*blending.z +
		texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1),4))*blending.w +
		texture(sDetailMap1, vec3(vDetailTexCoord.xz, 0))*blending.y;
	//vec4 tex2=texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 5))*blending.x +
		//texture(sDetailMap1, vec3(vDetailTexCoord.zy, 5))*blending.z +
		//texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1),5))*blending.w +
		//texture(sDetailMap1, vec3(vDetailTexCoord.xz, 1))*blending.y;
	//vec4 tex3=texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 6))*blending.x +
		//texture(sDetailMap1, vec3(vDetailTexCoord.zy, 6))*blending.z +
		//texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1),6))*blending.w +
		//texture(sDetailMap1, vec3(vDetailTexCoord.xz, 2))*blending.y;
	//vec4 tex4=texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 7))*blending.x +
		//texture(sDetailMap1, vec3(vDetailTexCoord.zy, 7))*blending.z +
		//texture(sDetailMap1, vec3(vDetailTexCoord.xy*vec2(1.1547,1),7))*blending.w +
		//texture(sDetailMap1, vec3(vDetailTexCoord.xz, 3))*blending.y;


	//float ma=max(tex1.a+weights0.r, max(tex2.a+weights0.g, max(tex3.a+weights0.b, tex4.a+weights0.a)))-0.2;
	//float b1=max(0, tex1.a+weights0.r-ma);
	//float b2=max(0, tex2.a+weights0.g-ma);
	//float b3=max(0, tex3.a+weights0.b-ma);
	//float b4=max(0, tex4.a+weights0.a-ma);
	//float bsum=b1+b2+b3+b4;
	//vec4 diffColor=((tex1*b1+tex2*b2+tex3*b3+tex4*b4)/bsum);
	vec4 diffColor=tex1;

    vec3 specColor = cMatSpecColor.rgb;

    // Get normal
	#ifdef NORMALMAP
	    vec3 bit=vec3(vTexCoord.zw, vTangent.w);
        mat3 tbn = mat3(vTangent.xyz, bit, vNormal);
		vec4 bump1=(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 4)))*blending.x +
			(texture(sNormal2, vec3(vDetailTexCoord.zy, 4)))*blending.z +
			(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 4)))*blending.w +
			(texture(sNormal2, vec3(vDetailTexCoord.xz, 0)))*blending.y;
		//vec4 bump2=(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 5)))*blending.x +
			//(texture(sNormal2, vec3(vDetailTexCoord.zy, 5)))*blending.z +
			//(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 5)))*blending.w +
			//(texture(sNormal2, vec3(vDetailTexCoord.xz, 1)))*blending.y;
		//vec4 bump3=(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 6)))*blending.x +
			//(texture(sNormal2, vec3(vDetailTexCoord.zy, 6)))*blending.z +
			//(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 6)))*blending.w +
			//(texture(sNormal2, vec3(vDetailTexCoord.xz, 2)))*blending.y;
		//vec4 bump4=(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 7)))*blending.x +
			//(texture(sNormal2, vec3(vDetailTexCoord.zy, 7)))*blending.z +
			//(texture(sNormal2, vec3(vDetailTexCoord.xy*vec2(1.1547,1), 7)))*blending.w +
			//(texture(sNormal2, vec3(vDetailTexCoord.xz, 3)))*blending.y;

		//vec3 texnormal=normalize(((bump1*b1+bump2*b2+bump3*b3+bump4*b4)/bsum).rgb*2.0-1.0);
		vec3 texnormal=normalize(bump1.rgb*2.0-1.0);
		//vec3 texnormal=vec3(0,0,1);


		#ifdef MODELNORMAL
			texnormal=texnormal*0.5+0.5;
			vec4 modelnormalsample=texture(sModelNormal3, vModelTexCoord.xy);
			vec3 modelnormal=modelnormalsample.rgb;
			vec3 normal=(combineNormals(modelnormal, texnormal));

		#else
			vec3 normal=texnormal;
		#endif

		normal=normalize(normal*tbn);

    #else
        vec3 normal = normalize(vNormal);
    #endif

    diffColor=vec4(abs(vTangent.xyz*0.5+0.5),1);
    normal=normalize(vNormal);

    // Get fog factor
    #ifdef HEIGHTFOG
        float fogFactor = GetHeightFogFactor(vWorldPos.w, vWorldPos.y);
    #else
        float fogFactor = GetFogFactor(vWorldPos.w);
    #endif

    #if defined(PERPIXEL)
        // Per-pixel forward lighting
        vec3 lightColor;
        vec3 lightDir;
        vec3 finalColor;

        float diff = GetDiffuse(normal, vWorldPos.xyz, lightDir);

        #ifdef SHADOW
            diff *= GetShadow(vShadowPos, vWorldPos.w);
        #endif

        #if defined(SPOTLIGHT)
            lightColor = vSpotPos.w > 0.0 ? texture2DProj(sLightSpotMap, vSpotPos).rgb * cLightColor.rgb : vec3(0.0, 0.0, 0.0);
        #elif defined(CUBEMASK)
            lightColor = textureCube(sLightCubeMap, vCubeMaskVec).rgb * cLightColor.rgb;
        #else
            lightColor = cLightColor.rgb;
        #endif

        #ifdef SPECULAR
            float spec = GetSpecular(normal, cCameraPosPS - vWorldPos.xyz, lightDir, cMatSpecColor.a);
            finalColor = diff * lightColor * (diffColor.rgb + spec * specColor * cLightColor.a);
        #else
            finalColor = diff * lightColor * diffColor.rgb;
        #endif

        #ifdef AMBIENT
            finalColor += cAmbientColor * diffColor.rgb;
            finalColor += cMatEmissiveColor;
            gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
        #else
            gl_FragColor = vec4(GetLitFog(finalColor, fogFactor), diffColor.a);
        #endif
    #elif defined(PREPASS)
        // Fill light pre-pass G-Buffer
        float specPower = cMatSpecColor.a / 255.0;

        gl_FragData[0] = vec4(normal * 0.5 + 0.5, specPower);
        gl_FragData[1] = vec4(EncodeDepth(vWorldPos.w), 0.0);
    #elif defined(DEFERRED)
        // Fill deferred G-buffer
        float specIntensity = specColor.g;
        float specPower = cMatSpecColor.a / 255.0;

        vec3 finalColor = vVertexLight * diffColor.rgb;
        #ifdef AO
            // If using AO, the vertex light ambient is black, calculate occluded ambient here
            finalColor += texture2D(sEmissiveMap, vTexCoord2).rgb * cAmbientColor * diffColor.rgb;
        #endif

        #ifdef ENVCUBEMAP
            finalColor += cMatEnvMapColor * textureCube(sEnvCubeMap, reflect(vReflectionVec, normal)).rgb;
        #endif
        #ifdef LIGHTMAP
            finalColor += texture2D(sEmissiveMap, vTexCoord2).rgb * diffColor.rgb;
        #endif
        #ifdef EMISSIVEMAP
            finalColor += cMatEmissiveColor * texture2D(sEmissiveMap, vTexCoord.xy).rgb;
        #else
            finalColor += cMatEmissiveColor;
        #endif

        gl_FragData[0] = vec4(GetFog(finalColor, fogFactor), 1.0);
        gl_FragData[1] = fogFactor * vec4(diffColor.rgb, specIntensity);
        gl_FragData[2] = vec4(normal * 0.5 + 0.5, specPower);
        gl_FragData[3] = vec4(EncodeDepth(vWorldPos.w), 0.0);
    #else
        // Ambient & per-vertex lighting
        vec3 finalColor = vVertexLight * diffColor.rgb;
        #ifdef AO
            // If using AO, the vertex light ambient is black, calculate occluded ambient here
            finalColor += texture2D(sEmissiveMap, vTexCoord2).rgb * cAmbientColor * diffColor.rgb;
        #endif

        #ifdef MATERIAL
            // Add light pre-pass accumulation result
            // Lights are accumulated at half intensity. Bring back to full intensity now
            vec4 lightInput = 2.0 * texture2DProj(sLightBuffer, vScreenPos);
            vec3 lightSpecColor = lightInput.a * lightInput.rgb / max(GetIntensity(lightInput.rgb), 0.001);

            finalColor += lightInput.rgb * diffColor.rgb + lightSpecColor * specColor;
        #endif

        #ifdef ENVCUBEMAP
            finalColor += cMatEnvMapColor * textureCube(sEnvCubeMap, reflect(vReflectionVec, normal)).rgb;
        #endif
        #ifdef LIGHTMAP
            finalColor += texture2D(sEmissiveMap, vTexCoord2).rgb * diffColor.rgb;
        #endif
        #ifdef EMISSIVEMAP
            finalColor += cMatEmissiveColor * texture2D(sEmissiveMap, vTexCoord.xy).rgb;
        #else
            finalColor += cMatEmissiveColor;
        #endif

        gl_FragColor = vec4(GetFog(finalColor, fogFactor), diffColor.a);
    #endif
}