#define SHADOW_EPSILON 0.3f
#define reciproc	1.0f/512.0f
#define textureSize	256.0f
#define textureSize2 128.0f

//Model view matrix
uniform float4x4 modelview;
//Model view inverse transpose matrix
uniform float4x4 modelviewIT;
//Model view projection matrix
uniform float4x4 modelviewproj;
//Shooter colors.
uniform float4   Lshoot;
//Current number of iterations.
uniform float    niteration;
//The reciproc of resolution.
uniform float    recres2;
//Random number.
uniform float	 RandomNum;
//The current search coordinates.
uniform float2	 searchCoords;
//The first sum.
uniform float	 firstsum;
//The eye position.
uniform float3	 eyePos;
//Py parameter.
uniform float	 py;
//Render full or half screen.
uniform bool	 fullScreen;
//The shininess parameter for specular.
uniform float	 shininess;


//Texture for the original visibility map.
texture visibility_map;
sampler VisMapSampler = sampler_state
{
   Texture = <visibility_map>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   //AddressU  = Clamp;
   //AddressV  = Clamp;
};
//Texture for radiosity map.
texture radiosity_map;
sampler RadMapSampler = sampler_state
{
   Texture = <radiosity_map>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   //AddressU  = Clamp;
   //AddressV  = Clamp;
};
//Texure for actual radiosity map.
texture act_radiosity_map;
sampler ActRadMapSampler = sampler_state
{
   Texture = <act_radiosity_map>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   //AddressU  = Clamp;
   //AddressV  = Clamp;
};
//Texture for luminance.
texture luminance_map;
sampler LumMapSampler = sampler_state
{
   Texture = <luminance_map>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   //AddressU  = Wrap;
   //AddressV  = Wrap;
};
//Texture for emission.
texture emission_map;
sampler EmissionMapSampler = sampler_state
{
   Texture = <emission_map>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   //AddressU  = Clamp;
   //AddressV  = Clamp;
};
//Texture for the sum of the mipmap levels.
texture sum_map;
sampler SumSampler = sampler_state
{
   Texture = <sum_map>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   AddressU  = Clamp;
   AddressV  = Clamp;
};
//Mipmap level texture
texture mipmap;
sampler MipmapSampler = sampler_state
{
   Texture = <mipmap>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   AddressU  = Clamp;
   AddressV  = Clamp;
};
//The BRDF map.
texture BRDFMap;
sampler BRDFMapSampler = sampler_state
{
   Texture = <BRDFMap>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = None;   
   AddressU  = Clamp;
   AddressV  = Clamp;
};
//The specular map.
texture Specular_Map;
sampler SpecularMapSampler = sampler_state
{
   Texture = <Specular_Map>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = None;   
   AddressU  = Clamp;
   AddressV  = Clamp;
};

//The map for the final rendered image.
texture final_map;
sampler FinalMapSampler = sampler_state
{
   Texture = <final_map>;
   MinFilter = Point;
   MagFilter = Point;
   MipFilter = None;   
   AddressU  = Clamp;
   AddressV  = Clamp;
};


//Multiple render target PS output for 2 targets.
struct MRT_Output_2 {   
    float4 firstcolor    : COLOR0;
    float4 secondcolor   : COLOR1;
};
//Vertex shader input structure.
struct inputs {   
    float4 position    : POSITION;
    float4 patch_index : COLOR0;
    float2 texcoord    : TEXCOORD0;
	float3 brdf        : TEXCOORD1;
	float4 emission    : TEXCOORD2;
	float4 normal	   : NORMAL;
};
//Complex vertex shader output structure.
struct vs_outputs {
    float4 hposition   : POSITION;
    float2 texcoord    : TEXCOORD0;
    float4 viscoord    : TEXCOORD1;
    float4 emission    : TEXCOORD2;
    float3 x           : TEXCOORD3;
    float3 brdf		   : TEXCOORD4;
    float3 normal	   : TEXCOORD5;
 };
//Simple vertex shader output for initializing BRDF maps.
struct text_vs_output{
	float4 hposition:POSITION;
	float2 texcoord:TEXCOORD0;
};


