Sorry your browser is not supported!

    float4 worldPosition = mul(float4(input.Position.xyz,1), World);

    output.Depth.x = output.Position.z;
    output.Depth.y = output.Position.w;

//or 

output.Depth = input.Depth.x / input.Depth.y;


//and then reconstruct like this?

    //read depth
    float depthVal = tex2D(depthSampler,texCoord).r;

// Green Gandalf's basic shadow mapping shader with alpha mapping
// Created 21 October 2009, edited 23 October 2009.

// Uses ideas and some code from:
//       MS DX9 SDK shadow mapping demo    "ShadowMap.fx"
//       nVidia shadow mapping demo        "shadRPortHW.fx"
//       EVOLVED's shadow mapping demo     "ShadowMapping.fx"
// plus some suggestions from Math89.

// Tested using DBPro objects with "set object transparency objId, 6".


float4x4 wvp  :  WorldViewProjection;
float4x4 mw   :  World;
float4x4 winv : WorldInverse;
float4x4 lightProjMatrix : LightViewProjection;


float4x4 texMat = { 0.5, 0.0, 0.0, 0.5,
                    0.0,-0.5, 0.0, 0.5,
                    0.0, 0.0, 0.5, 0.5,
                    0.0, 0.0, 0.0, 1.0};

float4 filterSamples[16] = {-1.5, -1.5, 0.0, 0.0,
                            -0.5, -1.5, 0.0, 0.0,
                             0.5, -1.5, 0.0, 0.0,
                             1.5, -1.5, 0.0, 0.0,
                            -1.5, -0.5, 0.0, 0.0,
                            -0.5, -0.5, 0.0, 0.0,
                             0.5, -0.5, 0.0, 0.0,
                             1.5, -0.5, 0.0, 0.0,
                            -1.5,  0.5, 0.0, 0.0,
                            -0.5,  0.5, 0.0, 0.0,
                             0.5,  0.5, 0.0, 0.0,
                             1.5,  0.5, 0.0, 0.0,
                            -1.5,  1.5, 0.0, 0.0,
                            -0.5,  1.5, 0.0, 0.0,
                             0.5,  1.5, 0.0, 0.0,
                             1.5,  1.5, 0.0, 0.0
                           };
//float shadowMapSize = 512.0;
//float filterWidth = 0.001953125; // = 1.0/512;

float shadowMapSize = 1024.0;
//float filterWidth = 0.0009765625;// = 1.0/1024.0;
//float shadowMapSize = 2048.0;

float4 ambient = {0.5, 0.5, 0.5, 1.0};  
float4 lightCol = {1.0, 1.0, 1.0, 1.0};
float4 lightDir   = {0.0f, -1.0f, 0.0f, 1.0f};

float4 lightPos = {0.0, 0.0, 0.0, 0.001};  // 4th entry is reciprocal of light range
float nearDist = 0.0; // estimate of distance of closest object to the light
float lightProjScale =  0.002; // reciprocal of max likely distance of shadow from light less nearDist (default 500 - 0)
float alphaMin = 0.1;
float specLevel  = 0.025;
float specExpon=1.0;


texture baseTexture < string ResourceName=""; >;
sampler baseSample = sampler_state
{ texture = <baseTexture>;
  minFilter = linear;
  magFilter = linear;
  mipFilter = linear;
  addressU = wrap;
  addressV = wrap;
};


texture baseNormal < string ResourceName=""; >;
sampler normalSample = sampler_state
{ texture = <baseNormal>;
  minFilter = linear;
  magFilter = linear;
  mipFilter = linear;
  addressU = wrap;
  addressV = wrap;
};


sampler baseSampleAlpha = sampler_state
{ texture = <baseTexture>;
  minFilter = linear;
  magFilter = linear;
  mipFilter = linear; // default mipmapping makes alpha mapped leaves disappear in the distance
  addressU = wrap;
  addressV = wrap;
};

texture shadowMap < string ResourceName=""; >;	
sampler depthSample = sampler_state
{ texture = <shadowMap>;
  minFilter = none;
  magFilter = none;
  mipFilter = none;
  addressU = clamp;
  addressV = clamp;
};

struct VSInput
{ float4 pos    :  position;
  float2 UV     :  texcoord0;
  float3 normal :  normal;
  float3 Tangent :  TANGENT;
  float3 Binormal : BINORMAL;
  
  
  
};

struct VSOutDepth
{ float4 pos   :  position;
  float  depth :  texcoord0;
  float2 UV    :  texcoord1;
};

struct VSOutScene
{ float4 pos       :  position;
  float2 UV        :  texcoord0;
  float4 lightProj :  texcoord1;
  float3 normal    :  texcoord2;
  float depth      :  texcoord3;
  float3 lightDir  :  texcoord4;
  float3 Light        : TEXCOORD5;
  float3 View         : TEXCOORD6;
  
};

