// vert //

out vec3 view_dir, world_dir;

uniform vec4 view_corners[4], world_corners[4];

void main(void) {
	qgl_FragTexture = qgl_Texture;
	gl_Position = qgl_ftransform();
	view_dir  = view_corners [gl_VertexID].xyz;
	world_dir = world_corners[gl_VertexID].xyz;
}


// frag //

in vec3 view_dir, world_dir;

uniform vec2 dt;
uniform float z_near;
uniform sampler2D tex_coeff_brdf, tex_noise;
uniform sampler2D tex_0, tex_1, tex_2, tex_3, tex_4, tex_5, tex_sh;
//uniform sampler2DShadow tex_shadow[16];
#ifdef SHADOWS
uniform vec2 shadow_size;
uniform sampler2DArrayShadow tex_shadows_cone;
uniform sampler2DArray tex_depths_cone;
uniform samplerCubeArrayShadow tex_shadows_omni;
uniform samplerCubeArray tex_depths_omni;
uniform bool soft_shadows_enabled = false;
uniform float soft_shadows_quality = 1.;
uniform int soft_shadows_samples = 16, noise_size = 64;
#endif
uniform samplerCube tex_env;
uniform int lights_start, lights_count;
uniform vec4 fog_color = vec4(0.5, 0.5, 0.5, 1.);
uniform float fog_decay = 10., fog_density = 0.;
uniform mat3 view_mat;
const float _pe = 2.4e-7;

const vec3 luma = vec3(0.299, 0.587, 0.114);
const float _min_rough = 1.e-8, max_lod = 8.;
const float PI = 3.1416;

ivec2 tc;
vec4 pos, lpos, shp;
vec3 li, si, ldir, halfV, bn, bn2, lwdir;
vec3 normal, geom_normal, vds, vds2;
float rough_diff, rough_spec, dist, NdotL, NdotH, spot, ldist, diff, spec, sdist;
uint flags;


vec4 mapScreenToShadow(in int light_index, in vec3 offset) {
	vec4 shp = qgl_light_position[light_index].shadow_matrix * (pos + vec4(offset, 0));
	//shp.z += 0.5;
	return shp;
}


#ifdef SHADOWS
#ifdef SPOT

float getShadowCone(in vec3 uvz, in int layer) {
	/*vec2 uvpix = uvz.xy * shadow_size + vec2(0.5f);
	vec2 uvp = fract(uvpix), iuvp = vec2(1.f) - uvp;
	vec4 gt = textureGather(tex_shadows_cone, vec3(floor(uvpix.xy) / shadow_size, layer), 0);
	vec4 uvv;
	uvv[0] = iuvp.x *  uvp.y;
	uvv[1] =  uvp.x *  uvp.y;
	uvv[2] =  uvp.x * iuvp.y;
	uvv[3] = iuvp.x * iuvp.y;
	shadow_dz = max(max(uvz.z - gt[0], uvz.z - gt[1]), max(uvz.z - gt[2], uvz.z - gt[3]));
	return clamp(dot(step(vec4(uvz.z), gt), uvv), 0, 1);*/
	float z = 1. - 1. / (uvz.z - z_near + 1.);
	return texture(tex_shadows_cone, vec4(uvz.xy, layer, z));
}

#else

float getShadowOmni(in vec4 uvwz, in int layer) {
	/*vec3 uvpix = uvwz.xyz * vec3(shadow_size.x) + vec3(0.5f);
	vec3 uvp = fract(uvpix), iuvp = vec3(1.f) - uvp;
	vec4 gt = textureGather(tex_shadows_omni, vec4(floor(uvpix.xyz) / vec3(shadow_size.x), layer), 0);
	vec4 uvv;
	uvv[0] = iuvp.y *  uvp.z;
	uvv[1] =  uvp.y *  uvp.z;
	uvv[2] =  uvp.y * iuvp.z;
	uvv[3] = iuvp.y * iuvp.z;
	return clamp(dot(step(vec4(uvwz.w), gt), uvv), 0, 1);*/
	float d = 1. - 1. / (uvwz.w - z_near + 1.);
	return texture(tex_shadows_omni, vec4(uvwz.xyz, layer), d);
	//return step(uvwz.w, gt[3]);
}

#endif