//Renders vertex output to a texture atlas.
text_vs_output BRDFMAP_VS(inputs IN){
	text_vs_output OUT;
	OUT.hposition.xy = 2*IN.texcoord.xy-float2(1,1);
	OUT.hposition.z = 0;
	OUT.hposition.w = 1;
	OUT.texcoord.x		= IN.texcoord.x+reciproc;
	OUT.texcoord.y		= 1-IN.texcoord.y+reciproc;
	return(OUT);
}
//Pixel shader for BRDF atlas rendering.
float4 BRDFMAP_PS(float4 texcoord:TEXCOORD0):COLOR{
	float4 retval;
	retval.rgb=tex2D(BRDFMapSampler,texcoord).rgb/3.1415f;
	retval.a=shininess;
	return retval;
}

//Renders visibility map.
vs_outputs ORIGVISMAP_VS( inputs IN) {
			 
    vs_outputs OUT;
    
    OUT.hposition=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.texcoord=float2(0.0f,0.0f);
    OUT.viscoord=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.emission=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.x =float3(0.0f,0.0f,0.0f);
    OUT.brdf=float3(0.0f,0.0f,0.0f);
    OUT.normal=float3(0.0f,0.0f,0.0f);
	OUT.hposition.xy = 2*IN.texcoord.xy-float2(1,1);
	OUT.hposition.z = 0;
	OUT.hposition.w = 1;
	OUT.emission.rgb = IN.patch_index.xyz;
	OUT.emission.a	 = 1.0f;
	OUT.viscoord=IN.emission.rgba;
	return(OUT);
}

//Renders emission map.
vs_outputs EMISSION_VS( inputs IN) {
			 
    vs_outputs OUT;
    
    OUT.hposition=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.texcoord=float2(0.0f,0.0f);
    OUT.viscoord=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.emission=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.x =float3(0.0f,0.0f,0.0f);
    OUT.brdf=float3(0.0f,0.0f,0.0f);
    OUT.normal=float3(0.0f,0.0f,0.0f);
    OUT.hposition.xy = 2 * IN.texcoord.xy - float2(1, 1);
	OUT.hposition.z = 0;
	OUT.hposition.w = 1;
	OUT.emission.rgba = IN.emission.rgba;
    return(OUT);
}


//Renders iterated visibility map.
vs_outputs ITVIS_VS( inputs IN) {
			 
    vs_outputs OUT;
    
    OUT.hposition=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.texcoord=float2(0.0f,0.0f);
    OUT.viscoord=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.emission=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.x =float3(0.0f,0.0f,0.0f);
    OUT.brdf=float3(0.0f,0.0f,0.0f);
    OUT.normal=float3(0.0f,0.0f,0.0f);
    OUT.hposition	= mul(IN.position,modelviewproj);
	OUT.emission.r  = OUT.hposition.z;
	OUT.emission.g	= abs(dot(IN.normal,normalize(IN.position-eyePos)));	//cosine
    return(OUT);
}
//Vertex shader for rendering one shot from the current shooter.
vs_outputs SHOOT_VS( inputs IN) {
			 
    vs_outputs OUT;
    
    OUT.hposition=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.texcoord=float2(0.0f,0.0f);
    OUT.viscoord=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.emission=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.x =float3(0.0f,0.0f,0.0f);
    OUT.brdf=float3(0.0f,0.0f,0.0f);
    OUT.normal=float3(0.0f,0.0f,0.0f);
	OUT.hposition.xy	= 2 * IN.texcoord.xy - float2(1, 1);
	OUT.hposition.z		= 0;
	OUT.hposition.w		= 1;
	OUT.texcoord.x		= IN.texcoord.x+reciproc;
	OUT.texcoord.y		= 1-IN.texcoord.y+reciproc;
	
	OUT.x				= mul(IN.position, modelview).xyz;
	OUT.normal			= mul(IN.normal, modelviewIT).xyz;

	OUT.emission.rgba	= IN.emission.rgba;		
	OUT.brdf			= IN.brdf;
	OUT.viscoord	    = mul(IN.position,modelviewproj);
	return OUT;
}
//Rendering the final output.
vs_outputs FINAL_VS( inputs IN) {
			 
    vs_outputs OUT;
    
    OUT.hposition=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.texcoord=float2(0.0f,0.0f);
    OUT.viscoord=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.emission=float4(0.0f,0.0f,0.0f,0.0f);
    OUT.x =float3(0.0f,0.0f,0.0f);
    OUT.brdf=float3(0.0f,0.0f,0.0f);
    OUT.normal=float3(0.0f,0.0f,0.0f);
    
    OUT.hposition.xyzw = mul(IN.position,modelviewproj).xyzw;
	OUT.texcoord.x = IN.texcoord.x;
	OUT.texcoord.y = 1.0f-IN.texcoord.y;
	
    return OUT;
}

