#version 120
/* DRAWBUFFERS:34 */

#define gbuffers_shadows
#define composite0
#define composite2
#define lightingColors
#include "shaders.settings"

varying vec2 texcoord;
varying vec3 lightColor;
varying vec3 sunVec;
varying vec3 upVec;
varying vec3 sky1;
varying vec3 sky2;

varying float tr;

varying vec2 lightPos;

varying vec3 sunlight;
varying vec3 nsunlight;

varying vec3 rawAvg;

varying float SdotU;
varying float sunVisibility;
varying float moonVisibility;

uniform sampler2D depthtex0;
uniform sampler2D depthtex1;
uniform sampler2D colortex0;
uniform sampler2D colortex1;
uniform sampler2D colortex2;
uniform sampler2D composite;

#ifdef HandLight
uniform int heldBlockLightValue;
uniform int heldBlockLightValue2;
#endif

#if defined Shadows || defined Volumetric_Lighting
uniform sampler2DShadow shadow;		//shadows
#endif

#ifdef Shadows
uniform sampler2DShadow shadowtex1; //colored shadows
uniform sampler2D shadowcolor0;
#endif

uniform vec3 sunPosition;
uniform mat4 gbufferProjection;
uniform mat4 gbufferProjectionInverse;
uniform mat4 gbufferModelViewInverse;
uniform mat4 shadowModelView;
uniform mat4 shadowProjection;
uniform ivec2 eyeBrightnessSmooth;
uniform int isEyeInWater;
uniform int worldTime;
uniform float aspectRatio;
uniform float near;
uniform float far;
uniform float viewWidth;
uniform float viewHeight;
uniform float rainStrength;
uniform ivec2 eyeBrightness;
uniform float nightVision;
uniform vec3 shadowLightPosition;
uniform float frameTimeCounter;

float comp = 1.0-near/far/far;			//distance above that are considered as sky

const vec2 check_offsets[25] = vec2[25](vec2(-0.4894566f,-0.3586783f),
									vec2(-0.1717194f,0.6272162f),
									vec2(-0.4709477f,-0.01774091f),
									vec2(-0.9910634f,0.03831699f),
									vec2(-0.2101292f,0.2034733f),
									vec2(-0.7889516f,-0.5671548f),
									vec2(-0.1037751f,-0.1583221f),
									vec2(-0.5728408f,0.3416965f),
									vec2(-0.1863332f,0.5697952f),
									vec2(0.3561834f,0.007138769f),
									vec2(0.2868255f,-0.5463203f),
									vec2(-0.4640967f,-0.8804076f),
									vec2(0.1969438f,0.6236954f),
									vec2(0.6999109f,0.6357007f),
									vec2(-0.3462536f,0.8966291f),
									vec2(0.172607f,0.2832828f),
									vec2(0.4149241f,0.8816f),
									vec2(0.136898f,-0.9716249f),
									vec2(-0.6272043f,0.6721309f),
									vec2(-0.8974028f,0.4271871f),
									vec2(0.5551881f,0.324069f),
									vec2(0.9487136f,0.2605085f),
									vec2(0.7140148f,-0.312601f),
									vec2(0.0440252f,0.9363738f),
									vec2(0.620311f,-0.6673451f)
									);

#define diagonal3(mat) vec3((mat)[0].x, (mat)[1].y, (mat)[2].z)

#ifdef Shadows
	#if defined Penumbra && defined MC_GL_VENDOR_NVIDIA && defined MC_OS_WINDOWS
		#extension GL_EXT_gpu_shader4 : enable
		#define ffstep(x,y) clamp((y - x) * 1e35,0.0,1.0)
		uniform sampler2D shadowtex0; //This is actually the same as shadow2Dsampler shadow, but nvidia allows different sampler types per texture unit.		
	#endif

vec2 tapLocation(int sampleNumber, int nb, float jitter){
    float alpha = (sampleNumber+jitter)/nb;
    float angle = jitter*6.28 + alpha * 4.0 * 6.28;
    return vec2(cos(angle), sin(angle))*sqrt(alpha);
}
#endif

vec3 nvec3(vec4 pos) {
    return pos.xyz/pos.w;
}

#ifndef Volumetric_Lighting
#ifdef Godrays
float cdist(vec2 coord) {
	vec2 vec = abs(coord*2.0-1.0);
	float d = max(vec.x,vec.y);
	return 1.0 - d*d;
}
#endif
#endif

vec3 getSkyColor(vec3 fposition) {
const vec3 moonlightS = vec3(0.00575, 0.0105, 0.014);
vec3 sVector = normalize(fposition);

float invRain07 = 1.0-rainStrength*0.4;
float cosT = dot(sVector,upVec);
float mCosT = max(cosT,0.0);
float absCosT = 1.0-max(cosT*0.82+0.26,0.2);
float cosY = dot(sunVec,sVector);
float Y = acos(cosY);

const float a = -1.;
const float b = -0.22;
const float c = 8.0;
const float d = -3.5;
const float e = 0.3;

//luminance
float L =  (1.0+a*exp(b/(mCosT)));
float A = 1.0+e*cosY*cosY;

//gradient
vec3 grad1 = mix(sky1,sky2,absCosT*absCosT);
float sunscat = max(cosY,0.0);
vec3 grad3 = mix(grad1,nsunlight*(1.0-isEyeInWater),sunscat*sunscat*(1.0-mCosT)*(0.9-rainStrength*0.5*0.9)*(clamp(-(SdotU)*4.0+3.0,0.0,1.0)*0.65+0.35)+0.1);

float Y2 = 3.14159265359-Y;
float L2 = L * (8.0*exp(d*Y2)+A);

const vec3 moonlight2 = pow(normalize(moonlightS),vec3(3.0))*length(moonlightS);
const vec3 moonlightRain = normalize(vec3(0.25,0.3,0.4))*length(moonlightS);

vec3 gradN = mix(moonlightS,moonlight2,1.-L2/2.0);
gradN = mix(gradN,moonlightRain,rainStrength);
return pow(L*(c*exp(d*Y)+A),invRain07)*sunVisibility *length(rawAvg) * (0.85+rainStrength*0.425)*grad3+ 0.2*pow(L2*1.2+1.2,invRain07)*moonVisibility*gradN;
}

vec3 decode (vec2 enc){
    vec2 fenc = enc*4-2;
    float f = dot(fenc,fenc);
    float g = sqrt(1-f/4.0);
    vec3 n;
    n.xy = fenc*g;
    n.z = 1-f/2;
    return n;
}