struct PSOutput { float4 col : color; };

VSOutDepth VSDepth( VSInput In, VSOutDepth Out )
{ float4 sPos = mul(In.pos, wvp);
  Out.pos = sPos;
  Out.depth = (sPos.z - nearDist) * lightProjScale; // try to aim for values in range 0.0 to 1.0
        
    //   float4 WPosP = mul(In.pos,mw); 
      // float4 Proj = mul(sPos,ProjMatrix); 
       //Out.depth = Proj.z; 
  
  
  
  return Out;
}

VSOutDepth VSDepthAlpha( VSInput In, VSOutDepth Out )
{ float4 sPos = mul(In.pos, wvp);
  Out.pos = sPos;
  Out.depth = (sPos.z - nearDist) * lightProjScale; // try to aim for values in range 0.0 to 1.0
  Out.UV = In.UV;
  return Out;
}

VSOutScene VSScene( VSInput In, VSOutScene Out )
{ Out.pos = mul(In.pos, wvp);
  Out.UV = In.UV;
  float4 wPos = mul(In.pos, mw);
  float4 lightProj = mul(wPos, lightProjMatrix);
  Out.lightProj = mul(texMat, lightProj); // convert to coords for projective texture lookup
  Out.normal = mul(In.normal, (float3x3) mw	);
  Out.depth = (Out.lightProj.z - nearDist) * lightProjScale - 0.01;
  Out.lightDir = lightPos.xyz - wPos.xyz;
  
 
    float3x3 TSM = {In.Tangent,In.Binormal,In.normal};
    TSM=transpose(TSM);
    float3 temp=-mul(lightDir.xyz,winv);
    Out.Light=mul(temp,TSM);
    temp=mul(lightPos,winv)-In.pos;
    Out.View=mul(temp,TSM);
 
    
  return Out;
}

PSOutput PSDepth( VSOutDepth In, PSOutput Out)
{ Out.col = In.depth;
  return Out;
}

PSOutput PSDepthAlpha( VSOutDepth In, PSOutput Out)
{ float alpha = tex2D(baseSampleAlpha, In.UV).a;
  clip(alpha - alphaMin);
  Out.col = float4 (In.depth.xxx, 1.0);
  return Out;
}

PSOutput PSScene0( VSOutScene In, PSOutput Out)
{ // no filtering of shadow edges
  float4 base = tex2D(baseSample, In.UV);
  float shadow = tex2Dproj(depthSample, In.lightProj).r < In.depth ? 0.0 : 1.0;
  float attenuation = saturate(1.0 - length(In.lightDir) * lightPos.w);
  //float diffuse = saturate(dot(normalize(In.lightDir), normalize(In.normal))) * attenuation;
  
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
  Out.col =  saturate( base * (ambient + diffuse * lightCol* shadow ) +specular );
  return Out;
}

PSOutput PSScene0Alpha( VSOutScene In, PSOutput Out)
{ // no filtering of shadow edges
  float4 base = tex2D(baseSampleAlpha, In.UV);
  float shadow = tex2Dproj(depthSample, In.lightProj).r < In.depth ? 0.0 : 1.0;
  float attenuation = saturate(1.0 - length(In.lightDir) * lightPos.w);
  //float diffuse = saturate(dot(normalize(In.lightDir), normalize(In.normal))) * attenuation;
 // float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
  ///float4 light = saturate(lightCol  * diffuse * shadow + ambient);
  //Out.col = float4(base.rgb * light.rgb, base.a);
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
  Out.col =  saturate( base * (ambient + diffuse * lightCol* shadow ) +specular );
  
  return Out;
}

PSOutput PSScene8( VSOutScene In, PSOutput Out)
{ // 4x4 PCF with bi-linear filtered shadow map lookup
  float4 base = tex2D(baseSample, In.UV);
  float2 texelPos = shadowMapSize * In.lightProj.xy / In.lightProj.w + float2(-0.5, 0.5) ;
  float2 lerps = frac( texelPos );
  // start with central 4 texels
  float offsetScale = 1.0/shadowMapSize * In.lightProj.w;
  float shadow = (tex2Dproj(depthSample, In.lightProj + filterSamples[5] * offsetScale).r < In.depth ? 1.0 : 0.0)
              + (tex2Dproj(depthSample, In.lightProj + filterSamples[6] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[9] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[10] * offsetScale).r < In.depth ? 1.0 : 0.0);
  // next add in the 4 corners
  float a1 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[0] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[3] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  float a2 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[12] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[15] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  shadow += lerp(a1, a2, lerps.y);
  
  // now add left and right edges
  a1 = (tex2Dproj(depthSample, In.lightProj + filterSamples[4] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[8] * offsetScale).r < In.depth ? 1.0 : 0.0);
  a2 = (tex2Dproj(depthSample, In.lightProj + filterSamples[7] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[11] * offsetScale).r < In.depth ? 1.0 : 0.0);
  shadow += lerp(a1, a2, lerps.x);
  // finally add in top and bottom edges
  a1 = (tex2Dproj(depthSample, In.lightProj + filterSamples[1] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[2] * offsetScale).r < In.depth ? 1.0 : 0.0);
  a2 = (tex2Dproj(depthSample, In.lightProj + filterSamples[13] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[14] * offsetScale).r < In.depth ? 1.0 : 0.0);
  shadow += lerp(a1, a2, lerps.y);
  
  // calculate weighted mean
  //invert shadow and lighten to make it look correct
  shadow = 1.0 - shadow * 0.111111111;

 
 
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
   
  
  
  Out.col =  saturate( base * (ambient + diffuse * lightCol * shadow) +specular );
  return Out;
}


