Notes on the softShadowSpot shader.
This shader is an implementation on the article in the SIGGRAPH 2006, course 25, Disney bonus section, “Shadow Map Bias Cone and Improved Soft Shadows”. The idea is the following. First, we sample the depth map to get the distance between the shading point and the point that casts the shadow, and we vary the blur size according to the ratio of these distances. Then, we resample the depth map (with variable search radius this time), and we give a bigger bias to the samples that are further to the shading point (creating a “cone” of sampling rather than a “disc”). This reduces the self-shadowing artifacts. And while we know the distance of the occluding object, we will try to add the capability to decrease the shadow opacity as this distance increases.
For readability, I’ll use “Ps” for the surface point currently being shaded, and “occluder” for the point which depth was stored in the depth map. I also tried to use “distance” as the 2d distance between two points on the depth map, as opposed to the “depth” in 3d space.
The procedures that this shader refer to are declared within the shader for conciseness reasons, and because they are designed for the specific needs of this shader, hence probably not useful elsewhere.
You can see the full shader code at the bottom of the page.
light
softShadowSpot( float intensity = 1;
color lightColor = 1;
float coneAngle = 35; // in degrees
float penumbraAngle = 5; // ourside the coneAngle
[…] )
{
uniform float illumAngle = radians( coneAngle/2 + penumbraAngle );
uniform float cosoutside = cos( illumAngle );
uniform float cosinside = cos( radians( coneAngle/2 ) );
uniform vector lightDir = vector "shader" ( 0,0,1 );
[…]
illuminate( point "shader" ( 0,0,0 ), lightDir, illumAngle )
{
Cl = 0;
float cosangle = normalize( L ).lightDir;
float atten = smoothstep( cosoutside, cosinside, cosangle );
float shadowValue = 0;
[…]
atten *= ( 1 - shadowValue );
Cl = intensity * lightColor * atten;
}
}
This doesn’t need much explanation. The reader will most likely have its own light shader that he may want to modify.
Here, we want to find the average distance between Ps and the occluder. We first need to find the depth of Ps.
// get the s and t coord of Ps on shadowmap
float pShadS, pShadT;
uniform matrix shadProjSpace;
textureinfo( shadowMap, "projectionmatrix", shadProjSpace );
point shadProjP = transform( shadProjSpace, Ps );
pShadS = ( 1 + xcomp( shadProjP ) ) * 0.5;
pShadT = ( 1 - ycomp( shadProjP ) ) * 0.5;
// get Ps distance from shadow plane
uniform matrix shadCamSpace;
textureinfo( shadowMap, "viewingmatrix", shadCamSpace );
point shadCamP = transform( shadCamSpace, Ps );
float PsDepth = zcomp( shadCamP );
Note: we can’t use L because the data stored in the depth map is the distance between the points and a plane (crossing the light), and not the distance of the light.
Then we sample the depth map around Ps and average the occluder depths. Note that is the depths found by the samples are larger than Ps’ depth, no occluder was found and the sample is discarded.
// get the average occluder depth in shadowmap around Ps
float avrgedDepth = 0;
float totalWeight = 0;
float iterator = 0;
for ( iterator = 0; iterator < samples; iterator += 1 )
{
float sampleDepth, distFromPs;
sampleDepth = sampleShadowMap( pShadS, pShadT, sampleCoordX[ iterator ], sampleCoordY[ iterator ], maxRadius, 0, distFromPs );
// weight according to raster distance from Ps coord
if ( (sampleDepth+bias) < PsDepth )
{
float sampleWeight = 1 - 0.9 * ( distFromPs / maxRadius );
totalWeight += sampleWeight;
avrgedDepth += ( sampleDepth * sampleWeight );
}
}
if ( totalWeight > 0 ) avrgedDepth /= totalWeight;
// _________________________________________
Where the sampleShadowMap function is defined as the following
/*
Function that samples the shadow map,
returns sampled depth and normalised raster distance of sample
*/
float sampleShadowMap( float pShadS; float pShadT; float sampleX; float sampleY; float radius; float uniformSampling; output float distFromPs )
{
extern string shadowMap;
// sample coord
float ss = sampleX;
float tt = sampleY;
HammersleyToRadial( uniformSampling, ss, tt );
ss *= radius;
tt *= radius;
ss += pShadS;
tt += pShadT;
// find distance from Ps coord
distFromPs = distance( point( pShadS, pShadT, 0), point( ss, tt, 0 ) );
// sample map without filtering
return texture( shadowMap, ss, tt, "width", 0.00001 , "samples", 1 ); // this will generate warnings at compilation time with 3Delight
}
// ___________________________________
We will talk later about sampleCoordX and sampleCoordY as well as the HammersleyToRadial function.
The sampling radius is user-defined with the maxRadius parameter.
The depths found are not averaged uniformly but rather have a stronger weight if they are closer to Ps (on the depth map).
We then compute the shadow blur width depending on the averaged occluder depth (the ratio between the occluder depth and Ps depth in fact, because it has to be relative to the position of the light).
// compute the radius of the filter
float filterRadius = minRadius + (( maxRadius-minRadius ) * ( 1 - ( avrgedDepth / PsDepth )));
minRadius is also a user-defined parameter.
We can now sample the depth map again with the search radius found in the preceding step, to find the shadowing value. The use of a shadow() shadeop (to which we pass varying “width” value) leads to unacceptable self-shadowing artifacts. The self-shadowing is being caused by points within the filter region, which are closer to the light plane (smaller depth in the map). We then need to sample the map with a custom loop, to add extra bias values to the samples that are further away from Ps’ coordinates on the depth map. The amount that is added to the sample’s bias is scaled by a user-defined parameter. It is called biasConeSlope here, but may eventually be named “selfShadowingReducer” in a more artist-friendly nomenclature.
// get the shadow occlusion of Ps
for ( iterator = 0; iterator < samples; iterator += 1 )
{
float sampleDepth, distFromPs;
sampleDepth = sampleShadowMap( pShadS, pShadT, sampleCoordX[ iterator ], sampleCoordY[ iterator ], filterRadius, 1, distFromPs );
// add bias cone
sampleDepth += bias + ( distFromPs * biasConeSlope );
if ( sampleDepth < PsDepth ) shadowValue += 1;
}
shadowValue /= samples;
Now that we have a prop soft shadow, we may use the knowledge to the depths of Ps and the occluder to modify the shadow opacity (the opacity decreasing as Ps moves away from the occluder). Different approaches may be implemented. In the presented version, the shadow opacity decreases linearly from a cut-on distance (shadDecayDistMin) to a cut-off distance (shadDecayDistMax). The amount of decrease is also user-defined (shadowDecay).
// decrease light attenuation as Ps moves further from occluder
if ( shadowDecay > 0 )
{
float distFromOccluder = PsDepth - avrgedDepth;
shadowValue *= 1 - ( smoothstep( shadDecayDistMin, shadDecayDistMax, distFromOccluder ) * shadowDecay );
}
The depth map generation is important to get correct values. The value used for the shadow decay should ideally be the distance between Ps and its closest occluder point. We obtain that when the depth map generation type is “max”, and if the occluding objects are double-sided.
The SIGGRAPH article on which this shader is based suggests the Hamersley Point Set for the generation of sample points. What I understand from the process is the following.
- From the user-defined number of samples that we want to generate, find how many digits it takes to represent this number in the binary form.
// find the num of decimals
uniform float numOfDecimals = ceil( log( samples, 2 ) );
Then, for every sample
- Convert the sample to a binary format
// generate binary fractions and their reversed
uniform float digit = 0;
uniform float remainder = iter;
for( decimal = (numOfDecimals - 1); digit >= 0; digit -= 1 )
{
uniform float power = pow( 2, digit);
if ( remainder >= power )
{
revBinValues[ digit] = 1;
remainder -= power;
}
else
revBinValues[ digit] = 0;
}
Note that the order of the digits is already reversed here.
- Reverse the binary digits to create a second number
- Make these numbers a fraction by placing them after the period
- Convert them back to floats and output the values.
// convert back to floats
uniform float x = 0;
uniform float y = 0;
uniform float index = 0;
for( index = 1; index <= numOfDecimals; index += 1 )
{
x += ( pow( 2, -index ) * revBinValues[ numOfDecimals-index ] );
y += ( pow( 2, -index ) * revBinValues[ index-1 ] );
}
Now, you will notice that the distribution of samples, always between 0 and 1, is almost evenly distributed. But this holds up only if the number of samples is a power of 2 (…, 16, 32, 64, 128…). Otherwise, the binary number (the x coordinate in this case) never goes as far as it can, given the number of digits.
We thus have to scale the x coordinate accordingly to keep it in its full range. This doesn’t happen for the reversed digits (the y coord) because they alternate naturally between low and high value (their first digit is always oscillating between 0 and 1).
Now that we have our samples in a unit square, let’s transfer the values to get radial coordinates. We want our samples to stay within a given radius around Ps (or the projection of Ps on the depth map, more precisely). We will use the x coordinate as angle and y as the radius. The x coordinate should be scale to 2p (or 360 degrees), and y to the given radius of the sampling disc.
float angleOfSample = sampleCoordX * 2 * PI;
sampleCoordX = cos( angleOfSample ) * sampleCoordY; // cos = adj / hypot
sampleCoordY = sqrt( pow( sampleCoordY, 2 ) - pow( sampleCoordX, 2 ) ); // a2 + b2 = c2
if( angleOfSample > PI )
sampleCoordY *= -1;
Notice that the samples are denser around the center. This is alright for the sampling of the average occluder distance (see the SIGGRAPH section), but we need an uniform distribution for the shadowing sampling. This is achieved by taking the square root of the y coordinate to compute the radius.
// if these samples are for light shadowing sampling
if ( shadowSampling == 1 ){
// samples should be evenly distributed
sampleCoordY = sqrt( sampleCoordY );
[…]
}
-This implementation does not currently supports deep shadow maps.
-The procedures that the shader calls are defined inside the shader. This choice was made for conciseness, and because they are more likely to be used exclusively by this shader.
-This was developed using 3Delight renderer.
-Brief benchmarking of this shader:
Normal z-depth Shadow Map
render time: 4.30 seconds
Soft Shadow Shader (z-depth Map)
render time: 46.58 seconds
Ray-traced Shadows (with equivalent -even lower- quality)
render time: 106.19 seconds
-The MEL script that I used to test the Hammersley distribution can be found here.
-The RSL code node that I used to test the Hammersley on a square patch can be found here.
This shader is an implementation of the SIGGRAPH 2006, course 25, “RenderMan For Everyone”, the Disney Bonus Section, “Shadow Map Bias Cone and Improved Soft Shadows”.
I used as reference this pdf.
-a web page of the RenderManAcademy.com ( archived here ) for the shadow map coordinates of Ps.
-Advanced Renderman for various principles and examples.
-The 3Delight renderer documentation for various syntaxes and examples.
-a web page of MathWorld for the Hammersley Point Set
Many thanks to Andreas Bauer, who explained to be how to convert to and from binary numbers, and helping me to understand the Hammersley Point Set principle.
- home - curriculum - competences - gallery -MEL scripts - shaders - contact - links -