#ifdef Lens_Flares
void LensFlare(inout vec3 color){
	vec2 ntc2 = texcoord*2.0-1.0;
	vec2 lPos = lightPos;
	  
	float sunmask = 1.0;
		  sunmask *= (1.0 - rainStrength);

	if (sunmask > 0.02){
	vec3 lenslc = sqrt(lightColor);
	//Adjust global flare settings
	float flaremultR = 0.04*lenslc.r;
	float flaremultG = 0.05*lenslc.g;
	float flaremultB = 0.075*lenslc.b;
	float flarescale = 1.0;
/*-------------------------------*/

	//Small sun glare/glow
		vec2 flare1scale = vec2(1.7*flarescale, 1.7*flarescale);
		float flare1pow = 12.0;
		vec2 flare1pos = vec2(lPos.x*aspectRatio*flare1scale.x, lPos.y*flare1scale.y);

		float flare1 = distance(flare1pos, vec2(ntc2.s*aspectRatio*flare1scale.x, ntc2.t*flare1scale.y));
              flare1 = 0.5 - flare1;
              flare1 = clamp(flare1, 0.0, 10.0)  ;
              flare1 *= sunmask;
              flare1 = pow(flare1, 1.8);

              flare1 *= flare1pow;
if(sunVisibility > 0.2){
			  color.r += flare1*1.0*flaremultR;
			  color.g += flare1*0.1*flaremultG;
			  color.b += flare1*0.0*flaremultB;
} else {
			  color.r += flare1*0.0*flaremultR;
			  color.g += flare1*0.1*flaremultG;
			  color.b += flare1*0.5*flaremultB;
}

	/*//Huge sun glare/glow
		vec2 flare1Bscale = vec2(0.5*flarescale, 0.5*flarescale);
		float flare1Bpow = 6.0;
		vec2 flare1Bpos = vec2(lPos.x*aspectRatio*flare1Bscale.x, lPos.y*flare1Bscale.y);

		float flare1B = distance(flare1Bpos, vec2(ntc2.s*aspectRatio*flare1Bscale.x, ntc2.t*flare1Bscale.y));
              flare1B = 0.5 - flare1B;
              flare1B = clamp(flare1B, 0.0, 10.0)  ;
              flare1B *= sunmask;
              flare1B = pow(flare1B, 1.8);

			  flare1B *= flare1Bpow;

			  color.r += flare1B*1.0*flaremultR;
			  color.g += flare1B*0.1*flaremultG;
			  color.b += flare1B*0.0*flaremultB;
	/*----------------------------------------------------------*/

	//Far blue flare MAIN
		vec2 flare3scale = vec2(2.0*flarescale, 2.0*flarescale);
		float flare3pow = 0.7;
		float flare3fill = 10.0;
		float flare3offset = -0.5;
		vec2 flare3pos = vec2(  ((1.0 - lPos.x)*(flare3offset + 1.0) - (flare3offset*0.5))  *aspectRatio*flare3scale.x,  ((1.0 - lPos.y)*(flare3offset + 1.0) - (flare3offset*0.5))  *flare3scale.y);

		float flare3 = distance(flare3pos, vec2(ntc2.s*aspectRatio*flare3scale.x, ntc2.t*flare3scale.y));
              flare3 = 0.5 - flare3;
              flare3 = clamp(flare3*flare3fill, 0.0, 1.0)  ;
              flare3 = sin(flare3*1.57075);
              flare3 *= sunmask;
              flare3 = pow(flare3, 1.1);

              flare3 *= flare3pow;

	//subtract from blue flare
		vec2 flare3Bscale = vec2(1.4*flarescale, 1.4*flarescale);
		float flare3Bpow = 1.0;
		float flare3Bfill = 2.0;
		float flare3Boffset = -0.65f;
		vec2 flare3Bpos = vec2(  ((1.0 - lPos.x)*(flare3Boffset + 1.0) - (flare3Boffset*0.5))  *aspectRatio*flare3Bscale.x,  ((1.0 - lPos.y)*(flare3Boffset + 1.0) - (flare3Boffset*0.5))  *flare3Bscale.y);

		float flare3B = distance(flare3Bpos, vec2(ntc2.s*aspectRatio*flare3Bscale.x, ntc2.t*flare3Bscale.y));
              flare3B = 0.5 - flare3B;
              flare3B = clamp(flare3B*flare3Bfill, 0.0, 1.0)  ;
              flare3B = sin(flare3B*1.57075);
              flare3B *= sunmask;
              flare3B = pow(flare3B, 0.9);

              flare3B *= flare3Bpow;

              flare3 = clamp(flare3 - flare3B, 0.0, 10.0);

              color.r += flare3*0.5*flaremultR;
              color.g += flare3*0.3*flaremultG;
              color.b += flare3*1.0*flaremultB;
	/*--------------------------------------------------------------------------*/

	//Far blue flare MAIN 2
		vec2 flare3Cscale = vec2(3.2*flarescale, 3.2*flarescale);
		float flare3Cpow = 1.4;
		float flare3Cfill = 10.0;
		float flare3Coffset = -0.0;
		vec2 flare3Cpos = vec2(  ((1.0 - lPos.x)*(flare3Coffset + 1.0) - (flare3Coffset*0.5))  *aspectRatio*flare3Cscale.x,  ((1.0 - lPos.y)*(flare3Coffset + 1.0) - (flare3Coffset*0.5))  *flare3Cscale.y);


		float flare3C = distance(flare3Cpos, vec2(ntc2.s*aspectRatio*flare3Cscale.x, ntc2.t*flare3Cscale.y));
              flare3C = 0.5 - flare3C;
              flare3C = clamp(flare3C*flare3Cfill, 0.0, 1.0)  ;
              flare3C = sin(flare3C*1.57075);

              flare3C = pow(flare3C, 1.1);

              flare3C *= flare3Cpow;

	//subtract from blue flare
		vec2 flare3Dscale = vec2(2.1*flarescale, 2.1*flarescale);
		float flare3Dpow = 2.7;
		float flare3Dfill = 1.4;
		float flare3Doffset = -0.05f;
		vec2 flare3Dpos = vec2(  ((1.0 - lPos.x)*(flare3Doffset + 1.0) - (flare3Doffset*0.5))  *aspectRatio*flare3Dscale.x,  ((1.0 - lPos.y)*(flare3Doffset + 1.0) - (flare3Doffset*0.5))  *flare3Dscale.y);

		float flare3D = distance(flare3Dpos, vec2(ntc2.s*aspectRatio*flare3Dscale.x, ntc2.t*flare3Dscale.y));
              flare3D = 0.5 - flare3D;
              flare3D = clamp(flare3D*flare3Dfill, 0.0, 1.0)  ;
              flare3D = sin(flare3D*1.57075);
              flare3D = pow(flare3D, 0.9);

              flare3D *= flare3Dpow;

              flare3C = clamp(flare3C - flare3D, 0.0, 10.0);
              flare3C *= sunmask;

              color.r += flare3C*0.5*flaremultR;
              color.g += flare3C*0.3*flaremultG;
              color.b += flare3C*1.0*flaremultB;
	/*--------------------------------------------------------------------*/

	//far small pink flare
		vec2 flare4scale = vec2(4.5*flarescale, 4.5*flarescale);
		float flare4pow = 0.3;
		float flare4fill = 3.0;
		float flare4offset = -0.1;
		vec2 flare4pos = vec2(  ((1.0 - lPos.x)*(flare4offset + 1.0) - (flare4offset*0.5))  *aspectRatio*flare4scale.x,  ((1.0 - lPos.y)*(flare4offset + 1.0) - (flare4offset*0.5))  *flare4scale.y);


		float flare4 = distance(flare4pos, vec2(ntc2.s*aspectRatio*flare4scale.x, ntc2.t*flare4scale.y));
              flare4 = 0.5 - flare4;
              flare4 = clamp(flare4*flare4fill, 0.0, 1.0)  ;
              flare4 = sin(flare4*1.57075);
              flare4 *= sunmask;
              flare4 = pow(flare4, 1.1);

              flare4 *= flare4pow;

              color.r += flare4*1.6*flaremultR;
              color.g += flare4*0.0*flaremultG;
              color.b += flare4*1.8*flaremultB;
	/*---------------------------------------------------------------*/

	//far small pink flare2
		vec2 flare4Bscale = vec2(7.5*flarescale, 7.5*flarescale);
		float flare4Bpow = 0.4;
		float flare4Bfill = 2.0;
		float flare4Boffset = 0.0;
		vec2 flare4Bpos = vec2(  ((1.0 - lPos.x)*(flare4Boffset + 1.0) - (flare4Boffset*0.5))  *aspectRatio*flare4Bscale.x,  ((1.0 - lPos.y)*(flare4Boffset + 1.0) - (flare4Boffset*0.5))  *flare4Bscale.y);

		float flare4B = distance(flare4Bpos, vec2(ntc2.s*aspectRatio*flare4Bscale.x, ntc2.t*flare4Bscale.y));
              flare4B = 0.5 - flare4B;
              flare4B = clamp(flare4B*flare4Bfill, 0.0, 1.0)  ;
              flare4B = sin(flare4B*1.57075);
              flare4B *= sunmask;
              flare4B = pow(flare4B, 1.1);

              flare4B *= flare4Bpow;

              color.r += flare4B*1.4*flaremultR;
              color.g += flare4B*0.0*flaremultG;
              color.b += flare4B*1.8*flaremultB;
	/*------------------------------------------------------------*/

	//far small pink flare3
		vec2 flare4Cscale = vec2(37.5*flarescale, 37.5*flarescale);
		float flare4Cpow = 2.0;
		float flare4Cfill = 2.0;
		float flare4Coffset = -0.3;
		vec2 flare4Cpos = vec2(  ((1.0 - lPos.x)*(flare4Coffset + 1.0) - (flare4Coffset*0.5))  *aspectRatio*flare4Cscale.x,  ((1.0 - lPos.y)*(flare4Coffset + 1.0) - (flare4Coffset*0.5))  *flare4Cscale.y);

		float flare4C = distance(flare4Cpos, vec2(ntc2.s*aspectRatio*flare4Cscale.x, ntc2.t*flare4Cscale.y));
              flare4C = 0.5 - flare4C;
              flare4C = clamp(flare4C*flare4Cfill, 0.0, 1.0)  ;
              flare4C = sin(flare4C*1.57075);
              flare4C *= sunmask;
              flare4C = pow(flare4C, 1.1);

              flare4C *= flare4Cpow;

              color.r += flare4C*1.6*flaremultR;
              color.g += flare4C*0.3*flaremultG;
              color.b += flare4C*1.1*flaremultB;
	/*----------------------------------------------------------------------------*/
			  
	//far small pink flare4
		vec2 flare4Dscale = vec2(67.5*flarescale, 67.5*flarescale);
		float flare4Dpow = 1.0;
		float flare4Dfill = 2.0;
		float flare4Doffset = -0.35f;
		vec2 flare4Dpos = vec2(  ((1.0 - lPos.x)*(flare4Doffset + 1.0) - (flare4Doffset*0.5))  *aspectRatio*flare4Dscale.x,  ((1.0 - lPos.y)*(flare4Doffset + 1.0) - (flare4Doffset*0.5))  *flare4Dscale.y);

		float flare4D = distance(flare4Dpos, vec2(ntc2.s*aspectRatio*flare4Dscale.x, ntc2.t*flare4Dscale.y));
			  flare4D = 0.5 - flare4D;
              flare4D = clamp(flare4D*flare4Dfill, 0.0, 1.0)  ;
              flare4D = sin(flare4D*1.57075);
              flare4D *= sunmask;
              flare4D = pow(flare4D, 1.1);

              flare4D *= flare4Dpow;

			  color.r += flare4D*1.2*flaremultR;
			  color.g += flare4D*0.2*flaremultG;
			  color.b += flare4D*1.2*flaremultB;
	/*------------------------------------------------------------------*/

	//far small pink flare5
		vec2 flare4Escale = vec2(60.5*flarescale, 60.5*flarescale);
		float flare4Epow = 1.0;
		float flare4Efill = 3.0;
		float flare4Eoffset = -0.3393f;
		vec2 flare4Epos = vec2(  ((1.0 - lPos.x)*(flare4Eoffset + 1.0) - (flare4Eoffset*0.5))  *aspectRatio*flare4Escale.x,  ((1.0 - lPos.y)*(flare4Eoffset + 1.0) - (flare4Eoffset*0.5))  *flare4Escale.y);

		float flare4E = distance(flare4Epos, vec2(ntc2.s*aspectRatio*flare4Escale.x, ntc2.t*flare4Escale.y));
              flare4E = 0.5 - flare4E;
              flare4E = clamp(flare4E*flare4Efill, 0.0, 1.0)  ;
              flare4E = sin(flare4E*1.57075);
              flare4E *= sunmask;
              flare4E = pow(flare4E, 1.1);

			  flare4E *= flare4Epow;

			  color.r += flare4E*1.2*flaremultR;
			  color.g += flare4E*0.2*flaremultG;
			  color.b += flare4E*1.0*flaremultB;
	/*----------------------------------------------------------*/

	//Sun glow
		vec2 flare5scale = vec2(3.2*flarescale , 3.2*flarescale );
		float flare5pow = 13.4;
		float flare5fill = 1.0;
		float flare5offset = -2.0;
		vec2 flare5pos = vec2(  ((1.0 - lPos.x)*(flare5offset + 1.0) - (flare5offset*0.5))  *aspectRatio*flare5scale.x,  ((1.0 - lPos.y)*(flare5offset + 1.0) - (flare5offset*0.5))  *flare5scale.y);

		float flare5 = distance(flare5pos, vec2(ntc2.s*aspectRatio*flare5scale.x, ntc2.t*flare5scale.y));
              flare5 = 0.5 - flare5;
              flare5 = clamp(flare5*flare5fill, 0.0, 1.0)  ;
              flare5 *= sunmask;
              flare5 = pow(flare5, 1.9);

              flare5 *= flare5pow;

			  color.r += flare5*2.0*flaremultR;
			  color.g += flare5*0.4*flaremultG;
			  color.b += flare5*0.1*flaremultB;
	/*-----------------------------------------------------*/
	
	//Anamorphic lens
		vec2 flareEscale = vec2(0.2*flarescale, 5.0*flarescale);
		float flareEpow = 5.0;
		float flareEfill = 0.75;
		vec2 flareEpos = vec2(lPos.x*aspectRatio*flareEscale.x, lPos.y*flareEscale.y);

		float flareE = distance(flareEpos, vec2(ntc2.s*aspectRatio*flareEscale.x, ntc2.t*flareEscale.y));
			  flareE = 0.5 - flareE;
			  flareE = clamp(flareE*flareEfill, 0.0, 1.0)  ;
			  flareE *= sunmask;
			  flareE = pow(flareE, 1.4);
			  flareE *= flareEpow;

			  color.r += flareE*0.0*flaremultR;
			  color.g += flareE*0.05*flaremultG;
			  color.b += flareE*1.0*flaremultB;
	/*----------------------------------------------*/

	//first red sweep
		vec2 flare_extra3scale = vec2(32.0*flarescale, 32.0*flarescale);
		float flare_extra3pow = 2.5;
		float flare_extra3fill = 1.1;
		float flare_extra3offset = -1.3;
		vec2 flare_extra3pos = vec2(  ((1.0 - lPos.x)*(flare_extra3offset + 1.0) - (flare_extra3offset*0.5))  *aspectRatio*flare_extra3scale.x,  ((1.0 - lPos.y)*(flare_extra3offset + 1.0) - (flare_extra3offset*0.5))  *flare_extra3scale.y);


		float flare_extra3 = distance(flare_extra3pos, vec2(ntc2.s*aspectRatio*flare_extra3scale.x, ntc2.t*flare_extra3scale.y));
              flare_extra3 = 0.5 - flare_extra3;
              flare_extra3 = clamp(flare_extra3*flare_extra3fill, 0.0, 1.0)  ;
              flare_extra3 = sin(flare_extra3*1.57075);
              flare_extra3 *= sunmask;
              flare_extra3 = pow(flare_extra3, 1.1);

              flare_extra3 *= flare_extra3pow;

		//subtract
		vec2 flare_extra3Bscale = vec2(5.1*flarescale, 5.1*flarescale);
		float flare_extra3Bpow = 1.5;
		float flare_extra3Bfill = 1.0;
		float flare_extra3Boffset = -0.77f;
		vec2 flare_extra3Bpos = vec2(  ((1.0 - lPos.x)*(flare_extra3Boffset + 1.0) - (flare_extra3Boffset*0.5))  *aspectRatio*flare_extra3Bscale.x,  ((1.0 - lPos.y)*(flare_extra3Boffset + 1.0) - (flare_extra3Boffset*0.5))  *flare_extra3Bscale.y);

		float flare_extra3B = distance(flare_extra3Bpos, vec2(ntc2.s*aspectRatio*flare_extra3Bscale.x, ntc2.t*flare_extra3Bscale.y));
              flare_extra3B = 0.5 - flare_extra3B;
              flare_extra3B = clamp(flare_extra3B*flare_extra3Bfill, 0.0, 1.0)  ;
              flare_extra3B = sin(flare_extra3B*1.57075);
              flare_extra3B *= sunmask;
              flare_extra3B = pow(flare_extra3B, 0.9);

              flare_extra3B *= flare_extra3Bpow;

              flare_extra3 = clamp(flare_extra3 - flare_extra3B, 0.0, 10.0);

			  color.r += flare_extra3*1.0*flaremultR;
			  color.g += flare_extra3*0.0*flaremultG;
			  color.b += flare_extra3*0.2*flaremultB;
	/*--------------------------------------------------------------------------*/

	//mid purple sweep
		vec2 flare_extra4scale = vec2(35.0*flarescale, 35.0*flarescale);
		float flare_extra4pow = 1.0;
		float flare_extra4fill = 1.1;
		float flare_extra4offset = -1.2;
		vec2 flare_extra4pos = vec2(  ((1.0 - lPos.x)*(flare_extra4offset + 1.0) - (flare_extra4offset*0.5))  *aspectRatio*flare_extra4scale.x,  ((1.0 - lPos.y)*(flare_extra4offset + 1.0) - (flare_extra4offset*0.5))  *flare_extra4scale.y);


		float flare_extra4 = distance(flare_extra4pos, vec2(ntc2.s*aspectRatio*flare_extra4scale.x, ntc2.t*flare_extra4scale.y));
              flare_extra4 = 0.5 - flare_extra4;
              flare_extra4 = clamp(flare_extra4*flare_extra4fill, 0.0, 1.0)  ;
              flare_extra4 = sin(flare_extra4*1.57075);
              flare_extra4 *= sunmask;
              flare_extra4 = pow(flare_extra4, 1.1);

              flare_extra4 *= flare_extra4pow;


		//subtract
		vec2 flare_extra4Bscale = vec2(5.1*flarescale, 5.1*flarescale);
		float flare_extra4Bpow = 1.5;
		float flare_extra4Bfill = 1.0;
		float flare_extra4Boffset = -0.77f;
		vec2 flare_extra4Bpos = vec2(  ((1.0 - lPos.x)*(flare_extra4Boffset + 1.0) - (flare_extra4Boffset*0.5))  *aspectRatio*flare_extra4Bscale.x,  ((1.0 - lPos.y)*(flare_extra4Boffset + 1.0) - (flare_extra4Boffset*0.5))  *flare_extra4Bscale.y);


		float flare_extra4B = distance(flare_extra4Bpos, vec2(ntc2.s*aspectRatio*flare_extra4Bscale.x, ntc2.t*flare_extra4Bscale.y));
			  flare_extra4B = 0.5 - flare_extra4B;
			  flare_extra4B = clamp(flare_extra4B*flare_extra4Bfill, 0.0, 1.0)  ;
			  flare_extra4B = sin(flare_extra4B*1.57075);
			  flare_extra4B *= sunmask;
			  flare_extra4B = pow(flare_extra4B, 0.9);

			  flare_extra4B *= flare_extra4Bpow;

			  flare_extra4 = clamp(flare_extra4 - flare_extra4B, 0.0, 10.0);

			  color.r += flare_extra4*0.7*flaremultR;
			  color.g += flare_extra4*0.1*flaremultG;
			  color.b += flare_extra4*1.0*flaremultB;
	/*----------------------------------------------------------------------------*/

	//last blue/purple sweep
		vec2 flare_extra5scale = vec2(25.0*flarescale, 25.0*flarescale);
		float flare_extra5pow = 4.0;
		float flare_extra5fill = 1.1;
		float flare_extra5offset = -0.9;
		vec2 flare_extra5pos = vec2(  ((1.0 - lPos.x)*(flare_extra5offset + 1.0) - (flare_extra5offset*0.5))  *aspectRatio*flare_extra5scale.x,  ((1.0 - lPos.y)*(flare_extra5offset + 1.0) - (flare_extra5offset*0.5))  *flare_extra5scale.y);

		float flare_extra5 = distance(flare_extra5pos, vec2(ntc2.s*aspectRatio*flare_extra5scale.x, ntc2.t*flare_extra5scale.y));
              flare_extra5 = 0.5 - flare_extra5;
              flare_extra5 = clamp(flare_extra5*flare_extra5fill, 0.0, 1.0)  ;
              flare_extra5 = sin(flare_extra5*1.57075);
              flare_extra5 *= sunmask;
              flare_extra5 = pow(flare_extra5, 1.1);

              flare_extra5 *= flare_extra5pow;

		//subtract
		vec2 flare_extra5Bscale = vec2(5.1*flarescale, 5.1*flarescale);
		float flare_extra5Bpow = 1.0;
		float flare_extra5Bfill = 1.0;
		float flare_extra5Boffset = -0.77f;
		vec2 flare_extra5Bpos = vec2(  ((1.0 - lPos.x)*(flare_extra5Boffset + 1.0) - (flare_extra5Boffset*0.5))  *aspectRatio*flare_extra5Bscale.x,  ((1.0 - lPos.y)*(flare_extra5Boffset + 1.0) - (flare_extra5Boffset*0.5))  *flare_extra5Bscale.y);

		float flare_extra5B = distance(flare_extra5Bpos, vec2(ntc2.s*aspectRatio*flare_extra5Bscale.x, ntc2.t*flare_extra5Bscale.y));
			  flare_extra5B = 0.5 - flare_extra5B;
			  flare_extra5B = clamp(flare_extra5B*flare_extra5Bfill, 0.0, 1.0)  ;
			  flare_extra5B = sin(flare_extra5B*1.57075);
			  flare_extra5B *= sunmask;
			  flare_extra5B = pow(flare_extra5B, 0.9);

			  flare_extra5B *= flare_extra5Bpow;

			  flare_extra5 = clamp(flare_extra5 - flare_extra5B, 0.0, 10.0);

			  color.r += flare_extra5*0.2*flaremultR;
			  color.g += flare_extra5*0.1*flaremultG;
			  color.b += flare_extra5*0.6*flaremultB;
	/*----------------------------------------------------------------------*/

	//mid orange sweep
		vec2 flare10scale = vec2(6.0*flarescale, 6.0*flarescale);
		float flare10pow = 1.9;
		float flare10fill = 1.1;
		float flare10offset = -0.7;
		vec2 flare10pos = vec2(  ((1.0 - lPos.x)*(flare10offset + 1.0) - (flare10offset*0.5))  *aspectRatio*flare10scale.x,  ((1.0 - lPos.y)*(flare10offset + 1.0) - (flare10offset*0.5))  *flare10scale.y);


		float flare10 = distance(flare10pos, vec2(ntc2.s*aspectRatio*flare10scale.x, ntc2.t*flare10scale.y));
              flare10 = 0.5 - flare10;
              flare10 = clamp(flare10*flare10fill, 0.0, 1.0)  ;
              flare10 = sin(flare10*1.57075);
              flare10 *= sunmask;
              flare10 = pow(flare10, 1.1);

              flare10 *= flare10pow;

		//subtract
		vec2 flare10Bscale = vec2(5.1*flarescale, 5.1*flarescale);
		float flare10Bpow = 1.5;
		float flare10Bfill = 1.0;
		float flare10Boffset = -0.77f;
		vec2 flare10Bpos = vec2(  ((1.0 - lPos.x)*(flare10Boffset + 1.0) - (flare10Boffset*0.5))  *aspectRatio*flare10Bscale.x,  ((1.0 - lPos.y)*(flare10Boffset + 1.0) - (flare10Boffset*0.5))  *flare10Bscale.y);

		float flare10B = distance(flare10Bpos, vec2(ntc2.s*aspectRatio*flare10Bscale.x, ntc2.t*flare10Bscale.y));
              flare10B = 0.5 - flare10B;
              flare10B = clamp(flare10B*flare10Bfill, 0.0, 1.0)  ;
              flare10B = sin(flare10B*1.57075);
              flare10B *= sunmask;
              flare10B = pow(flare10B, 0.9);

              flare10B *= flare10Bpow;

              flare10 = clamp(flare10 - flare10B, 0.0, 10.0);

			  color.r += flare10*0.5*flaremultR;
			  color.g += flare10*0.3*flaremultG;
			  color.b += flare10*0.0*flaremultB;
	/*-----------------------------------------------------------------------------*/

	//mid blue sweep
		vec2 flare10Cscale = vec2(6.0*flarescale, 6.0*flarescale);
		float flare10Cpow = 1.9;
		float flare10Cfill = 1.1;
		float flare10Coffset = -0.6;
		vec2 flare10Cpos = vec2(  ((1.0 - lPos.x)*(flare10Coffset + 1.0) - (flare10Coffset*0.5))  *aspectRatio*flare10Cscale.x,  ((1.0 - lPos.y)*(flare10Coffset + 1.0) - (flare10Coffset*0.5))  *flare10Cscale.y);

		float flare10C = distance(flare10Cpos, vec2(ntc2.s*aspectRatio*flare10Cscale.x, ntc2.t*flare10Cscale.y));
              flare10C = 0.5 - flare10C;
              flare10C = clamp(flare10C*flare10Cfill, 0.0, 1.0)  ;
              flare10C = sin(flare10C*1.57075);
              flare10C *= sunmask;
              flare10C = pow(flare10C, 1.1);

              flare10C *= flare10Cpow;

		//subtract
		vec2 flare10Dscale = vec2(5.1*flarescale, 5.1*flarescale);
		float flare10Dpow = 1.5;
		float flare10Dfill = 1.0;
		float flare10Doffset = -0.67f;
		vec2 flare10Dpos = vec2(  ((1.0 - lPos.x)*(flare10Doffset + 1.0) - (flare10Doffset*0.5))  *aspectRatio*flare10Dscale.x,  ((1.0 - lPos.y)*(flare10Doffset + 1.0) - (flare10Doffset*0.5))  *flare10Dscale.y);

			float flare10D = distance(flare10Dpos, vec2(ntc2.s*aspectRatio*flare10Dscale.x, ntc2.t*flare10Dscale.y));
			  flare10D = 0.5 - flare10D;
			  flare10D = clamp(flare10D*flare10Dfill, 0.0, 1.0)  ;
			  flare10D = sin(flare10D*1.57075);
			  flare10D *= sunmask;
			  flare10D = pow(flare10D, 0.9);

			  flare10D *= flare10Dpow;

			  flare10C = clamp(flare10C - flare10D, 0.0, 10.0);

			  color.r += flare10C*0.5*flaremultR;
			  color.g += flare10C*0.3*flaremultG;
			  color.b += flare10C*1.0*flaremultB;
	/*--------------------------------------------------------------------------------------*/
        
	//RedGlow1
        vec2 flare11scale = vec2(1.5*flarescale, 1.5*flarescale);
        float flare11pow = 1.1;
        float flare11fill = 2.0;
        float flare11offset = -0.523f;
        vec2 flare11pos = vec2(  ((1.0 - lPos.x)*(flare11offset + 1.0) - (flare11offset*0.5))  *aspectRatio*flare11scale.x,  ((1.0 - lPos.y)*(flare11offset + 1.0) - (flare11offset*0.5))  *flare11scale.y);

        float flare11 = distance(flare11pos, vec2(ntc2.s*aspectRatio*flare11scale.x, ntc2.t*flare11scale.y));
              flare11 = 0.5 - flare11;
              flare11 = clamp(flare11*flare11fill, 0.0, 1.0)  ;
              flare11 = pow(flare11, 2.9);
              flare11 *= sunmask;

              flare11 *= flare11pow;

              color.r += flare11*1.0*flaremultR;
              color.g += flare11*0.2*flaremultG;
              color.b += flare11*0.0*flaremultB;
	/*------------------------------------------------------------------*/
		
	//PurpleGlow2
        vec2 flare12scale = vec2(2.5*flarescale, 2.5*flarescale);
        float flare12pow = 0.5;
        float flare12fill = 2.0;
        float flare12offset = -0.323f;
        vec2 flare12pos = vec2(  ((1.0 - lPos.x)*(flare12offset + 1.0) - (flare12offset*0.5))  *aspectRatio*flare12scale.x,  ((1.0 - lPos.y)*(flare12offset + 1.0) - (flare12offset*0.5))  *flare12scale.y);

        float flare12 = distance(flare12pos, vec2(ntc2.s*aspectRatio*flare12scale.x, ntc2.t*flare12scale.y));
              flare12 = 0.5 - flare12;
              flare12 = clamp(flare12*flare12fill, 0.0, 1.0)  ;
              flare12 = pow(flare12, 2.9);
              flare12 *= sunmask;

              flare12 *= flare12pow;

              color.r += flare12*0.7*flaremultR;
              color.g += flare12*0.0*flaremultG;
              color.b += flare12*1.0*flaremultB;
	/*------------------------------------------------------------------*/

	//BlueGlow3
        vec2 flare13scale = vec2(1.0*flarescale, 1.0*flarescale);
        float flare13pow = 1.5;
        float flare13fill = 2.0;
        float flare13offset = +0.138f;
		vec2 flare13pos = vec2(  ((1.0 - lPos.x)*(flare13offset + 1.0) - (flare13offset*0.5))  *aspectRatio*flare13scale.x,  ((1.0 - lPos.y)*(flare13offset + 1.0) - (flare13offset*0.5))  *flare13scale.y);

        float flare13 = distance(flare13pos, vec2(ntc2.s*aspectRatio*flare13scale.x, ntc2.t*flare13scale.y));
              flare13 = 0.5 - flare13;
              flare13 = clamp(flare13*flare13fill, 0.0, 1.0)  ;
              flare13 = pow(flare13, 2.9);
              flare13 *= sunmask;

              flare13 *= flare13pow;

              color.r += flare13*0.0*flaremultR;
              color.g += flare13*0.2*flaremultG;
              color.b += flare13*1.0*flaremultB;
	/*-------------------------------------------------------------*/
   }
}
#endif