PSOutput PSScene8Alpha( VSOutScene In, PSOutput Out)
{ // 4x4 PCF with bi-linear filtered shadow map lookup
  float4 base = tex2D(baseSampleAlpha, In.UV);
  float2 texelPos = shadowMapSize * In.lightProj.xy / In.lightProj.w + float2(-0.5, 0.5) ;
  float2 lerps = frac( texelPos );
  // start with central 4 texels
  float offsetScale = 1.0/shadowMapSize * In.lightProj.w;
  float shadow = (tex2Dproj(depthSample, In.lightProj + filterSamples[5] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[6] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[9] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[10] * offsetScale).r < In.depth ? 1.0 : 0.0);
  // next add in the 4 corners
  float a1 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[0] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[3] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  float a2 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[12] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[15] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  shadow += lerp(a1, a2, lerps.y);
  // now add left and right edges
  a1 = (tex2Dproj(depthSample, In.lightProj + filterSamples[4] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[8] * offsetScale).r < In.depth ? 1.0 : 0.0);
  a2 = (tex2Dproj(depthSample, In.lightProj + filterSamples[7] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[11] * offsetScale).r < In.depth ? 1.0 : 0.0);
  shadow += lerp(a1, a2, lerps.x);
  // finally add in top and bottom edges
  a1 = (tex2Dproj(depthSample, In.lightProj + filterSamples[1] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[2] * offsetScale).r < In.depth ? 1.0 : 0.0);
  a2 = (tex2Dproj(depthSample, In.lightProj + filterSamples[13] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[14] * offsetScale).r < In.depth ? 1.0 : 0.0);
  shadow += lerp(a1, a2, lerps.y);
  // calculate weighted mean
  shadow = 1.0 - shadow * 0.111111111;
 // float attenuation = saturate(1.0 - length(In.lightDir) * lightPos.w);
  //float diffuse = saturate(dot(normalize(In.lightDir), normalize(In.normal))) * attenuation;
  //float4 light = saturate(lightCol  * diffuse * shadow + ambient);
  //Out.col = float4 (base.rgb * light.rgb, base.a);
  
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
   
   //Out.col = saturate( base * (ambient + diffuse * lightCol* shadow ) + specular * lightCol);
  //Out.col =  saturate( base * (ambient + diffuse * lightCol* shadow ) +specular* lightCol );
  Out.col =  saturate( base * (ambient + diffuse * lightCol* shadow ) +specular );
  
  
  return Out;
}

technique shadow
{ pass p1
  { vertexShader = compile vs_2_0 VSDepth();
    pixelShader  = compile ps_2_0 PSDepth();
  }
}

technique shadowAlpha
{ pass p1
  { vertexShader = compile vs_2_0 VSDepthAlpha();
    pixelShader  = compile ps_2_0 PSDepthAlpha();
  }
}


technique scene0
// unfiltered shadow map lookup
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_0 PSScene0();
  }
}

technique scene8
// 4x4 PCF with bi-linear filtered shadow map lookup 
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_a PSScene8();
  }
}



technique scene0Alpha
// unfiltered shadow map lookup
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_0 PSScene0Alpha();
  }
}

technique scene8Alpha
// 4x4 PCF with bi-linear filtered shadow map lookup 
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_a PSScene8Alpha();
  }
}

float3 eyePos : CameraPosition;

float4 eyePos : CameraPosition;

//
// Green Gandalf's Bumpmapper v1.4
//
// Created 27 June 2006,    Modified 2 August 2009.
//
// Bumpmapping using a texture and normal map with a single directional light source
// plus ambient light and specular reflection.
// Uses full normalization in the pixel shader.
//
// Contains two techniques:
//   t0 - standard normal mapping suitable for simple objects such as cubes
//   t1 - improved normal mapping suitable for objects such as DBPro spheres
//        which might contain seams.
//
// Special thanks to Morcilla of MPL3D for some useful corrections.