//Rendering a shot from the current shooter.
float4 SHOOT_PS(
			float2 texcoord        : TEXCOORD0,
	        float4 viscoord        : TEXCOORD1,
	        float4 emission        : TEXCOORD2,
	        float3 x               : TEXCOORD3,
	        float3 brdf	  		   : TEXCOORD4,
	        float3 xnormal		   : TEXCOORD5
			) : COLOR
{
	
	float3 ytox			= normalize( x );			// direction from y to x
	float  xydist2		= dot( x, x );				// |x - y|^2

	float  costhetax	= dot(xnormal, -ytox);		//cosine(thetax)
	if(costhetax<0.0f) costhetax=0.0f;
		
	float  costhetay	= (fullScreen) ? ytox.z : ytox.y; //cosine(thetay) is fullscreen side of the visibility hemicube?
	if(costhetay<0.0f) costhetay=0.0f;
	if(xydist2<1.0f) xydist2 = 1.0f;
	float G = costhetax * costhetay / (xydist2+4.0f*Lshoot.w);	//Geometry factor. Uniform disc method.
	
	float3 Lref	= Lshoot.xyz * G;
	
	
	float visible;
	
	float2 depthmap;
	
	float2 viscoord2=(viscoord.xy/viscoord.w+1)/2;
	viscoord2.y=1-viscoord2.y+reciproc;
	viscoord2.x+=reciproc;
	float depth=viscoord.z;
	float yLimit= (fullScreen)? 1 :0.5;
	if((viscoord2.x>=0)&&(viscoord2.x<=1)&&(viscoord2.y>=0)&&(viscoord2.y<yLimit)){
		depthmap  = tex2D(VisMapSampler, viscoord2).rg;

		visible =	(abs(depthmap.r-depth)<(0.09-0.06*depthmap.g));
		
	}
	else{
		visible=0;
	}
	
	/*
	//V has is a normalized vector from patch to eye pos.
	//L is -ytox.
	//N is xnormal.
	//R is L mirrored to N.
	float4 brdf2=tex2D(BRDFSampler,texcoord);
	float3 eyePos2=normalize(x-eyePos);
	float3 R=xnormal*(2.0f*costhetax)+ytox;
	float cos_out=dot(R,eyePos2);
	//brdf2.a is specular shininess;
	float specular=0.1f*pow(cos_out,brdf2.a)/max(dot(xnormal,eyePos2),dot(xnormal,-ytox));
	float3 lrNew= visible * Lref.xyz * (brdf2.xyz+specular);
	*/
	
	float3 lrNew= visible * Lref.xyz * brdf.xyz;

	
	float g;
	if(py==0.0f){
		g=0.0f;
	}
	else{
		g = G*visible/py;
	}
	
	float4 oldActual=tex2D(ActRadMapSampler,texcoord).rgba;
	
	float4 retColor=float4(lrNew,g)+oldActual.rgba;
	
	return retColor;
	
	
}

float4 TEXTURE_PS( in float2 texcoord        : TEXCOORD0
			 ) : COLOR
{
	
	texcoord*=textureSize2;
	
	int2 itexcoord0=texcoord;
	
	float2 itexcoord1=float2(itexcoord0.x+1,itexcoord0.y);
	float2 itexcoord2=float2(itexcoord0.x,itexcoord0.y+1);
	float2 itexcoord3=float2(itexcoord0.x+1,itexcoord0.y+1);
	float4 color0=tex2D(FinalMapSampler, itexcoord0/textureSize2).rgba;
	float4 color1=tex2D(FinalMapSampler, itexcoord1/textureSize2).rgba;
	float4 color2=tex2D(FinalMapSampler, itexcoord2/textureSize2).rgba;
	float4 color3=tex2D(FinalMapSampler, itexcoord3/textureSize2).rgba;
	color0*=(1-(texcoord.x-itexcoord0.x))*(1-(texcoord.y-itexcoord0.y));
	color1*=((texcoord.x-itexcoord0.x))*(1-(texcoord.y-itexcoord0.y));
	color2*=(1-(texcoord.x-itexcoord0.x))*((texcoord.y-itexcoord0.y));
	color3*=((texcoord.x-itexcoord0.x))*((texcoord.y-itexcoord0.y));
	if(color1.a!=0.0){
		color0+=color1;
		
	}
	if(color2.a!=0.0){
		color0+=color2;
		
	}
	if(color3.a!=0.0){
		color0+=color3;
	}
	
	return float4(color0.rgb/color0.a,1);
	
}