#if defined Volumetric_Lighting || defined raytracedShadows
float ld(float depth) {
    return (2.0 * near) / (far + near - depth * (far - near));		// (-depth * (far - near)) = (2.0 * near)/ld - far - near
}
#endif

float raysNoise(vec2 pos) {
	return fract(sin(dot(pos ,vec2(18.9898f,28.633f))) * 4378.5453f);
}

#ifdef Volumetric_Lighting
float raysCdist(vec2 coord) {
	return clamp(1.0 - max(abs(coord.s-0.5),abs(coord.t-0.5))*2.0, 0.0, 1.0);
}

vec3 screenSpace(vec2 coord, float depth){
	vec4 pos = gbufferProjectionInverse * (vec4(coord, depth, 1.0) * 2.0 - 1.0);
	return pos.xyz/pos.w;
}

vec2 Vstep = vec2(0.0,1.0)/vec2(viewWidth,viewHeight).xy;

float Vthreshs(float v1){
	float cdepth = ld(texture2D(depthtex0, texcoord.xy).x);
	return exp(-abs(texture2D(composite, texcoord + v1*Vstep).y-cdepth)*8.0);
}

float Volumetric_Light(vec2 tex){
	float weights[9] = float[9](
		0.013519569015984728,
		0.047662179108871855,
		0.11723004402070096,
		0.20116755999375591,
		0.240841295721373,
		0.20116755999375591,
		0.11723004402070096,
		0.047662179108871855,
		0.013519569015984728
	);

	float indices[9] = float[9](-4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0);
	
	float threshs[9] = float[9](
		Vthreshs(indices[0]),
		Vthreshs(indices[1]),
		Vthreshs(indices[2]),
		Vthreshs(indices[3]),
		1.0,
		Vthreshs(indices[5]),
		Vthreshs(indices[6]),
		Vthreshs(indices[7]),
		Vthreshs(indices[8])
	);
	
	float weight = 0.0;
	float Vgr = 0.0;;

	for(int i=0; i<9; ++i ){
		weight += weights[i]*threshs[i];
		Vgr += texture2D(composite, tex + indices[i]*Vstep).z * (weights[i]*threshs[i]);		
	}
	Vgr /= weight;
	
	return Vgr;
}

