float GetGaussianDistribution( float amount, float rho )
{
   float g = 1.0f / sqrt( 2.0f * 3.141592654f * rho * rho );
   return g * exp( -( amount * amount ) / (2 * rho * rho) );
}

void GetGaussianOffsets( bool bHorizontal, D3DXVECTOR2 vViewportTexelSize,
                         D3DXVECTOR2* vSampleOffsets, float* fSampleWeights )
{
   // Get the weights for the remaining taps
   for( int i = 0; i < 15; i += 2 )
   {
      fSampleWeights[i] = 2.0f * GetGaussianDistribution( 0.0f, float(i - 8 ), 3.0f );
   }
   // Get the center texel offset and weight
   fSampleWeights[8] = 1.0f * GetGaussianDistribution( 0, 0, 2.0f );
}

float g_viewPortTexelSizeX;  // vViewportTexelSize.x
float g_viewPortTexelSizeY;  // vViewportTexelSize.y


// Gaussian filter vertex shader
struct VSOUTPUT_BLUR
{
   float4 vPosition    : POSITION;
   float2 vTexCoord    : TEXCOORD0;
};

VSOUTPUT_BLUR VS_Blur( float4 inPosition : POSITION, float2 inTexCoord : TEXCOORD0 )
{
   // Output struct
   VSOUTPUT_BLUR OUT = (VSOUTPUT_BLUR)0;
   // Output the position
   OUT.vPosition = inPosition;
   // Output the texture coordinates
   OUT.vTexCoord = inTexCoord;
   return OUT;
}
// Horizontal blur pixel shader
float4 PS_BlurH( VSOUTPUT_BLUR IN ): COLOR0
{
   // Accumulated color
   float4 vAccum = float4( 0.0f, 0.0f, 0.0f, 0.0f );
   // Sample the taps (g_vSampleOffsets holds the texel offsets
   // and g_fSampleWeights holds the texel weights)
   for(int i = 0; i < 15; i++ )
   {
//      vAccum += tex2D( ScreenSampler, IN.vTexCoord + g_vSampleOffsets[i] ) * g_fSampleWeights[i];
      vAccum += tex2D( ScreenSampler, IN.vTexCoord + float2( 2.0f* (i-8) * g_viewPortSizeX, 0.0f ) * g_fSampleWeights[i];

   }
   return vAccum;
}
// Vertical blur pixel shader
float4 PS_BlurV( VSOUTPUT_BLUR IN ): COLOR0
{
   // Accumulated color
   float4 vAccum = float4( 0.0f, 0.0f, 0.0f, 0.0f );
   // Sample the taps (g_vSampleOffsets holds the texel offsets and
   // g_fSampleWeights holds the texel weights)
   for( int i = 0; i < 15; i++ )
   {
//      vAccum += tex2D( BlurHSampler, IN.vTexCoord + g_vSampleOffsets[i] ) * g_fSampleWeights[i];
      vAccum += tex2D( BlurHSampler, IN.vTexCoord + float2( 0.0f, 2.0f * (i-8) * g_viewPortSizeX ) * g_fSampleWeights[i];
   }
   return vAccum;
}

   // Sample each of them checking whether the pixel under test is shadowed or not
   float fShadowTerms[9];
   float fShadowTerm = 0.0f;
   for( int i = 0; i < 9; i++ )
   {
      float A = tex2Dproj( ShadowSampler, vTexCoords[i] ).r;
      float B = (IN.fDepth – 0.1f);

      // Texel is shadowed
      fShadowTerms[i] = A < B ? 0.0f : 1.0f;
      fShadowTerm     += fShadowTerms[i];
   }
   // Get the average
   fShadowTerm /= 9.0f;
   return fShadowTerm;

   // NB!! I use "p=" for plus equals, since the plus sign wasn't showing up
   //  in my previews
   float4 result = ambient * vColor;
   float nDotL = dot( IN.vNormal, IN.vLightVec )
   float diffuse  = 0.0f;
   if (nDotL > 0.0f)
   {
     // Grab the shadow term
     float fShadowTerm = tex2Dproj( BlurVSampler, IN.vScreenCoord );
     // Grab the spot term
     float fSpotTerm = tex2Dproj( SpotSampler, IN.vProjCoord );
     float intensity = fShadowTerm * fSpotTerm;
     if (intensity > (1.0f / 255.0f)) // minimum to effect 8-bit color
     {
       // add the diffuse term we know exists
       result += diffuse * intensity * g_vLightColor.a * vColor;

       float theta = dot (2 * nDotL * IN.vNormal - IN.vLightVec, IN.vEyeVec);
       if (theta > 0.0f)
       {
         float specular = pow(theta, 8);

         // add the specular term we know exists
         result += specular * intensity * g_vLightColor.a * vColor;
       }
     }
   }
  
   return result;