I started this little rendering sandbox about 1 year ago. I started this blog at the same time to share about my progress and finding. So 1 year later I now have what looks like a basic modern rendering sandbox integrating my studied subjects. I experimented with a lot of concepts since my last post. I will quickly summarize all of them and share all the references I used for my implementation.
Author: Foogywoo
Playing with BRDF
Theory is one thing but there is nothing like practice and execution. It was time for me to spend sometime experimenting with more physically based BRDF models to get a better feel of how they work. Just for fun I started with Cook-Torrance using the Beckmann distribution, but like everybody I ended up using the GGX distribution for the microfacet slope distribution (D).
Some takeaway from this experiment:
- The application of the Fresnel term and the proper energy conservation really have an impressive visual impact.
- Even if the instruction count is higher then the good old Blinn-Phong the performance hit is not that high on modern GPU.
- Authoring and calibrating textures is hard, I ended up using DDO to have a good reference.
- You really need some environment reflection (which I don’t have for now) for the metals to look good since they don’t have a diffuse component.
- Not really specific to the BRDF model but the high constrast specular highlights don’t come out to good on the Rift DK1, revealing even more the pixel grid. Cannot wait to see how it will perform with the DK2.
- Goodbye Blinn-Phong.
The next step will be to add some IBL to handle indirect lighting and radiance properly. Those more realistic materials mixed with the lack of irradiance really give the impression that we are on the moon.
References:
D3DBook:(Lighting) Cook-Torrance
Optimizing GGX Shaders with dot(L,H)
Variance shadow maps
Variance shadow maps propose a way to soften shadow edges by allowing the use of standard filtering methods such as hardware linear interpolation and gaussian blur directly on shadow maps. The results are convincing and many options are available to tune the quality / performance ratio.
Concept
The variance shadow map technique have a statistical approach to shadow filtering. The problem is formulated this way: For a given point with a depth z, what is the percentage of points in a filtered shadow map that have a depth superior or equal to this z. The answer to this can be found with the Chebyshev inequality:
P() is the percentage of points that will fail the depth test. x is the depth. t is the fixed depth we are comparing to. σ2 is the variance (the standard deviation squared). µ is the mean.
The first important observation is that we are considering our shadow map to be filtered so after the filtering the depth value will become the mean. Now, we need to find how to retrieve the variance from a filtered shadow map. For this we need to remember that the variance can also be expressed as the mean of squares minus the squared mean.
σ2 = E[x2] - µ2
Knowing this, if we store the depth squared into our shadow maps, this value will become the mean of squares after filtering. Now that we know how to get all the terms needed for this inequation let’s see how the implementation will look like.
Basic implementation (opengl)
For the implementation I will assume that you already have basic shadow maps working. If you don’t, this tutorial is a very good starting point. So I will only highlight the implementation changes specific to VSM.
The first thing we need to change is the type of attachment for our shadow FBO. Since our depth pass now need to record both the depth and the squared depth we will attach a texture of type GL_RGB16F_ARB. Also, our depth attachment is not a texture but a RenderBuffer.
glGenFramebuffers(1, &frameBuffer); glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer); glGenTextures (1, &textureID); glBindTexture(GL_TEXTURE_2D, textureID); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB16F_ARB, 1024, 1024, 0, GL_RGB, GL_FLOAT, 0); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureID, 0); glGenRenderbuffers(1, &depthBuffer); glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer); glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, 1024, 1024); glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer);
Don’t forget to disable the compare function from your shadow map texture parameters and to switch your sampler from sampler2DShadow to sampler2D:
//glTexParameteri(mGLTexturetype, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); //glTexParameteri(mGLTexturetype, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
The shader for your depth pass will look like this:
vec4 recordDepth() { float depth = gl_FragCoord.z; float moment2 = depth * depth; return vec4(depth, moment2, 0.0, 0.0); }
The you compute the percentage of shadow using the Chebyshev inequality this way:
vec4 shadowCoordNDC = vShadowCoord / vShadowCoord.w; vec2 moments = texture2D(ShadowMap, shadowCoordNDC.xy).rg; if (distance <= moments.x) return 1.0; float variance = moments.y - (moments.x * moments.x); variance = max(variance, 0.0000005); float d = shadowCoordNDC.z - moments.x; float shadowPCT = variance / (variance + d*d);
Note that since we are not using the GLSL textureProj function, we need to apply the division by vShadowCoord.w ourself to transform to normalized device coordinate.
Results and options
(All results are rendered with a 1024×1024 shadow map)No filtering

This is what we get if we don’t perform any filtering on our shadow map. Not very interesting, we see very aliased shadow edges and some weird artifacts (near the base of the cube).
Linear interpolation
Linear interpolation and 5×5 Gaussian blur
Linear interpolation and 5×5 Gaussian blur, floor value

We can soften the depth precision artifact by setting a greater floor value to the variance in the shader. (variance = max(variance, 0.0005) )
Linear interpolation and 5×5 Gaussian blur, 32bit texture
Far away, anisotropic filtering

Using anisotropic filtering (x16) improve farther shadows a little bit. You could also try to turn on mipmap generations.
Limitations and improvements
//float p_max = variance / (variance + d*d); float p_max = smoothstep(0.20, 1.0, variance / (variance + d*d));
References
www.punkuser.net—vsm_paper.pdf