float getVolumetricRays() {	
		float dither = fract(0.75487765 * gl_FragCoord.x + 0.56984026 * gl_FragCoord.y);	
		#ifdef TAA  
			  dither = fract(frameTimeCounter * 128.0 + dither);	//filter using taa
		#endif
		int maxSamples = 6;
	
		const float VL_dISTANCE = 200.0;

		//setup ray in projected shadow map space
		vec4 fragposition = vec4(texcoord.xy,texture2D(depthtex0,texcoord.xy).x,1.0)*2.-1.;
		fragposition = gbufferProjectionInverse*fragposition;
		fragposition /= fragposition.w;
	
		float z = -fragposition.z;
		
		//project pixel position into projected shadowmap space
		fragposition = gbufferModelViewInverse*fragposition;
		fragposition = shadowModelView*fragposition;
		fragposition = shadowProjection*fragposition;
		
		//project view origin into projected shadowmap space
		vec4 start = gbufferModelViewInverse*vec4(0.0,0.0,0.0,1.0);
		start = (shadowModelView*start);
		start = (shadowProjection*start);
		
		//rayvector into projected shadow map space
		//we can use a projected vector because its orthographic projection
		//however we still have to send it to curved shadow map space every step
		vec3 dV = (fragposition.xyz-start.xyz)/maxSamples;
		
		//apply dither
		vec3 progress = start.xyz + dV*dither;

		float vL = 0.0;
		
		for (int i=0;i<maxSamples;i++) {
			//project into biased shadowmap space
			vec2 pos = progress.xy;
			pos = progress.xy*calcDistortion(pos.xy);

			//sample and apply fog to sample
			vL += shadow2D(shadow, vec3(pos.xy*0.5+0.5, progress.z*0.5/6.0+0.5)).z;

			//advance the ray
			progress += dV;
	}
		vL *= z/VL_dISTANCE/maxSamples;
	return vL;
}
#endif

