source: GTP/trunk/App/Demos/Illum/SoftShadowMap/Shaders/technique_06.fx @ 1637

// Percentage closer soft shadows
// nVidia implementation


// SHADOWMAP generation

//-----------------------------------------------------------------------------
// Vertex Shader: RenderShadowMap_06_VS
// Desc: Process vertex for the shadow map
//-----------------------------------------------------------------------------
void RenderShadowMap_06_VS(
                float4 Pos  : POSITION,
    out float4 oPos : POSITION,
    out float  hPos : TEXCOORD0 )
{
        oPos = mul( Pos, WorldLightProj );      // Compute the projected coordinates
    hPos = oPos.w;                                              // Store z in our spare texcoord
}

//-----------------------------------------------------------------------------
// Pixel Shader: RenderShadowMap_06_PS
// Desc: Process pixel for the shadow map
//-----------------------------------------------------------------------------
float4 RenderShadowMap_06_PS(
                float hPos : TEXCOORD0 ):COLOR
{
        return float4(hPos,0,0,0);
}


// SCENE RENDERING

//-----------------------------------------------------------------------------
// Vertex Shader: RenderSceneWithTechnique_06_VS
// Desc: Process vertex for scene
//-----------------------------------------------------------------------------
VS_OUTPUT RenderSceneWithTechnique_06_VS( VS_INPUT IN )
{
        VS_OUTPUT OUT = (VS_OUTPUT)0;
        OUT.Color = IN.Color;
        OUT.Tex = IN.Tex;

        // transform model-space vertex position to light's normalized device space:
        OUT.ldPosition = mul(IN.Position, WorldLightProj);

        // transform model-space vertex position to normalized screen space:
        OUT.hPosition = mul(IN.Position, WorldViewProj);
        return OUT;
}


//-----------------------------------------------------------------------------
// Pixel Shader: RenderSceneWithTechnique_06_PS
// Desc: PCF soft shadow
//-----------------------------------------------------------------------------
// -------------------------------------
// STEP 1: Search for potential blockers
// -------------------------------------
half findBlocker(
                half2 uv,
                half4 LP,
        half searchWidth )
{
        // divide filter width by number of samples to use
        half stepSize = 2 * searchWidth / g_iKernelSize;

        // compute starting point uv coordinates for search
        uv = uv - half2(searchWidth, searchWidth);

        // reset sum to zero
        half blockerSum = 0;
        half receiver = LP.z;
        half blockerCount = 0;
        half foundBlocker = 0;

        // iterate through search region and add up depth values
        for (int i=0; i<g_iKernelSize; i++) {
               for (int j=0; j<g_iKernelSize; j++) {
                       half shadMapDepth = tex2D(g_ShadowMapColorSampler, uv + half2(i*stepSize,j*stepSize)).x;
                       // found a blocker
                       if (shadMapDepth < receiver) {
                               blockerSum += shadMapDepth;
                               blockerCount++;
                               foundBlocker = 1;
                       }
               }
        }

                half result;
                
                if (foundBlocker == 0) {
                        // set it to a unique number so we can check
                        // later to see if there was no blocker
                        result = 999;
                }
                else {
                    // return average depth of the blockers
                        result = blockerSum / blockerCount;
                }
                
                return result;
}

// ------------------------------------------------
// STEP 2: Estimate penumbra based on
// blocker estimate, receiver depth, and light size
// ------------------------------------------------
half estimatePenumbra(
                half receiver,      // receiver depth
                half blocker )
{
       // estimate penumbra using parallel planes approximation
       return (receiver - blocker) * g_fLightSize / blocker;
}

// ----------------------------------------------------
// Step 3: Percentage-closer filter implementation with
// variable filter width and number of samples.
// This assumes a square filter with the same number of
// horizontal and vertical samples.
// ----------------------------------------------------

half PCF_Filter(
                half2 uv,
                half4 LP,
        half filterWidth )
{
       // compute step size for iterating through the kernel
       half stepSize = 2 * filterWidth / g_iKernelSize;

       // compute uv coordinates for upper-left corner of the kernel
       uv = uv - half2(filterWidth,filterWidth);

       half sum = 0;  // sum of successful depth tests

       // now iterate through the kernel and filter
       for (int i=0; i<g_iKernelSize; i++) {
           for (int j=0; j<g_iKernelSize; j++) {
               // get depth at current texel of the shadow map
               half shadMapDepth = 0;
               
               shadMapDepth = tex2D(g_ShadowMapColorSampler, uv + half2(i*stepSize,j*stepSize)).x;

               // test if the depth in the shadow map is closer than
               // the eye-view point
               half shad = LP.z < shadMapDepth;

               // accumulate result
               sum += shad;
           }
       }
       
       // return average of the samples
       return sum / (g_iKernelSize*g_iKernelSize);
}


float4 RenderSceneWithTechnique_06_PS( VS_OUTPUT IN ) : COLOR
{
        // Apply bias
        IN.ldPosition.z -= g_fShadowBias;
        
        // The soft shadow algorithm follows:

   // Compute uv coordinates for the point being shaded
   // Saves some future recomputation.
   half2 uv = half2(.5,-.5)*(IN.ldPosition.xy)/IN.ldPosition.w + half2( 0.5f + HALF_TEXEL, 0.5f + HALF_TEXEL );

   // ---------------------------------------------------------
   // Step 1: Find blocker estimate
   half blocker = findBlocker(uv, IN.ldPosition, g_fIntensity * g_fLightSize / IN.ldPosition.z );
   
   // ---------------------------------------------------------
   // Step 2: Estimate penumbra using parallel planes approximation
   half penumbra = estimatePenumbra( IN.ldPosition.z, blocker );

   // ---------------------------------------------------------
   // Step 3: Compute percentage-closer filter
   // based on penumbra estimate

   // Now do a penumbra-based percentage-closer filter
   half shadowed = PCF_Filter(uv, IN.ldPosition, penumbra );
   
   // If no blocker was found, just return 1.0
   // since the point isn't occluded
   if (blocker > 998) 
                shadowed = 1.0;

   // Visualize lighting and shadows
   if( shadowed < 1.0 )
   {
                shadowed *= g_fBiasSlope;
                if( shadowed > 1.0 )
                {
                        shadowed = 1.0;
                }
   }
   return tex2D(g_samScene, IN.Tex) * shadowed  * g_vMaterial;
}



// TECHNIQUE

//-----------------------------------------------------------------------------
// Techniques: RenderShadowMap
// Desc: Render the shadow map
//-----------------------------------------------------------------------------

technique RenderShadowMap_6
{
    pass p0
    {
        VertexShader = compile vs_2_0 RenderShadowMap_06_VS();
        PixelShader  = compile ps_2_0 RenderShadowMap_06_PS();
    }
}


technique RenderSceneWithTechnique_6
{
    pass p0
    {
        VertexShader = compile vs_2_0 RenderSceneWithTechnique_06_VS();
        PixelShader  = compile ps_3_0 RenderSceneWithTechnique_06_PS();
    }
}