//Writes float4(TEXCOORD2.x,TEXCOORD2.y,TEXCOORD2.z,(sum(TEXCOORD2.x,TEXCOORD2.y,TEXCOORD2.z)*TEXCOORD2.w)) to the output.
float4 WRITETHROUGH_PS(in float4 emission : TEXCOORD2) : COLOR {
	float lumPower=(emission.r+emission.g+emission.b)/3.0f*emission.a;
	return(float4(emission.rgb,lumPower));
	//return(float4(0,emission.a,0,1));
}


//Writes TEXCOORD2.r and TEXCOORD1.r to the output.
float4 ORIGVISMAP_PS(	in float4 emission : TEXCOORD1,
						in float4 patch_index : TEXCOORD2
					 
					 ) : COLOR {
	return float4(patch_index.r,emission.a,0.0f,0.0f);
}
//Writes TEXCOORD2.r, TEXCOORD2.g to the output.
float4 WRITETHROUGH_VISMAP_PS(in float4 emission : TEXCOORD2) : COLOR {
	return(float4(emission.r,emission.g,0,1));
}
//Creates the base level for the radiosity sum map.
float4 MIPMAP_CREATE_BASE( in float2 texcoord        : TEXCOORD0,
						   in float4 color               : COLOR0
             
                 ) : COLOR
{
		
        float col=tex2D(RadMapSampler, float2(texcoord.x,texcoord.y)).a;
        col+=tex2D(RadMapSampler, float2(texcoord.x+recres2, texcoord.y)).a;
        col+=tex2D(RadMapSampler, float2(texcoord.x, texcoord.y+recres2)).a;
        col+=tex2D(RadMapSampler, float2(texcoord.x+recres2, texcoord.y+recres2)).a;
        return float4(col,0,0,0);
}
//Creates a sum map level.
float4 MIPMAP_CREATE_LEVEL( in float2 texcoord        : TEXCOORD0,
							in float4 color               : COLOR0
             
                 ) : COLOR
{
		
        float col=tex2D(LumMapSampler, float2(texcoord.x,texcoord.y)).r;
        col+=tex2D(LumMapSampler, float2(texcoord.x+recres2, texcoord.y)).r;
        col+=tex2D(LumMapSampler, float2(texcoord.x, texcoord.y+recres2)).r;
        col+=tex2D(LumMapSampler, float2(texcoord.x+recres2, texcoord.y+recres2)).r;
        return float4(col,0,0,0);
}