#ifdef Celshading
float edepth(vec2 coord) {
	return texture2D(depthtex1,coord).x;
}

vec3 celshade(vec3 clrr) {
	//edge detect
	float dtresh = 1.0/(far-near) / (5000.0*Celradius);
	vec4 dc = vec4(edepth(texcoord.xy));
	vec3 border = vec3(1.0/viewWidth, 1.0/viewHeight, 0.0)*Celborder;
	vec4 sa = vec4(edepth(texcoord.xy + vec2(-border.x,-border.y)),
		 		   edepth(texcoord.xy + vec2(border.x,-border.y)),
		 		   edepth(texcoord.xy + vec2(-border.x,border.z)),
		 		   edepth(texcoord.xy + vec2(border.z,border.y)));

	//opposite side samples
	vec4 sb = vec4(edepth(texcoord.xy + vec2(border.x,border.y)),
		 		   edepth(texcoord.xy + vec2(-border.x,border.y)),
		 		   edepth(texcoord.xy + vec2(border.x,border.z)),
		 		   edepth(texcoord.xy + vec2(border.z,-border.y)));

	vec4 dd = abs(2.0* dc - sa - sb) - dtresh;
		 dd = step(dd.xyzw, vec4(0.0));

	float e = clamp(dot(dd,vec4(0.25f)),0.0,1.0);
	return clrr*e;
}
#endif