matrix wvp : WorldViewProjection;
matrix mworld : World;
matrix winv: WorldInverse;
float4 eyePos : CameraPosition;

texture baseTexture < string ResourceName = ""; >;
texture nMapTexture < string ResourceName = ""; >;

sampler baseSample = sampler_state 
{ texture = <baseTexture>;
  mipFilter = linear;
  magFilter = linear;
  minFilter = linear;
};
sampler nMapSample = sampler_state 
{ texture = <nMapTexture>;
  mipFilter = linear;
  magFilter = linear;
  minFilter = linear;
};

float4 lightDir   = {-1.0, 0.0, 0.0, 1.0};
float4 ambiColor  = {0.2, 0.2, 0.2, 1.0};
float4 lightColor = {1.0, 1.0, 1.0, 1.0};
float specLevel  = 0.5;
float specExpon = 10.0;

struct VSInput
{ float4 pos          : position;
  float2 UV           : texcoord0;
  float3 tangent      : tangent;
  float3 binormal     : binormal;
  float3 normal       : normal;
};

struct VSOutput
{ float4 pos          : position;
  float2 UV           : texcoord0;
  float3 light        : texcoord1;
  float3 view         : texcoord2;
};

VSOutput GGBumpVShader0(VSInput In, VSOutput Out)
{ Out.pos = mul(In.pos, wvp);
  Out.UV = In.UV;
  // normalize everything just in case
  float3 n = normalize(In.normal);
  float3 t = normalize(In.tangent);
  float3 b = normalize(In.binormal);
  float3x3 TSM = {t, b, n};
  TSM = transpose(TSM);  
  float3 temp = -mul(lightDir.xyz, winv);  
  Out.light = mul(temp, TSM);  
  temp = (mul(eyePos, winv) - In.pos).xyz;
  Out.view = mul(temp, TSM);
  return Out;
}

VSOutput GGBumpVShader1(VSInput In, VSOutput Out)
{ Out.pos = mul(In.pos, wvp);
  Out.UV = In.UV;
  // adjust tangents and binormals - GG fix for seams on DBPro spheres
  float3 n = normalize(In.normal);
  float3 b = normalize(cross(n, In.tangent));
  float3 t = normalize(cross(b, n));
  float3x3 TSM = {t, b, n};
  TSM = transpose(TSM);  
  float3 temp = -mul(lightDir.xyz, winv);  
  Out.light = mul(temp, TSM);  
  temp = (mul(eyePos, winv) - In.pos).xyz;
  Out.view = mul(temp, TSM);
  return Out;
}

struct PSInput
{ float2 UV           : texcoord0;
  float3 light        : texcoord1;
  float3 view         : texcoord2;
};

struct PSOutput { float4 col : color; };

PSOutput GGBumpPShader(PSInput In, PSOutput Out)
{ float4 baseColour = tex2D(baseSample, In.UV);
  float3 normal     = 2 * tex2D(nMapSample, In.UV) - 1.0;
  float3 tempLightDir = normalize(In.light);
  float3 tempViewDir  = normalize(In.view);
  float diffuse       = saturate(dot(normal, tempLightDir));
  float3 reflect      = 2 * diffuse * normal - tempLightDir;
  float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)), specExpon);
  Out.col = baseColour * (ambiColor + diffuse * lightColor) + specular * lightColor;
  return Out;
}

technique t0
{ pass p0
  { VertexShader = compile vs_2_0 GGBumpVShader0();
    PixelShader = compile ps_2_0 GGBumpPShader();
  }
}

technique t1
{ pass p0
  { VertexShader = compile vs_2_0 GGBumpVShader1();
    PixelShader = compile ps_2_0 GGBumpPShader();
  }
}

// Green Gandalf's basic shadow mapping shader with alpha mapping
// Created 21 October 2009, edited 23 October 2009.

// Uses ideas and some code from:
//       MS DX9 SDK shadow mapping demo    "ShadowMap.fx"
//       nVidia shadow mapping demo        "shadRPortHW.fx"
//       EVOLVED's shadow mapping demo     "ShadowMapping.fx"
// plus some suggestions from Math89.

// Tested using DBPro objects with "set object transparency objId, 6".


float4x4 wvp  :  WorldViewProjection;
float4x4 mw   :  World;
float4x4 winv : WorldInverse;
float4x4 lightProjMatrix : LightViewProjection;
float4 CamPos : CameraPosition;


float4x4 texMat = { 0.5, 0.0, 0.0, 0.5,
                    0.0,-0.5, 0.0, 0.5,
                    0.0, 0.0, 0.5, 0.5,
                    0.0, 0.0, 0.0, 1.0};

