source: GTP/trunk/App/Demos/Illum/Standalone/StochasticIteration [DirectX]/hlsl.fx @ 1808

#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();
    }
}