#if defined TAA || defined raytracedShadows
vec2 texelSize = vec2(1.0/viewWidth,1.0/viewHeight);
uniform int framemod8;
const vec2[8] offsets = vec2[8](vec2(1./8.,-3./8.),
								vec2(-1.,3.)/8.,
								vec2(5.0,1.)/8.,
								vec2(-3,-5.)/8.,
								vec2(-5.,5.)/8.,
								vec2(-7.,-1.)/8.,
								vec2(3,7.)/8.,
								vec2(7.,-7.)/8.);
#endif

vec3 toScreenSpace(vec3 pos) {
	vec4 iProjDiag = vec4(gbufferProjectionInverse[0].x, gbufferProjectionInverse[1].y, gbufferProjectionInverse[2].zw);
	vec3 p3 = pos * 2.0 - 1.0;
    vec4 fragposition = iProjDiag * p3.xyzz + gbufferProjectionInverse[3];
    return fragposition.xyz / fragposition.w;
}

#ifdef SSDO
//modified version of Yuriy O'Donnell's SSDO (License MIT -> https://github.com/kayru/dssdo)
float calcSSDO(vec3 fragpos, vec3 normal){
	float finalAO = 0.0;

	float radius = 0.05 / (fragpos.z);
	const float attenuation_angle_threshold = 0.1;
	const int num_samples = 16;	
	const float ao_weight = 1.0;
	#ifdef TAA
	float noise = fract(0.75487765 * gl_FragCoord.x + 0.56984026 * gl_FragCoord.y);
		  noise = fract(frameTimeCounter * 2.0 + noise);
	#else
	float noise = 1.0;
	#endif	

	for( int i=0; i<num_samples; ++i ){
	    vec2 texOffset = pow(length(check_offsets[i].xy),0.5)*radius*vec2(1.0,aspectRatio)*normalize(check_offsets[i].xy);
		vec2 newTC = texcoord+texOffset*noise;
	#ifdef TAA
		vec3 t0 = toScreenSpace(vec3(newTC-offsets[framemod8]*texelSize*0.5, texture2D(depthtex1, newTC).x));
	#else
		vec3 t0 = toScreenSpace(vec3(newTC, texture2D(depthtex1, newTC).x));
	#endif	
		vec3 center_to_sample = t0.xyz - fragpos.xyz;

		float dist = length(center_to_sample);

		vec3 center_to_sample_normalized = center_to_sample / dist;
		float attenuation = 1.0-clamp(dist/6.0,0.0,1.0);
		float dp = dot(normal, center_to_sample_normalized);

		attenuation = sqrt(max(dp,0.0))*attenuation*attenuation * step(attenuation_angle_threshold, dp);
		finalAO += attenuation * (ao_weight / num_samples);
	}
	return finalAO;
}
#endif

#ifdef raytracedShadows
//Based of Chocapic13s implementation
//https://www.minecraftforum.net/forums/mapping-and-modding-java-edition/minecraft-mods/1293898-1-14-chocapic13s-shaders
vec3 toClipSpace(vec3 viewSpacePosition) {
    return (diagonal3(gbufferProjection) * viewSpacePosition + gbufferProjection[3].xyz) / -viewSpacePosition.z * 0.5 + 0.5;
}

float calcRaytraceShadows(vec3 angle, vec3 pos, float dither, float translucent){
	//prevents the ray from going behind the camera
	float rayLength = (pos.z + angle.z * far*1.732 > -near) ? (-near - pos.z) / angle.z : far*1.732;
    vec3 direction = toClipSpace(pos+angle*rayLength)-toClipSpace(pos);  //convert to clip space
    	 direction.xyz = direction.xyz/max(abs(direction.x)/texelSize.x,abs(direction.y)/texelSize.y);	//fixed step size

	vec3 stepv = direction * 4.5;
#ifdef TAA	
	vec3 spos = toClipSpace(pos)+vec3(offsets[framemod8]*texelSize*0.5,0.0)+stepv*dither;
#else
	vec3 spos = toClipSpace(pos)+stepv*dither;
#endif
	for (int i = 0; i < 16; i++) {
		spos += stepv;
		float depth1 = texture2D(depthtex1,spos.xy).x; //might change to depthtex0 to support transparency
    	if(depth1 < spos.z) {
			float dist = abs(ld(depth1)-ld(spos.z))/ld(spos.z);
			if (dist < 0.01) return translucent*exp2(pos.z/8.0);
		}
	}
    return 1.0;
}
#endif