//Starts the search of the sum map levels for a shooter.
float4 SEARCH_PS_START( in float2 texcoord        : TEXCOORD0,
				  in float4 color               : COLOR0
             
                 ) : COLOR
{
	//float3 sumColor=tex2D(SumSampler,float2(0.5f,0.5f));
	float r=firstsum;
	float color1=tex2D(MipmapSampler ,float2(0,0)).r;
	float colMax=color1;
	float colMin=0;
	float retval=0;
	float2 retCoords;
	if(r<=colMax){
		retval=r;
		retCoords=float2(0,0);
		
	}
	else{
		colMin=colMax;
		float color2=tex2D(MipmapSampler ,float2(searchCoords.x+recres2,searchCoords.y)).r;
		colMax+=color2;
		if(r<=colMax){
			retval=r-colMin;
			retCoords=float2(searchCoords.x+recres2,searchCoords.y);
		}
		else{
			colMin=colMax;
			float color3=tex2D(MipmapSampler ,float2(searchCoords.x,searchCoords.y+recres2)).r;
			colMax+=color3;
			if(r<=colMax){
				retval=r-colMin;
				retCoords=float2(searchCoords.x,searchCoords.y+recres2);
			}
			else{
				colMin=colMax;
				retval=r-colMin;
				retCoords=float2(searchCoords.x+recres2,searchCoords.y+recres2);
			}
		}
	}	
	
	return float4(retval,retCoords.x,retCoords.y,1.0f);
}
//Searches the sum map levels for a shooter.
float4 SEARCH_PS( in float2 texcoord        : TEXCOORD0,
				  in float4 color               : COLOR0             
                 ) : COLOR
{
	float3 sumColor=tex2D(SumSampler,float2(0.5f,0.5f));
	
	float r=sumColor.r;
	float2 searchCoords1=float2(sumColor.g,sumColor.b);
	float color1=tex2D(MipmapSampler ,searchCoords1).r;
	float colMax=color1;
	float colMin=0;
	float2 retCoords;
	float retval=0;
	if(r<=colMax){
		retval=r;
		retCoords=searchCoords1;
	}
	else{
		colMin=colMax;
		float color2=tex2D(MipmapSampler ,float2(searchCoords1.x+recres2,searchCoords1.y)).r;
		colMax+=color2;
		if(r<=colMax){
			retval=r-colMin;
			retCoords=float2(searchCoords1.x+recres2,searchCoords1.y);
		}
		else{
			colMin=colMax;
			float color3=tex2D(MipmapSampler ,float2(searchCoords1.x,searchCoords1.y+recres2)).r;
			colMax+=color3;
			if(r<=colMax){
				retval=r-colMin;
				retCoords=float2(searchCoords1.x,searchCoords1.y+recres2);
			}
			else{
				colMin=colMax;
				retval=r-colMin;
				retCoords=float2(searchCoords1.x+recres2,searchCoords1.y+recres2);
			}
		}
	}	
	
	return float4(retval,retCoords.x,retCoords.y,1.0f);
}


//Ends the search for sum map levels for a shooter.
MRT_Output_2 SEARCH_PS_END( in float2 texcoord        : TEXCOORD0,
							in float4 color               : COLOR0             
							)
{
	MRT_Output_2 output1;
	float3 sumColor=tex2D(SumSampler,float2(0.5f,0.5f));
	float r=sumColor.r;
	float2 searchCoords1=float2(sumColor.g,sumColor.b);
	float retval=0;
	float color1=tex2D(MipmapSampler ,searchCoords1).a;
	float colMax=color1;
	float colMin=0;
	float2 retCoords;
	if(r<=colMax){
		retval=r;
		retCoords=searchCoords1;
	}
	else{
		colMin=colMax;
		float color2=tex2D(MipmapSampler ,float2(searchCoords1.x+recres2,searchCoords1.y)).a;
		colMax+=color2;
		if(r<=colMax){
			retval=r-colMin;
			retCoords=float2(searchCoords1.x+recres2,searchCoords1.y);
		}
		else{
			colMin=colMax;
			float color3=tex2D(MipmapSampler ,float2(searchCoords1.x,searchCoords1.y+recres2)).a;
			colMax+=color3;
			if(r<=colMax){
				retval=r-colMin;
				retCoords=float2(searchCoords1.x,searchCoords1.y+recres2);
			}
			else{
				colMin=colMax;
				retval=r-colMin;
				retCoords=float2(searchCoords1.x+recres2,searchCoords1.y+recres2);
			}
		}
	}
	float3 radiosityColor=tex2D(MipmapSampler,retCoords).rgb;
	//The output is the value of the shooter. And the texture coordinates of the shooter.
	output1.firstcolor=float4(retval,retCoords.x,retCoords.y,1.0f);
	//The output is the value. And the texture coordinates of the shooter.
	output1.secondcolor=float4(radiosityColor.r,radiosityColor.g,radiosityColor.b,1.0f);
	return output1;
}

//The vertex shader input structure for sum maping.
struct mipmap_inputs {   
    float4 position    : POSITION;
    float2 texcoord    : TEXCOORD0;
    
};
//The input structure for sum maping.
struct mipmap_outputs {
    float4 hposition   : POSITION;
    float2 texcoord    : TEXCOORD0;
 };

//Sum map vertex shader.
mipmap_outputs  MIPMAP_VS(mipmap_inputs IN)  {
	mipmap_outputs OUT;
	OUT.hposition.w=1;
	OUT.hposition=IN.position;
	OUT.texcoord=IN.texcoord;
	return OUT;
}
//Averages the current radiosity map.
float4 AVERAGING_PS(mipmap_outputs IN):COLOR{
	float4 retval;
	float w=tex2D(RadMapSampler,IN.texcoord).a/3.1415f;
	float3 retcolor=tex2D(RadMapSampler,IN.texcoord).rgb;
	retcolor-=tex2D(EmissionMapSampler,IN.texcoord).rgb;
	retcolor/=niteration;
	retcolor+=tex2D(EmissionMapSampler,IN.texcoord).rgb;
	retval = float4(retcolor,1);
	return retval;
}