float4 filterSamples[16] = {-1.5, -1.5, 0.0, 0.0,
                            -0.5, -1.5, 0.0, 0.0,
                             0.5, -1.5, 0.0, 0.0,
                             1.5, -1.5, 0.0, 0.0,
                            -1.5, -0.5, 0.0, 0.0,
                            -0.5, -0.5, 0.0, 0.0,
                             0.5, -0.5, 0.0, 0.0,
                             1.5, -0.5, 0.0, 0.0,
                            -1.5,  0.5, 0.0, 0.0,
                            -0.5,  0.5, 0.0, 0.0,
                             0.5,  0.5, 0.0, 0.0,
                             1.5,  0.5, 0.0, 0.0,
                            -1.5,  1.5, 0.0, 0.0,
                            -0.5,  1.5, 0.0, 0.0,
                             0.5,  1.5, 0.0, 0.0,
                             1.5,  1.5, 0.0, 0.0
                           };
//float shadowMapSize = 512.0;
//float filterWidth = 0.001953125; // = 1.0/512;

float shadowMapSize = 1024.0;
//float filterWidth = 0.0009765625;// = 1.0/1024.0;
//float shadowMapSize = 2048.0;

float4 ambient = {0.2, 0.2, 0.2, 1.0};  
float4 lightCol = {1.0, 1.0, 1.0, 1.0};
float4 lightDir   = {0.0f, -1.0f, 0.0f, 1.0f};

float4 lightPos = {0.0, 0.0, 0.0, 0.002};  // 4th entry is reciprocal of light range
//float4 CamPos = {0.0, 0.0, 0.0, 0.0};  // camera position
float nearDist = 150.0; // estimate of distance of closest object to the light
float lightProjScale =  0.002; // reciprocal of max likely distance of shadow from light less nearDist (default 500 - 0)
float alphaMin = 0.1;
float specLevel  = 0.25;
float specExpon=1.0;


texture baseTexture < string ResourceName=""; >;
sampler baseSample = sampler_state
{ texture = <baseTexture>;
  minFilter = linear;
  magFilter = linear;
  mipFilter = linear;
  addressU = wrap;
  addressV = wrap;
};


texture shadowMap < string ResourceName=""; >;	
sampler depthSample = sampler_state
{ texture = <shadowMap>;
  minFilter = none;
  magFilter = none;
  mipFilter = none;
  addressU = clamp;
  addressV = clamp;
};



texture baseNormal < string ResourceName=""; >;
sampler normalSample = sampler_state
{ texture = <baseNormal>;
  minFilter = linear;
  magFilter = linear;
  mipFilter = linear;
  addressU = wrap;
  addressV = wrap;
};
struct VSInput
{ float4 pos    :  position;
  float2 UV     :  texcoord0;
  float3 normal :  normal;
  float3 Tangent :  TANGENT;
  float3 Binormal : BINORMAL;
  
  
  
};

struct VSOutDepth
{ float4 pos   :  position;
  float  depth :  texcoord0;
  float2 UV    :  texcoord1;
};

struct VSOutScene
{ float4 pos       :  position;
  float2 UV        :  texcoord0;
  float4 lightProj :  texcoord1;
  float3 normal    :  texcoord2;
  float depth      :  texcoord3;
  float3 lightDir  :  texcoord4;
  float3 Light        : TEXCOORD5;
  float3 View         : TEXCOORD6;
  
};

struct PSOutput { float4 col : color; };

VSOutDepth VSDepth( VSInput In, VSOutDepth Out )
{ float4 sPos = mul(In.pos, wvp);
  Out.pos = sPos;
  Out.depth = (sPos.z - nearDist) * lightProjScale; // try to aim for values in range 0.0 to 1.0
        
    //   float4 WPosP = mul(In.pos,mw); 
      // float4 Proj = mul(sPos,ProjMatrix); 
       //Out.depth = Proj.z; 
  
  
  
  return Out;
}

VSOutDepth VSDepthAlpha( VSInput In, VSOutDepth Out )
{ float4 sPos = mul(In.pos, wvp);
  Out.pos = sPos;
  Out.depth = (sPos.z - nearDist) * lightProjScale; // try to aim for values in range 0.0 to 1.0
  Out.UV = In.UV;
  return Out;
}

VSOutScene VSScene( VSInput In, VSOutScene Out )
{ Out.pos = mul(In.pos, wvp);
  Out.UV = In.UV;
  float4 wPos = mul(In.pos, mw);
  float4 lightProj = mul(wPos, lightProjMatrix);
  Out.lightProj = mul(texMat, lightProj); // convert to coords for projective texture lookup
  Out.normal = mul(In.normal, (float3x3) mw	);
  Out.depth = (Out.lightProj.z - nearDist) * lightProjScale - 0.01;
  Out.lightDir = lightPos.xyz - wPos.xyz;
  
 
    float3x3 TSM = {In.Tangent,In.Binormal,In.normal};
    TSM=transpose(TSM);
    float3 temp=-mul(lightDir.xyz,winv);
    Out.Light=mul(temp,TSM);
//    temp=mul(CamPos,winv)-In.pos;
    temp = (mul(CamPos, winv) - In.pos).xyz;

    Out.View=mul(temp,TSM);
 
    
  return Out;
}

