VERTEX_SHADER

	#version 400

	layout(location=0) in vec3 in_Position;
	layout(location=1) in vec3 in_Normal;
	layout(location=2) in vec2 in_UV;
	layout(location=3) in vec3 in_Tangent;

	out vec4 ex_Color;
	out vec3 ex_Normal;
	out vec3 ex_WorldPos;
	out vec2 ex_UV;
	out vec3 ex_Tangent;
	out vec3 ex_ShadowCoord;


	uniform mat4 ModelMatrix;
    uniform mat4 ViewMatrix;
    uniform mat4 ProjectionMatrix;
	uniform mat4 depthPV;
	uniform mat4 depthBiasPV;

	void main(void)
	{
		gl_Position = (ProjectionMatrix * ViewMatrix * ModelMatrix) * vec4(in_Position,1);
		ex_Normal = (ModelMatrix * vec4(in_Normal,0)).xyz;
		ex_WorldPos = (ModelMatrix * vec4(in_Position,1)).xyz;
		ex_UV=in_UV;
		ex_Tangent=normalize(  (ModelMatrix * vec4(in_Tangent,0)).xyz );
		ex_ShadowCoord = (depthPV * ModelMatrix * vec4(in_Position,1)).xyz;
		ex_ShadowCoord = (ex_ShadowCoord/2)+0.5;
		//ex_ShadowCoord = (ex_ShadowCoord);
		//ex_ShadowCoord = (depthBiasPV * ModelMatrix * vec4(in_Position,1)).xyz;
	}