//Vertex shader. Averages the actual radiosity mipmap.
text_vs_output ACTUAL_AVG_VS(inputs IN){
	text_vs_output OUT;
	
	OUT.hposition.xy = 2*IN.texcoord.xy-float2(1,1);
	OUT.hposition.z = 0;
	OUT.hposition.w = 1;
	OUT.texcoord.x = IN.texcoord.x+reciproc;
	OUT.texcoord.y = 1-IN.texcoord.y+reciproc;
	return OUT;
}

//Pixel shader. Averages the actual radiosity mipmap.
float4 ACTUAL_AVG_PS(float2 texcoord:TEXCOORD0):COLOR{
	float recres2=1.0f/textureSize;
	float2 texcoord1=float2(texcoord.x+recres2,texcoord.y);
	float2 texcoord2=float2(texcoord.x,texcoord.y+recres2);
	float2 texcoord3=float2(texcoord.x+recres2,texcoord.y+recres2);
	
	float4 highResActual0=tex2D(ActRadMapSampler,texcoord);
	float3 emission0=tex2D(EmissionMapSampler,texcoord).rgb;
	float2 mask0=tex2D(VisMapSampler,texcoord).rg;	//green channel contains area/texarea
	highResActual0.rgb+=emission0.rgb;
	
	float4 highResActual1=tex2D(ActRadMapSampler,texcoord1);
	float3 emission1=tex2D(EmissionMapSampler,texcoord1).rgb;
	highResActual1.rgb+=emission1.rgb;
	float2 mask1=tex2D(VisMapSampler,texcoord1).rg;
	
	float4 highResActual2=tex2D(ActRadMapSampler,texcoord2);
	float3 emission2=tex2D(EmissionMapSampler,texcoord2).rgb;
	highResActual2.rgb+=emission2.rgb;;
	float2 mask2=tex2D(VisMapSampler,texcoord2).rg;
	
	float4 highResActual3=tex2D(ActRadMapSampler,texcoord3);
	float3 emission3=tex2D(EmissionMapSampler,texcoord3).rgb;
	highResActual3.rgb+=emission3.rgb;
	float2 mask3=tex2D(VisMapSampler,texcoord3).rg;
	
	
	float  lNewLum=0;
	
	lNewLum+=(highResActual0.r+highResActual0.g+highResActual0.b)/3.0f*mask0.g;
	lNewLum+=(highResActual1.r+highResActual1.g+highResActual1.b)/3.0f*mask1.g;
	lNewLum+=(highResActual2.r+highResActual2.g+highResActual2.b)/3.0f*mask2.g;
	lNewLum+=(highResActual3.r+highResActual3.g+highResActual3.b)/3.0f*mask3.g;
	
	return float4(lNewLum,0,0,0);
}
//Pixel shader. Masks the averaging output with the original visibility map. Keeps texture atlas
//pixels originally visible only.
float4 ACTUAL_AVG_PS2(float2 texcoord:TEXCOORD0):COLOR{
	float recres2=1.0f/textureSize;
	float2 texcoord1=float2(texcoord.x+recres2,texcoord.y);
	float2 texcoord2=float2(texcoord.x,texcoord.y+recres2);
	float2 texcoord3=float2(texcoord.x+recres2,texcoord.y+recres2);
	
	float4 highResActual0=tex2D(ActRadMapSampler,texcoord);
	float mask0=tex2D(VisMapSampler,texcoord).r;
	float4 highResActual1=tex2D(ActRadMapSampler,texcoord1);
	float mask1=tex2D(VisMapSampler,texcoord1).r;
	
	float4 highResActual2=tex2D(ActRadMapSampler,texcoord2);
	float mask2=tex2D(VisMapSampler,texcoord2).r;
	
	float4 highResActual3=tex2D(ActRadMapSampler,texcoord3);
	float mask3=tex2D(VisMapSampler,texcoord3).r;
	
	float divisor=1.0f;
	
	float4 sum=highResActual0;
	
	if(mask0==mask1){
		divisor++;
		sum+=highResActual1;
	}
	if(mask0==mask2){
		divisor++;
		sum+=highResActual2;
	}
	if(mask0==mask3){
		divisor++;
		sum+=highResActual3;	
	}
	sum/=divisor;
	
	return(tex2D(RadMapSampler,texcoord)+sum);
}