PSOutput PSDepth( VSOutDepth In, PSOutput Out)
{ Out.col = In.depth;
  return Out;
}

PSOutput PSDepthAlpha( VSOutDepth In, PSOutput Out)
{ 
  float alpha = tex2D(baseSample, In.UV).rgba;
  //float alpha = tex2D(baseSampleAlpha, In.UV).a;
  	//color key code
	 if(alpha.r == 0)    
	 {
		alpha = -1.0;
		clip(alpha);
	 }     	

  Out.col = float4 (In.depth.xxx, 1.0);
  return Out;
}

PSOutput PSScene0( VSOutScene In, PSOutput Out)
{ // no filtering of shadow edges
  float4 base = tex2D(baseSample, In.UV).rgba;
  //clip(base-0.03);
  
  	//color key code
	 if(base.r == 0)    
	 {
		base = -1.0;
		clip(base);
	 }     	

  
  
  
  //tex2Dproj(depthSample, In.lightProj).r < In.depth ? 0.0 : 1.0;
  float shadow = tex2Dproj(depthSample, In.lightProj).r < In.depth ? 0.0 : 1.0;
  float attenuation = saturate(1.0 - length(In.lightDir) * lightPos.w);
  //float diffuse = saturate(dot(normalize(In.lightDir), normalize(In.normal))) * attenuation;
  
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
  Out.col =  base * (ambient + diffuse * lightCol * shadow) + specular * lightCol;
  return Out;
}

PSOutput PSScene0Alpha( VSOutScene In, PSOutput Out)
{ // no filtering of shadow edges
  float4 base = tex2D(baseSample, In.UV);
  
  float shadow = tex2Dproj(depthSample, In.lightProj).r < In.depth ? 0.0 : 1.0;
  float attenuation = saturate(1.0 - length(In.lightDir) * lightPos.w);
  //float diffuse = saturate(dot(normalize(In.lightDir), normalize(In.normal))) * attenuation;
 // float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
  ///float4 light = saturate(lightCol  * diffuse * shadow + ambient);
  //Out.col = float4(base.rgb * light.rgb, base.a);
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
  Out.col =  base * (ambient + diffuse * lightCol * shadow) + specular * lightCol;
  
  return Out;
}

PSOutput PSScene8( VSOutScene In, PSOutput Out)
{ // 4x4 PCF with bi-linear filtered shadow map lookup
  float4 base = tex2D(baseSample, In.UV);
   	//color key code
	 if(base.r == 0)    
	 {
		base = -1.0;
		clip(base);
	 }     	

  float2 texelPos = shadowMapSize * In.lightProj.xy / In.lightProj.w + float2(-0.5, 0.5) ;
  float2 lerps = frac( texelPos );
  // start with central 4 texels
  float offsetScale = 1.0/shadowMapSize * In.lightProj.w;
  float shadow = (tex2Dproj(depthSample, In.lightProj + filterSamples[5] * offsetScale).r < In.depth ? 1.0 : 0.0)
              + (tex2Dproj(depthSample, In.lightProj + filterSamples[6] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[9] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[10] * offsetScale).r < In.depth ? 1.0 : 0.0);
  // next add in the 4 corners
  float a1 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[0] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[3] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  float a2 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[12] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[15] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  shadow += lerp(a1, a2, lerps.y);
  
  // now add left and right edges
 float a3 = (tex2Dproj(depthSample, In.lightProj + filterSamples[4] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[8] * offsetScale).r < In.depth ? 1.0 : 0.0);
 float a4 = (tex2Dproj(depthSample, In.lightProj + filterSamples[7] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[11] * offsetScale).r < In.depth ? 1.0 : 0.0);
  shadow += lerp(a3, a4, lerps.x);
  // finally add in top and bottom edges
  float a5 = (tex2Dproj(depthSample, In.lightProj + filterSamples[1] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[2] * offsetScale).r < In.depth ? 1.0 : 0.0);
  float a6 = (tex2Dproj(depthSample, In.lightProj + filterSamples[13] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[14] * offsetScale).r < In.depth ? 1.0 : 0.0);
//  shadow += (a1 + a2 + a3 + a4 + a5 + a6 + shadow)/7.0 ;
//  shadow = 1.0 - shadow * 0.1;
  
  shadow += lerp(a5, a6, lerps.y);
  
  // calculate weighted mean
  //invert shadow and lighten to make it look correct
  shadow = 1.0 - shadow * 0.1;

 
 
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
   
  
  
  Out.col =  base * (ambient + diffuse * lightCol * shadow) + specular * lightCol;

  //saturate( base * (ambient + diffuse * lightCol * shadow) +specular );
  return Out;
}