FRAGMENT_SHADER

	#version 400

	float packColor(vec3 color) {
		return color.r + color.g * 256.0 + color.b * 256.0 * 256.0;
	}
	vec3 unpackColor(float f) {
		vec3 color;
		color.b = floor(f / 256.0 / 256.0);
		color.g = floor((f - color.b * 256.0 * 256.0) / 256.0);
		color.r = floor(f - color.b * 256.0 * 256.0 - color.g * 256.0);
		// now we have a vec3 with the 3 components in range [0..256]. Let's normalize it!
		return color / 256.0;
	}
	float rand(vec2 co){
		return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
	}

	in vec4 ex_Color;
	in vec3 ex_Normal;
	in vec3 ex_WorldPos;
	in vec2 ex_UV;
	in vec3 ex_Tangent;
	in vec3 ex_ShadowCoord;

	out vec4 out_Color;


	struct Light {
		vec3 color;
		vec3 position; // position == 0,0,0 => directional light
		vec3 direction; // direction == 0,0,0 => point light
		float attenuation;
		float cutOff;
	};
	const int MAX_LIGHTS = 10;
	uniform Light lights[MAX_LIGHTS];
	uniform int lightsNum;



	uniform vec3 lightPos;
	uniform vec3 lightColor;
	uniform vec3 ambientColor;
	uniform vec3 diffuseColor;
	uniform vec3 specularColor;
	uniform vec3 camPos;
	uniform float specularPower;
	uniform sampler2D ColorMap;
	uniform sampler2D NormalMap;
	uniform sampler2D SpecularMap;
	uniform sampler2D ShadowMap;

	void main(void)
	{
		float ooo=1;

		vec3 N = normalize(ex_Normal);
		if(length(ex_Tangent)>0.1) {
			vec3 nmap=2*texture2D(NormalMap, ex_UV).xyz-1;
			vec3 T = normalize(ex_Tangent);
			vec3 B;
			T=normalize(T-dot(T,N)*N);
			B=normalize(cross(T,N));
			N=normalize(
				mat3(B,T,N)*
				nmap*5
			);
		}



		const vec2 poissonDisk[4] = vec2[](
		  vec2( -0.94201624, -0.39906216 ),
		  vec2( 0.94558609, -0.76890725 ),
		  vec2( -0.094184101, -0.92938870 ),
		  vec2( 0.34495938, 0.29387760 )
		);
		const float shadowEdgeDistance=0.2f;
		float visibility = 1.0;
		if(
			ex_ShadowCoord.x>shadowEdgeDistance && ex_ShadowCoord.y>shadowEdgeDistance &&
			ex_ShadowCoord.x<1-shadowEdgeDistance && ex_ShadowCoord.y<1-shadowEdgeDistance
		) {
			const int im=4;
			for (int x=0;x<im;x++) {
				for (int y=0;y<im;y++) {
					float bias=0.0005;
					//vec2 r=vec2(rand(ex_WorldPos.xy+gl_FragCoord.xy),rand(ex_WorldPos.xy+gl_FragCoord.xy));
					//vec2 r=vec2(rand(ex_WorldPos.xy),rand(ex_WorldPos.xy));
					//vec2 r=vec2(rand(ex_WorldPos.xy),rand(ex_WorldPos.xy));
					//vec3 smp=texture2D( ShadowMap, ex_ShadowCoord.xy + poissonDisk[i%4]/700.0 ).xyz;
					//float d=clamp(dot(N,normalize(lights[0].direction)),0,1);
					//bias=d/1000;
					vec3 smp=texture2D( ShadowMap, ex_ShadowCoord.xy + vec2(x,y)/(im*im*700.0)).xyz;
					float depth=packColor(smp)/65025;
					if ( depth  <  ex_ShadowCoord.z + bias  ) {
						visibility -= 1.0/(im*im);
					}
				}
			}
		}









		vec3 cameraDirection = normalize(ex_WorldPos-camPos);
		vec3 lightsColor=vec3(0,0,0);

		for(int i=0; i<lightsNum; i++) {
			Light light=lights[i];

			vec3 lightToPixel;
			float koef=1;

			if(light.position==vec3(0,0,0)) {
				lightToPixel=normalize(light.direction);
			} else {
				lightToPixel = normalize(light.position-ex_WorldPos);
			}

			if(light.cutOff>0) {
				float spotFactor = dot(lightToPixel,normalize(light.direction));
				if(spotFactor > light.cutOff) {
					koef *= (1.0 - (1.0 - spotFactor) *
							1.0 / (1.0 - light.cutOff ));
				} else {
					koef *= 0;
				}
			}


			float diffuseFactor = max(0,dot(N,lightToPixel));
			vec3 lightColor=light.color*diffuseFactor;
			if(specularPower>0) {
				float specularFactor = clamp(pow(max(0,dot(cameraDirection,reflect(lightToPixel,N))),specularPower),0,1);
				specularFactor*=texture2D(SpecularMap, ex_UV).xyz;
				lightColor+=light.color*specularFactor;
			}

			if(light.attenuation>0) {
				float distance=distance(light.position,ex_WorldPos);
				float attenuation=light.attenuation*distance*distance;
				koef/=max(attenuation,1);
			}


			if(i==0) koef*=visibility; //TOFIX first light = shadowcaster


			lightsColor+=lightColor*koef;

			//lightsColor+= vec3(diffuseFactor,diffuseFactor,diffuseFactor);
		}








		float ambientFactor = 1;



		vec3 c = texture2D(ColorMap, ex_UV).xyz;
		c = c*ambientColor + c*lightsColor;
		out_Color=vec4(c,0.1);
		//out_Color=vec4(1,1,1,1)*visibility;
		//out_Color=vec4(1,1,1,1)* texture2D( ShadowMap, (ex_ShadowCoord.xy) ).z;
		//out_Color=vec4(1,1,1,1)* ex_ShadowCoord.z;
		//out_Color = normalize(1+vec4(N,0));
		//out_Color = texture2D(NormalMap, ex_UV);
		//out_Color=vec4(N,0);
		//out_Color=vec4(0,diffuse,0,1);
		//out_Color=vec4(0,1,0,1);
		//out_Color=vec4(0,out_Color.x,0,1);
		//out_Color=vec4(lightPos,0);
		//out_Color=texture2D(ColorMap, ex_UV);
		//out_Color=texture2D(NormalMap, ex_UV);
		//out_Color=vec4(gl_FragCoord.z,gl_FragCoord.z,gl_FragCoord.z,1);
		//out_Color=vec4(1,1,1,1)*visibility;
		//out_Color=texture2D(ShadowMap, ex_ShadowCoord.xy);
		//out_Color=texture2D(ShadowMap, ex_UV);
		//out_Color=vec4(ex_ShadowCoord,1);
		//out_Color=vec4(T,1);
		//out_Color=vec4(1,1,1,1)*ooo;

	}