uint hash(uint x) {
    x += (x << 10u);
    x ^= (x >>  6u);
    x += (x <<  3u);
    x ^= (x >> 11u);
    x += (x << 15u);
    return x;
}
uint hash( uvec2 v ) { return hash( v.x ^ hash(v.y)                         ); }
uint hash( uvec3 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z)             ); }
uint hash( uvec4 v ) { return hash( v.x ^ hash(v.y) ^ hash(v.z) ^ hash(v.w) ); }
float floatConstruct( uint m ) {
    const uint ieeeMantissa = 0x007FFFFFu; // binary32 mantissa bitmask
    const uint ieeeOne      = 0x3F800000u; // 1.0 in IEEE binary32

    m &= ieeeMantissa;                     // Keep only mantissa bits (fractional part)
    m |= ieeeOne;                          // Add fractional part to 1.0

    float  f = uintBitsToFloat( m );       // Range [1:2]
    return f - 1.;                        // Range [0:1]
}
float random( float x ) { return floatConstruct(hash(floatBitsToUint(x))); }
float random( vec2  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( vec3  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( vec4  v ) { return floatConstruct(hash(floatBitsToUint(v))); }
float random( int   x ) { return floatConstruct(hash(x)); }
float random( ivec2 v ) { return floatConstruct(hash(v)); }
float random( ivec3 v ) { return floatConstruct(hash(v)); }
float random( ivec4 v ) { return floatConstruct(hash(v)); }

uvec2 noise_hash;
void noise2init(vec2 v) {
	noise_hash = uvec2(hash(uint(v.x + 1)), hash(uint(v.y - 1)));
}
vec2 noise2() {
	noise2init(vec2(noise_hash));
	//return vec2(floatConstruct(noise_hash.x), floatConstruct(noise_hash.y)) * 2 - vec2(1.);
	float r = floatConstruct(noise_hash.x);
	float a = floatConstruct(noise_hash.y) * 2 * PI;
	return r * vec2(cos(a), sin(a));
}

float rand(vec2 co) {
    float a = 12.9898;
    float b = 78.233;
    float c = 43758.5453;
    float d = dot(co.xy, vec2(a, b));
    float e = sin(mod(d, 3.14)) * c;
    return fract(e) - 0.5;
}
#endif // SHADOWS

vec4 qgl_lightTexture(int index, vec2 coord, vec4 tex_shift) {
	coord *= qgl_light_parameter[index].map.scale;
	vec4 t = texture(qgl_texture_array[qgl_light_parameter[index].map.array_index],
						   vec3(coord, qgl_light_parameter[index].map.map_index));
	t += tex_shift;
	t.rgb *= qgl_light_parameter[index].map.amount + qgl_light_parameter[index].map.offset;
	return t;
}

void calcLight(in int index, in vec3 n, in vec3 v) {
	lpos = qgl_light_position[index].position;
	ldir = lpos.xyz - (pos.xyz * lpos.w);
	ldist = length(ldir);
	ldir = normalize(ldir);
	//ldir = vec3(0,0,1);
	halfV = normalize(ldir + v);
	NdotL = max(dot(n, ldir), 1E-8);
	NdotH = max(dot(n, halfV), 1E-8);
	spot = step(1.001E-8, NdotL) * qgl_light_parameter[index].decay_intensity.w;
	vec3 light_color = qgl_light_parameter[index].color.rgb;
#ifdef SPOT
	float scos = max(dot(-ldir, qgl_light_position[index].direction.xyz), 0.);
	spot *= scos * step(qgl_light_parameter[index].angles.w, scos);
	spot *= smoothstep(qgl_light_parameter[index].angles.w, qgl_light_parameter[index].angles.y, scos);
	vec4 shp = mapScreenToShadow(index, vec3(0));
	shp.xy /= shp.w;
	vec4 light_map_pix = qgl_lightTexture(index, shp.xy, vec4(0));
	light_color *= light_map_pix.rgb;
	spot *= light_map_pix.a;
#endif

#ifdef SHADOWS
	if (int(round(qgl_light_parameter[index].flags)) == 1 && bitfieldExtract(flags, 3, 1) == 1 && (spot > 1E-4)) {
#ifndef SPOT
		vec3 odir = -(view_mat * ldir);
#endif
		int layer = index - lights_start;
		float shadow = 0.;
		//float bias = abs(tan(PI/2.*(1 - abs(dot(normal, ldir)))) + 1) * z_near * 1;
		float bias = (1. + 1. / abs(dot(geom_normal, ldir))) * z_near * 2.;
		//bias = bias * bias + z_near;
		
		if (soft_shadows_enabled) {
			
			float depth = 1.;
#ifdef SPOT
			const int gm_size = 2;
			for (int i = -gm_size; i <= gm_size; ++i) {
				for (int j = -gm_size; j <= gm_size; ++j) {
					//depth = min(depth, textureOffset(tex_depths_cone, vec3(shp.xy, layer), ivec2(i, j)).x);
					depth = min(depth, texture(tex_depths_cone, vec3(shp.xy + vec2(i, j) / vec2(shadow_size.x), layer)).x);
				}
			}
#else
			const int gm_size = 2;
			for (int i = -gm_size; i <= gm_size; ++i) {
				for (int j = -gm_size; j <= gm_size; ++j) {
					for (int k = -gm_size; k <= gm_size; ++k) {
						depth = min(depth, texture(tex_depths_omni, vec4(odir + vec3(i, j, k) / vec3(shadow_size.x), layer)).r);
					}
				}
			}
			shp.z = ldist;
#endif
			depth = 1. / (1. - depth) - 1. + z_near;
			float dz = max(0., shp.z - depth);
			float ds = qgl_light_parameter[index].size * dz / (ldist - dz);
			//float ds = (ldist / 2.) / qgl_light_parameter[index].size;
			float srate = abs(ds / pos.z) * 10. * soft_shadows_quality;
			//qgl_FragColor.rgb = vec3(srate);
			
			int samples = clamp(int(round(srate * float(soft_shadows_samples))), 1, soft_shadows_samples);
			vds = ds * bn.xyz;
			vds2 = ds * bn2.xyz;
			vec2 so;
			ivec2 sotc = tc;
	
			noise2init(vec2(hash(ivec2(tc.x * 2. + 1., tc.y)), hash(ivec2(tc.x, (tc.y * 2. + 1.)))));
			for (int i = 0; i < samples; ++i) {
					so = noise2();
#ifdef SPOT
					//vec4 nc = texelFetch(tex_noise, sotc % noise_size, 0);
					//sotc += ivec2(nc.ba * 256) % noise_size;
					//so = (nc.rg - vec2(0.5));
					
					//so = vec2(rand(vec2(shp.x + i, shp.y)), rand(vec2(shp.x + i + 1, shp.y)));
					
					vec4 shp = mapScreenToShadow(index, vds * so.x + vds2 * so.y);
					shp.xy /= shp.w;
					shp.z -= bias;
					shadow += getShadowCone(shp.xyz, layer);
#else
					//so = vec2(rand(vec2(odir.x + i, odir.y)), rand(vec2(odir.x + i + 1, odir.y)))*1.25;
					
					vec3 old = lpos.xyz - ((pos.xyz + vec3(vds * so.x + vds2 * so.y)) * lpos.w);
					odir = -(view_mat * old);
					shadow += getShadowOmni(vec4(odir, length(old) - bias), layer);
#endif
			}
			
			spot *= min(1., 2. * shadow / samples);
			//spot *= shadow / soft_shadows_samples;
			//spot *= shadow / soft_shadows_samples + 1;
			
		} else {
			
#ifdef SPOT
			shp.xy;
			shp.z -= bias;
			spot *= getShadowCone(shp.xyz, layer);
#else
			spot *= getShadowOmni(vec4(odir, ldist - bias), layer);
#endif

		}
		//shp.z -= bias;
		//shadow += getShadowCone(shp.xyz, layer, vec2(0));
		
	}
#endif // SHADOWS
	
	vec3 dist_decay = vec3(1., ldist, ldist*ldist);
	spot /= dot(qgl_light_parameter[index].decay_intensity.xyz, dist_decay);
	
	float NdotLs = NdotL*NdotL;
	float NdotHs = NdotH*NdotH;
	
	float ndlc = (1. - NdotLs) / NdotLs;
	diff = 2. / (1. + sqrt(1. + (1. - rough_diff) * ndlc));
	//diff = texture(tex_coeffs[0], vec2(roughness, (NdotLs))).r;
	li += spot * diff * light_color;
	
	ndlc = (1. - NdotHs) / NdotHs;
	float der = NdotHs * (rough_spec + ndlc);
	spec = rough_spec / (der*der) / PI;
	//spec = texture(tex_coeffs[1], vec2(roughness, (NdotHs))).r;
	si += spot * spec * light_color;
}


void main(void) {
	tc = ivec2(gl_FragCoord.xy);
	vec4 v1 = texelFetch(tex_1, tc, 0);
	float z = v1.w;
	if (z == 1.) {
		discard;
	}
	pos.w = 1.;
	pos.xyz = view_dir * z;
	vec3 v = normalize(-pos.xyz);

	vec4 v0 = texelFetch(tex_0, tc, 0),
		 v2 = texelFetch(tex_2, tc, 0),
		 v3 = texelFetch(tex_3, tc, 0),
		 v4 = texelFetch(tex_4, tc, 0),
		 v5 = texelFetch(tex_5, tc, 0);

	vec3 diffuse       = v0.rgb;
		 normal        = v1.xyz;
	geom_normal        = v5.xyz;
	vec3 emission      = v3.rgb;
	float alpha        = v0.a;
	float metalness    = v2.r;
	float roughness    = v2.g;
	float reflectivity = v2.b;
	float NdotV = dot(normal, v);
	float roughness3   = roughness*roughness*roughness;
	bn  = normalize(cross(normal, vec3(1.,0.,0.)) + cross(normal, vec3(0.,1.,0.)));
	bn2 = normalize(cross(normal, bn));
	bn  =           cross(normal, bn2);
	rough_diff = max(roughness, _min_rough);
	rough_spec = max(roughness3, _min_rough);
	float shlick = clamp(metalness + (1. - metalness) * pow(1. - NdotV, 5.), 0., 1.);
	flags = uint(round(v2.w));

	//qgl_FragColor.rgba = vec4(0);

	li = vec3(0.);//qgl_AmbientLight.color.rgb * qgl_AmbientLight.intensity;
	si = vec3(0.);
	if (bitfieldExtract(flags, 0, 1) == 1) {
		for (int i = 0; i < lights_count; ++i)
			calcLight(lights_start + i, normal, v);
	} else {
		li = vec3(1.);
	}
	si *= shlick;
	li *= (1. - shlick);
	alpha = min(1., alpha * (1. + shlick));
	
	vec2 brdf = texture(tex_coeff_brdf, vec2(NdotV*0.99, roughness*0.995)).rg;
	float env_spec = shlick * brdf.x + brdf.y;
	vec3 spec_col = mix(vec3(1.), diffuse, metalness);
	vec3 env_dir = view_mat * reflect(-v, normal);
	vec3 env_col = textureLod(tex_env, env_dir, sqrt(roughness) * max_lod).rgb * spec_col;
	
	vec3 res_col = max(vec3(0.), li * diffuse + si * spec_col + emission);
	res_col = mix(res_col, env_col, env_spec * reflectivity);
	
	if (bitfieldExtract(flags, 1, 1) == 1) {
		float plen = length(pos.xyz);
		float fog = 1. - exp(-plen / fog_decay);
		fog = clamp(fog * fog_color.a * fog_density, 0., 1.);
		res_col = mix(res_col, fog_color.rgb, fog);
	}
	
	qgl_FragColor = vec4(res_col, alpha);
	//qgl_FragColor = vec4(diffuse.rgb, 0.25);
	//qgl_FragColor.a = alpha;
	//qgl_FragColor.rgb = vec3(geom_normal.rgb);
	//qgl_FragColor.rgba = vec4(vec3(0), 0.5);
	
#ifdef SPOT
	//vec4 shp = mapScreenToShadow(0, vec3(0));
	//shp.xy /= shp.w;
	//float depth = texture(tex_depths_cone, vec3(shp.xy, 0)).r;
	////depth = 1 / (1 - depth) - 1 + z_near;
	//float dz = max(0, shp.z - depth);
	//shp.z -= bias;
	//for (int xi = -2; xi <= 2; ++xi) {
	//	for (int yi = -2; yi <= 2; ++yi) {
	//qgl_FragColor.rgb = vec3(step(shp.z, texture(tex_shadows_cone, vec3(shp.xy, 0)).r));
	//qgl_FragColor.r = texture(tex_shadows_cone, vec3(0)).r;
	//qgl_FragColor.rgb = vec3(abs(depth)	+ 1);
	//float _d = texture(tex_depths_cone, vec3(shp.xy, 0)).r;
	//_d = 1 / (1 - _d) - 1 + z_near;
	//qgl_FragColor.rgb = vec3(texelFetch(tex_noise, tc % noise_size, 0).b);//vec4(res_col, alpha);
			
	//shp.z += 0.095;
	//qgl_FragColor.rgb = vec3(texture(tex_sh, shp.xy).rgb);
	//qgl_FragColor.rgb = vec3(textureProj(tex_shadow[0], shp));
	//vec4 rp = qgl_ViewProjMatrix*vec4(qgl_FragTexture.xy,z,1);
	//qgl_FragColor.rgb = vec3(texture(tex_shadows_cone, vec3(gl_FragCoord.xy/1000, 0)).r);
#else
	//vec3 odir = -(view_mat * ldir);
	//float otex = texture(tex_shadows_omni, vec4(odir, 0), 0.8);
	//qgl_FragColor.rgb = vec3(otex);
	//qgl_FragColor.rgb = vec3(ldist/50);
	//qgl_FragColor.rgb = vec3(abs(otex - ldist) * 1.);
	//qgl_FragColor.rgb = vec3(tan((1-abs(dot(view_mat*normal, odir)))));
#endif
	
	//vec3 specular = prefilteredColor * (F * envBRDF.x + envBRDF.y);
	//qgl_FragColor.rgb = vec3(shlick * brdf.x + brdf.y);
	//qgl_FragColor.rgb = vec3(alpha);
	//qgl_FragColor.rgb = vec3(textureLod(tex_env, world_dir, 0).rgb);
	//qgl_FragColor.a = 1.;
}