PSOutput PSScene8Alpha( VSOutScene In, PSOutput Out)
{ // 4x4 PCF with bi-linear filtered shadow map lookup
  //float4 base = tex2D(baseSampleAlpha, In.UV);
  float4 base = tex2D(baseSample, In.UV);
  
  clip(base-0.03);
  
  float2 texelPos = shadowMapSize * In.lightProj.xy / In.lightProj.w + float2(-0.5, 0.5) ;
  float2 lerps = frac( texelPos );
  // start with central 4 texels
  float offsetScale = 1.0/shadowMapSize * In.lightProj.w;
  float shadow = (tex2Dproj(depthSample, In.lightProj + filterSamples[5] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[6] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[9] * offsetScale).r < In.depth ? 1.0 : 0.0)
               + (tex2Dproj(depthSample, In.lightProj + filterSamples[10] * offsetScale).r < In.depth ? 1.0 : 0.0);
  // next add in the 4 corners
  float a1 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[0] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[3] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  float a2 = lerp(tex2Dproj(depthSample, In.lightProj + filterSamples[12] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  tex2Dproj(depthSample, In.lightProj + filterSamples[15] * offsetScale).r < In.depth ? 1.0 : 0.0,
                  lerps.x);
  shadow += lerp(a1, a2, lerps.y);
  // now add left and right edges
  a1 = (tex2Dproj(depthSample, In.lightProj + filterSamples[4] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[8] * offsetScale).r < In.depth ? 1.0 : 0.0);
  a2 = (tex2Dproj(depthSample, In.lightProj + filterSamples[7] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[11] * offsetScale).r < In.depth ? 1.0 : 0.0);
  shadow += lerp(a1, a2, lerps.x);
  // finally add in top and bottom edges
  a1 = (tex2Dproj(depthSample, In.lightProj + filterSamples[1] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[2] * offsetScale).r < In.depth ? 1.0 : 0.0);
  a2 = (tex2Dproj(depthSample, In.lightProj + filterSamples[13] * offsetScale).r < In.depth ? 1.0 : 0.0)
     + (tex2Dproj(depthSample, In.lightProj + filterSamples[14] * offsetScale).r < In.depth ? 1.0 : 0.0);
  shadow += lerp(a1, a2, lerps.y);
  // calculate weighted mean
  shadow = 1.0 - shadow * 0.111111111;
 // float attenuation = saturate(1.0 - length(In.lightDir) * lightPos.w);
  //float diffuse = saturate(dot(normalize(In.lightDir), normalize(In.normal))) * attenuation;
  //float4 light = saturate(lightCol  * diffuse * shadow + ambient);
  //Out.col = float4 (base.rgb * light.rgb, base.a);
  
   float3 normal     = 2 * tex2D(normalSample, In.UV) - 1.0;
   float3 tempLightDir = normalize(In.Light);
   float3 tempViewDir  = normalize(In.View);
   float diffuse       = saturate(dot(normal, tempLightDir));
   float3 reflect      = 2 * diffuse * normal - tempLightDir;
   float specular = diffuse * specLevel * pow(saturate(dot(reflect, tempViewDir)),specExpon);
   
   //Out.col = saturate( base * (ambient + diffuse * lightCol* shadow ) + specular * lightCol);
  //Out.col =  saturate( base * (ambient + diffuse * lightCol* shadow ) +specular* lightCol );
  
  float4 final = base * (ambient + diffuse * lightCol * shadow) + specular * lightCol;
  
  
  
  Out.col =  final;
  
  
  return Out;
}

technique shadow
{ pass p1
  { vertexShader = compile vs_2_0 VSDepth();
    pixelShader  = compile ps_2_0 PSDepth();
  }
}

technique shadowAlpha
{ pass p1
  { vertexShader = compile vs_2_0 VSDepthAlpha();
    pixelShader  = compile ps_2_0 PSDepthAlpha();
  }
}


technique scene0
// unfiltered shadow map lookup
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_0 PSScene0();
  }
}

technique scene8
// 4x4 PCF with bi-linear filtered shadow map lookup 
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_a PSScene8();
  }
}



technique scene0Alpha
// unfiltered shadow map lookup
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_0 PSScene0Alpha();
  }
}

technique scene8Alpha
// 4x4 PCF with bi-linear filtered shadow map lookup 
{ pass p1
  { vertexShader = compile vs_2_0 VSScene();
    pixelShader  = compile ps_2_a PSScene8Alpha();
  }
}

float4 final = base * (ambient + diffuse * lightCol * shadow) + specular * lightCol;

float4 final = base * (ambient + diffuse * lightCol * shadow) + specular * lightCol * shadow;