// -------------------------------------------------------------
// Name technique | how to compile 
// -------------------------------------------------------------

technique OriginalVisibilityMapShader
{
    pass P0
    {
        // compiler directives
        VertexShader = compile vs_3_0 ORIGVISMAP_VS();
        PixelShader  = compile ps_3_0 ORIGVISMAP_PS();
    }
}
technique EmissionMapTech
{
    pass P0
    {
        // compiler directives
        VertexShader = compile vs_3_0 EMISSION_VS();
        PixelShader  = compile ps_3_0 WRITETHROUGH_PS();
    }
}
technique ITVisShader
{
    pass P0
    {
        // compiler directives
        VertexShader = compile vs_3_0 ITVIS_VS();
        PixelShader  = compile ps_3_0 WRITETHROUGH_VISMAP_PS();
    }
}

technique MipmapBaseCreate
{
    pass P0{
		Sampler[0] = (RadMapSampler);
    	// compiler directives
        VertexShader = compile vs_3_0 MIPMAP_VS();
        PixelShader  = compile ps_3_0 MIPMAP_CREATE_BASE();
    }
}
technique MipmapLevelCreate
{
    pass P0{
		Sampler[0] = (LumMapSampler);
    	// compiler directives
        VertexShader = compile vs_3_0 MIPMAP_VS();
        PixelShader  = compile ps_3_0 MIPMAP_CREATE_LEVEL();
    }
}
technique SearchStartTech
{
    pass P0{
		Sampler[0] = (MipmapSampler);
		Sampler[1] = (SumSampler);
    	// compiler directives
        VertexShader = compile vs_3_0 MIPMAP_VS();
        PixelShader  = compile ps_3_0 SEARCH_PS_START();
    }
}
technique SearchTech
{
    pass P0{
		
		Sampler[0] = (SumSampler);
		Sampler[1] = (MipmapSampler);
    	// compiler directives
        VertexShader = compile vs_3_0 MIPMAP_VS();
        PixelShader  = compile ps_3_0 SEARCH_PS();
    }
}
technique SearchEndTech
{
    pass P0{
		/*
		Sampler[0] = (SumSampler);
		Sampler[1] = (MipmapSampler);
		Sampler[2] = (RadMapSampler);
		*/
    	// compiler directives
        VertexShader = compile vs_3_0 MIPMAP_VS();
        PixelShader  = compile ps_3_0 SEARCH_PS_END();
    }
}
technique Shoot
{
    pass P0{
		Sampler[0] = (VisMapSampler);		
		Sampler[1] = (RadMapSampler);
    	// compiler directives
        VertexShader = compile vs_3_0 SHOOT_VS();
        PixelShader  = compile ps_3_0 SHOOT_PS();
    }
}
technique RadAveragingTech
{
    pass P0{
    	// compiler directives
        VertexShader = compile vs_3_0 MIPMAP_VS();
        PixelShader  = compile ps_3_0 AVERAGING_PS();
    }
}
technique RenderFinal
{
    pass P0{
		Sampler[0] = (RadMapSampler);		
    	// compiler directives
        VertexShader = compile vs_3_0 FINAL_VS();
        PixelShader  = compile ps_3_0 TEXTURE_PS();
    }
}
technique ActualAveragingTech
{
    pass P0{
    	// compiler directives
        VertexShader = compile vs_3_0 ACTUAL_AVG_VS();
        PixelShader  = compile ps_3_0 ACTUAL_AVG_PS();
    }
}
technique ActualAveragingTech2
{
    pass P0{
    	// compiler directives
        VertexShader = compile vs_3_0 ACTUAL_AVG_VS();
        PixelShader  = compile ps_3_0 ACTUAL_AVG_PS2();
    }
}
technique BRDFShader
{
    pass P0{
    	// compiler directives
        VertexShader = compile vs_3_0 BRDFMAP_VS();
        PixelShader  = compile ps_3_0 BRDFMAP_PS();
    }
}