uniform float sunElevation;
vec3 YCoCg2RGB(vec3 c){
	c.y-=0.5;
	c.z-=0.5;
	return vec3(c.r+c.g-c.b, c.r + c.b, c.r - c.g - c.b);
}

void main() {

//sample half-resolution buffer with correct texture coordinates
vec4 hr = pow(texture2D(composite,(floor(gl_FragCoord.xy/2.)*2+1.0)/vec2(viewWidth,viewHeight)/2.0),vec4(2.2,2.2,2.2,1.0))*vec4(257.,257,257,1.0);

//Setup depth
float depth0 = texture2D(depthtex0, texcoord).x;	//everything
float depth1 = texture2D(depthtex1, texcoord).x;	//transparency

bool sky = (depth0 >= 1.0);

vec4 albedo = texture2D(colortex0,texcoord);
vec3 normal = decode(texture2D(colortex1, texcoord).xy);
vec2 lightmap = texture2D(colortex1, texcoord.xy).zw;
bool translucent = albedo.b > 0.69 && albedo.b < 0.71;
bool emissive = albedo.b > 0.59 && albedo.b < 0.61;
vec3 color = vec3(albedo.rg,0.0);

vec2 a0 = texture2D(colortex0,texcoord + vec2(1.0/viewWidth,0.0)).rg;
vec2 a1 = texture2D(colortex0,texcoord - vec2(1.0/viewWidth,0.0)).rg;
vec2 a2 = texture2D(colortex0,texcoord + vec2(0.0,1.0/viewHeight)).rg;
vec2 a3 = texture2D(colortex0,texcoord - vec2(0.0,1.0/viewHeight)).rg;
vec4 lumas = vec4(a0.x,a1.x,a2.x,a3.x);
vec4 chromas = vec4(a0.y,a1.y,a2.y,a3.y);

vec4 w = 1.0-step(0.1176, abs(lumas - color.x));
float W = dot(w,vec4(1.0));
w.x = (W==0.0)? 1.0:w.x;  W = (W==0.0)? 1.0:W;

bool pattern = (mod(gl_FragCoord.x,2.0)==mod(gl_FragCoord.y,2.0));
color.b= dot(w,chromas)/W;
color.rgb = (pattern)?color.rbg:color.rgb;
color.rgb = YCoCg2RGB(color.rgb);
color = pow(color,vec3(2.2));

if (!sky){
//Water and Ice
vec3 Wnormal = texture2D(colortex2,texcoord).xyz;
bool iswater = Wnormal.z < 0.2499 && dot(Wnormal,Wnormal) > 0.0;
bool isice = Wnormal.z > 0.2499 && Wnormal.z < 0.4999 && dot(Wnormal,Wnormal) > 0.0;
bool isnsun = (iswater||isice) || ((!iswater||!isice) && isEyeInWater == 1);
/*--------------------------------------------------------------------------------------*/

#ifdef TAA
vec2 newTC = gl_FragCoord.xy*texelSize;
vec3 TAAfragpos = toScreenSpace(vec3(newTC-offsets[framemod8]*texelSize*0.5, texture2D(depthtex1, newTC).x));
#else
vec3 TAAfragpos = toScreenSpace(vec3(texcoord,depth1));	//was depth0 before, might cause issues
#endif

#ifdef Whiteworld
	color += vec3(1.5);
#endif

#ifdef Celshading
	color = celshade(color);
#endif

float ao = 1.0;
#ifdef SSDO
	float occlusion = calcSSDO(TAAfragpos, normal);
	if(!iswater)ao = pow(1.0-occlusion, ao_strength);
#endif
	
	//Emissive blocks lighting and colors
	#ifdef HandLight
	bool underwaterlava = (isEyeInWater == 1.0 || isEyeInWater == 2.0);
	if(!underwaterlava) lightmap.x = max(lightmap.x, max(max(float(heldBlockLightValue), float(heldBlockLightValue2)) - 1.0 - length(TAAfragpos), 0.0) / 15.0);
	#endif
	float torch_lightmap = 16.0-min(15.0,(lightmap.x-0.5/16.0)*16.0*16.0/15.0);
	float fallof1 = clamp(1.0 - pow(torch_lightmap/16.0,4.0),0.0,1.0);
	torch_lightmap = fallof1*fallof1/(torch_lightmap*torch_lightmap+1.0);
	float c_emitted = dot((color.rgb),vec3(1.0,0.6,0.4))/2.0;
	float emitted 		= emissive? clamp(c_emitted*c_emitted,0.0,1.0)*torch_lightmap : 0.0;
	vec3 emissiveLightC = vec3(emissive_R,emissive_G,emissive_B);
	/*------------------------------------------------------------------------------------------*/
	
	//Lighting and colors
	float NdotL = dot(normal,sunVec);
	float NdotU = dot(normal,upVec);
	
	const vec3 moonlight = vec3(0.5, 0.9, 1.8) * Moonlight;

	vec2 visibility = vec2(sunVisibility,moonVisibility);

	float skyL = max(lightmap.y-2./16.0,0.0)*1.14285714286;	
	float SkyL2 = skyL*skyL;
	float skyc2 = mix(1.0,SkyL2,skyL);

	vec4 bounced = vec4(NdotL,NdotL,NdotL,NdotU) * vec4(-0.14*skyL*skyL,0.33,0.7,0.1) + vec4(0.6,0.66,0.7,0.25);
		 bounced *= vec4(skyc2,skyc2,visibility.x-tr*visibility.x,0.8);

	vec3 sun_ambient = bounced.w * (vec3(0.1, 0.5, 1.1)*2.4+rainStrength*2.3*vec3(0.05,-0.33,-0.9))+ 1.6*sunlight*(sqrt(bounced.w)*bounced.x*2.4 + bounced.z)*(1.0-rainStrength*0.99);
	vec3 moon_ambient = (moonlight*0.7 + moonlight*bounced.y)*4.0;

	//vec3 LightC = mix(sunlight,moonlight,moonVisibility)*tr*(1.0-rainStrength*0.99);
	vec3 LightC = mix(sunlight,moonlight,moonVisibility)*(1.0-rainStrength*0.99); //remove time check to smooth out day night transition
	vec3 amb1 = (sun_ambient*visibility.x + moon_ambient*visibility.y)*SkyL2*(0.03*0.65+tr*0.17*0.65);
	float finalminlight = (nightVision > 0.01)? 0.15 : minlight; //add nightvision support but make sure minlight is still adjustable.	
	vec3 ambientC = ao*amb1 + emissiveLightC*(emitted*15.*color + torch_lightmap*ao)*0.66 + ao*finalminlight*min(skyL+6/16.,9/16.)*normalize(amb1+0.0001);
	/*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

	//vec3 shadowLightpos = float(sunElevation > 1e-5)*2.0-1.0*normalize(mat3(gbufferModelViewInverse) *shadowLightPosition); //improves lighting but currently causes shadow acne
	//vec3 shadowLightpos = normalize(mat3(gbufferModelViewInverse) *shadowLightPosition);	
	float diffuse = translucent? 0.75 : clamp(dot(normal, normalize(shadowLightPosition)),0.0,1.0);	
	vec3 finalShading = vec3(diffuse);

#ifdef Shadows
	#ifdef TAA 
	float noise = fract(0.75487765 * gl_FragCoord.x + 0.56984026 * gl_FragCoord.y);
		  noise = fract(frameTimeCounter * 16.0 + noise);
	#else
	float noise = fract(dot(gl_FragCoord.xy, vec2(0.5, 0.25))); //Use different dithering if TAA is disabled, because it looks better at low sample rate.
	#endif
if (diffuse > 0.001) {
	vec3 shadowpos = mat3(gbufferModelViewInverse) * TAAfragpos.xyz + gbufferModelViewInverse[3].xyz;
		 shadowpos = mat3(shadowModelView) * shadowpos + shadowModelView[3].xyz;
		 shadowpos = diagonal3(shadowProjection) * shadowpos + shadowProjection[3].xyz;
	float distortion = calcDistortion(shadowpos.xy);
		 shadowpos.xy *= distortion;
	vec2 shading = vec2(1.0); //set to 1.0 for raytraced shadows outside of shadowmap
	//only if on shadowmap
	if (abs(shadowpos.x) < 1.0-1.5/shadowMapResolution && abs(shadowpos.y) < 1.0-1.5/shadowMapResolution && abs(shadowpos.z) < 6.0){
		float pdepth = 1.412;	//fallback if penumbra shadows are disabled
		const float threshMul = max(2048.0/shadowMapResolution*shadowDistance/128.0,0.95);
		float distortThresh = (sqrt(1.0-diffuse*diffuse)/diffuse+0.7)/distortion;
		shadowpos = shadowpos * vec3(0.5,0.5,0.5/6.0) + vec3(0.5,0.5,0.5);

	#if defined Penumbra && defined MC_GL_VENDOR_NVIDIA && defined MC_OS_WINDOWS
		vec3 shadowFilterDepth = vec3(1.412, 30.0, 20.0);	//x=min radius, y=max radius, z=max depth
		float pbias = translucent? 0.00014/15.0 : distortThresh/7500.0*threshMul;
		float diffthreshM = pbias*shadowFilterDepth.y*distortion*Nearshadowplane*k;
		vec2 counter = vec2(0.0);
		for(int i = 0; i < VPS_samples; i++){
			vec2 offsetS = tapLocation(i,VPS_samples,noise);

			float depth = texelFetch2D(shadowtex0, ivec2((shadowpos.xy+offsetS*distortion*(1.0+shadowFilterDepth.y)*Nearshadowplane*k/shadowMapResolution)*shadowMapResolution), 0).x;
			float block  = ffstep(depth,shadowpos.z-i*diffthreshM/VPS_samples-diffthreshM);

			counter.x += block;
			counter.y += depth * block;
		}
		counter.y = (counter.x >= 0.9)? counter.y / counter.x : shadowpos.z;
		pdepth = clamp(max(shadowpos.z - counter.y, 0.0)*1500.0, 0.0, shadowFilterDepth.z)/shadowFilterDepth.z*(shadowFilterDepth.y-shadowFilterDepth.x)+shadowFilterDepth.x;
	#endif

		//Setup shadows
		float rdMul = pdepth*distortion*Nearshadowplane*k/shadowMapResolution;
		float bias = translucent? 0.00014 : distortThresh/6000.0*threshMul;
		shading = vec2(0.0); //set to 0.0 for shadowmap shadows
		for(int i = 0; i < shadow_samples; i++){
			vec2 offsetS = tapLocation(i,shadow_samples,noise);

			float weight = 1.0+(i+noise)*rdMul/shadow_samples*shadowMapResolution;
			shading.x += shadow2D(shadow,vec3(shadowpos + vec3(rdMul*offsetS,-bias*weight))).x/shadow_samples;
		#ifdef ColoredShadows
			shading.y += shadow2D(shadowtex1,vec3(shadowpos + vec3(rdMul*offsetS,-bias*weight))).x/shadow_samples;
		#endif
		}
	}
	
	#ifdef raytracedShadows
		if(shading.x > 0.005)shading.xy *= calcRaytraceShadows(shadowLightPosition,TAAfragpos.xyz,noise,float(translucent));
	#endif

	#ifdef ColoredShadows
		finalShading = texture2D(shadowcolor0, shadowpos.xy).rgb*(shading.y-shading.x) + shading.x;
		finalShading *= diffuse;
	#else
		finalShading = vec3(shading.x)*diffuse;
	#endif

	//Prevent light leakage
	finalShading *= mix(skyL,1.0,clamp((eyeBrightnessSmooth.y/255.0-2.0/16.)*4.0,0.0,1.0));
}
#else
	finalShading *= mix(skyL,1.0,clamp((eyeBrightnessSmooth.y/255.0-4.0/16.)*4.0,0.0,1.0)); //fix lighting in caves with shadows disabled.
	finalShading *= 0.5;
#endif

	vec3 waterC = vec3(waterCR,waterCG,waterCB);
	if(iswater || isEyeInWater == 1.0) LightC = mix(waterC,waterC*0.0125,moonVisibility)*(1.0-rainStrength*0.99); //water shading, wip
	color *= (finalShading*LightC*(isnsun?SkyL2*skyL:1.0)*2.15+ambientC*(isnsun?1.0/(SkyL2*skyL*0.5+0.5):1.0)*1.4)*0.63;
}

//Sky
vec2 ntc = texcoord*2.0;
vec2 ntc2 = texcoord*2.0-1.0;
vec3 c = vec3(0.0);

if (ntc.x < 1.0 && ntc.y < 1.0 && ntc.x > 0.0 && ntc.y > 0.0) {
	float depth1 = texture2D(depthtex1, ntc).x;
	float sky = 0.950-near/far/far;
		if (depth1 > sky) {
			vec4 fragpos = gbufferProjectionInverse * (vec4(ntc, depth1, 1.0) * 2.0 - 1.0);
			fragpos /= fragpos.w;
			//Draw sky
			c = getSkyColor(fragpos.xyz);
		}
}

#ifdef Volumetric_Lighting
	float gr = Volumetric_Light(texcoord.xy);
		  gr = getVolumetricRays();

	//single pass godrays for volumetric lighting
	vec2 deltatexcoord = vec2(lightPos - texcoord) * 0.04;
	vec2 raysCoord = texcoord + deltatexcoord*raysNoise(texcoord); //slow filtered

	float rays = 1.0;
	for (int i = 0; i < 20; i++) {
		float depth0 = texture2D(depthtex0, raysCoord).x;
		raysCoord += deltatexcoord;
		rays += dot(step(comp, depth0), 1.0)*raysCdist(raysCoord);
	}
	rays /= 20.0;

	vec3 raysPos = screenSpace(texcoord.xy, texture2D(depthtex0, texcoord.xy).x);
	float lightpos = clamp(dot(normalize(raysPos), normalize(shadowLightPosition)), 0.0, 1.0)*rays*5.0;
	gr *= 1.0+lightpos*(1.0-isEyeInWater);
#else
	float gr = 0.0;
#endif

//Godrays and lens flares
if (ntc2.x < 1.0 && ntc2.y < 1.0 && ntc2.x > 0.0 && ntc2.y > 0.0){
#ifndef Volumetric_Lighting
#ifdef Godrays
	vec2 deltatexcoord = vec2(lightPos - ntc2) * 0.04;
	vec2 noisetc = ntc2 + deltatexcoord*raysNoise(ntc2) + deltatexcoord; //maybe doesnt need to be filtered
	bool underwater = (isEyeInWater == 1.0);

	for (int i = 0; i < grays_sample; i++) {
		float depth = underwater? texture2D(depthtex1, noisetc).x : texture2D(depthtex0, noisetc).x; //swap depth for now, wip
		noisetc += deltatexcoord;
		gr += dot(step(comp, depth), 1.0)*cdist(noisetc);
	}
	gr /= grays_sample;
#endif
#endif

#ifdef Lens_Flares
LensFlare(c);
#endif
}

#ifdef Lens_Flares
if (texcoord.x < 2.0/viewWidth && texcoord.y < 2.0/viewHeight) {
gr = 0.0;
	for (int i = -6; i < 7;i++) {
		for (int j = -6; j < 7 ;j++) {
		vec2 ij = vec2(i,j);
		float depth = texture2D(depthtex0, ntc+lightPos + sign(ij)*sqrt(abs(ij))*vec2(0.006)).x;
		gr += dot(step(comp, depth), 1.0);
		}
	}
	gr /= 169.0;
}
#endif

//Draw sky (color)
#ifdef defskybox
	if (sky)color = pow(texture2D(composite, texcoord.xy).rgb,vec3(2.2)); //overwrite color with data from skytextured
#else
	if (sky)color = hr.rgb;
#endif

gl_FragData[0] = vec4(c/30.0, 1.0);
gl_FragData[1] = vec4(pow(color/257.0,vec3(0.454)), gr);
}