/*

  This effect will convert the pixel depth to the color, thus making it ideal for shadow map generation

*/

shared float4x4 g_mWorld : WORLD;      // World matrix
shared float4x4 g_mView  : VIEW;       // View matrix
shared float4x4 g_mProj  : PROJECTION; // Projection matrix

struct VS_OUTPUT
{
    float4 Position   : POSITION;   // vertex position 
    float2 Depth      : TEXCOORD0;  // z and w of vertex position
};


VS_OUTPUT VertScene( float4 vPos         : POSITION )
{
    VS_OUTPUT Out;

    // Transform the position from object space to homogeneous projection space
    Out.Position = mul( vPos, g_mWorld );
    Out.Position = mul( Out.Position, g_mView );
    Out.Position = mul( Out.Position, g_mProj );

    // Store z and w in the texture coordinate
    Out.Depth.xy = Out.Position.zw;

    return Out;
}


float4 PixScene( VS_OUTPUT In ) : COLOR0
{
    // Depth is z / w
    return In.Depth.x / In.Depth.y;
}


//--------------------------------------------------------------------------------------
// Techniques
//--------------------------------------------------------------------------------------
technique RenderScene
{
    pass P0
    {
        // Cull the front facing triangles, so that backfaces are used instead
        CullMode = 2; // 2 = Clock-wise, 3 = Counter clock-wise
        
		// Turn off alpha blending
		AlphaBlendEnable = false;
		
		// Set the vertex and pixel shaders
        VertexShader = compile vs_2_0 VertScene();
        PixelShader  = compile ps_2_0 PixScene();
    }
}

float4x4 World;
float4x4 View;
float4x4 Projection;


float4x4 InvertViewProjection; 
float4x4 InvertLightViewProjection; 


//depth textures
texture depthMap;
texture depthMap2;


sampler depthSampler = sampler_state
{
    Texture = (depthMap);
    AddressU = CLAMP;
    AddressV = CLAMP;
    MagFilter = POINT;
    MinFilter = POINT;
    Mipfilter = POINT;
};

sampler depthSampler2 = sampler_state
{
    Texture = (depthMap2);
    AddressU = CLAMP;
    AddressV = CLAMP;
    MagFilter = POINT;
    MinFilter = POINT;
    Mipfilter = POINT;
};





struct VertexShaderInput
{
    float3 Position : POSITION0;
};

struct VertexShaderOutput
{
    float4 Position : POSITION0;
    float4 ScreenPosition : TEXCOORD0;
    
};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
    VertexShaderOutput output;
    //processing geometry coordinates
    float4 worldPosition = mul(float4(input.Position,1), World);
    float4 viewPosition = mul(worldPosition, View);
    output.Position = mul(viewPosition, Projection);
    output.ScreenPosition = output.Position;
  
    
    return output;
}

float2 halfPixel;
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
    //obtain screen position
    input.ScreenPosition.xy /= input.ScreenPosition.w;


    //obtain textureCoordinates corresponding to the current pixel
    //the screen coordinates are in [-1,1]*[1,-1]
    //the texture coordinates need to be in [0,1]*[0,1]
    float2 texCoord = 0.5f * (float2(input.ScreenPosition.x,-input.ScreenPosition.y) + 1);
    //allign texels to pixels
    texCoord -=halfPixel;
    

    //read depth
    float depthVal = tex2D(depthSampler,texCoord).r;
    float depthVal2 = tex2D(depthSampler2,texCoord).r;
    

    //compute screen-space position
    float4 position;
    position.xy = input.ScreenPosition.xy;
    position.z = depthVal;
    position.w = 1.0f;
    
    float4 position2;
    position2.xy = input.ScreenPosition.xy;
    position2.z = depthVal2;
    position2.w = 1.0f;
    

    
    //transform to world space
    //position = mul(position, InvertViewProjection);
    //position /= position.w;
    //return position;
    
    


    
    //surface-to-light vector
    //float3 lightVector = lightPosition - position;

float color = 1.0f;
//tex2D( g_samShadow, ShadowTexC ) + SHADOW_BIAS < In.vPosLS.z / In.vPosLS.w)? 0.0f: 1.0f;  
if(depthVal < depthVal2) 
{
color = 0.1f;
}

//color = depthVal + depthVal2;
//color = position.z;

    float4 shadow = (color,color,color,color);
    //float4 shadow = (1,1,1,1);
    return shadow;
}

technique Technique1
{
    pass Pass1
    {
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 PixelShaderFunction();
	}
}

    #define WANT_NORMAL

    #include "animate.vsi"
    #include "transform.vsi"
    #include "light.vsi"
    #include "fog.vsi"
    #include "radiosity.vsi"
    #include "envmap.vsi"

    mov oT0.xy, iTex0