Implemented Variance Shadow Mapping

Author: htmlboss

MP-APS/.vs/MP-APS/v15/.suo

@@ -21,15 +21,15 @@ void RenderSystem::Init(const pugi::xml_node& rendererNode) {
 std::abort();
 }
 
+queryHardwareCaps();
+
 #ifdef _DEBUG
 std::cout << "OpenGL Version: " << glGetString(GL_VERSION) << '\n';
 std::cout << "GLSL Version: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << '\n';
 std::cout << "OpenGL Driver Vendor: " << glGetString(GL_VENDOR) << '\n';
 std::cout << "OpenGL Renderer: " << glGetString(GL_RENDERER) << '\n';
 #endif
 
-getHardwareFeatures();
-
 const auto width = rendererNode.attribute("width").as_uint();
 const auto height = rendererNode.attribute("height").as_uint();
 
@@ -145,7 +145,7 @@ void RenderSystem::Render(const Camera& camera, RenderListIterator renderListBeg
 glActiveTexture(GL_TEXTURE2);
 glBindTexture(GL_TEXTURE_2D, m_skybox.GetBRDFLUT());
 glActiveTexture(GL_TEXTURE7);
-glBindTexture(GL_TEXTURE_2D, m_shadowDepthTexture);
+glBindTexture(GL_TEXTURE_2D, m_shadowColorTexture);
 
 pbrShader.Bind();
 pbrShader.SetUniform("camPos", camera.GetPosition()).SetUniformi("wireframe", globalWireframe).SetUniform("lightSpaceMatrix", m_lightSpaceMatrix);
@@ -198,6 +198,12 @@ void RenderSystem::UpdateView(const Camera& camera) {
 glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(m_projMatrix));
 }
 
+/***********************************************************************************/
+void RenderSystem::queryHardwareCaps() {
+// Anisotropic filtering
+glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &m_caps.MaxAnisotropy);
+}
+
 /***********************************************************************************/
 void RenderSystem::setDefaultState() {
 glFrontFace(GL_CCW);
@@ -289,12 +295,12 @@ void RenderSystem::renderShadowMap(const SceneBase& scene, RenderListIterator re
 
 glCullFace(GL_FRONT); // Solve peter-panning
 glViewport(0, 0, m_shadowMapResolution, m_shadowMapResolution);
-m_shadowDepthFBO.Bind();
+m_shadowFBO.Bind();
 glClear(GL_DEPTH_BUFFER_BIT);
 
 renderModelsNoTextures(shadowDepthShader, renderListBegin, renderListEnd);
 
-m_shadowDepthFBO.Unbind();
+m_shadowFBO.Unbind();
 glViewport(0, 0, m_width, m_height);
 glCullFace(GL_BACK);
 }
@@ -327,33 +333,49 @@ void RenderSystem::setupTextureSamplers() {
 glSamplerParameteri(m_samplerPBRTextures, GL_TEXTURE_WRAP_T, GL_REPEAT);
 glSamplerParameteri(m_samplerPBRTextures, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 glSamplerParameteri(m_samplerPBRTextures, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-glSamplerParameterf(m_samplerPBRTextures, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_features.MaxAnisotropy);
+glSamplerParameterf(m_samplerPBRTextures, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_caps.MaxAnisotropy);
 
 }
 
 /***********************************************************************************/
 void RenderSystem::setupShadowMap() {
-m_shadowDepthFBO.Init("Shadow Depth FBO");
-m_shadowDepthFBO.Bind();
+const static float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
 
+m_shadowFBO.Init("Shadow Depth FBO");
+m_shadowFBO.Bind();
+
+// Depth texture
 if (m_shadowDepthTexture) {
 glDeleteTextures(1, &m_shadowDepthTexture);
 }
 glGenTextures(1, &m_shadowDepthTexture);
 glBindTexture(GL_TEXTURE_2D, m_shadowDepthTexture);
-glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_shadowMapResolution, m_shadowMapResolution, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
+glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, m_shadowMapResolution, m_shadowMapResolution, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); // Clamp to border to fix over-sampling
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
-const float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
-glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor); 
+glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
+
+// Colour texture for Variance Shadow Mapping (VSM)
+if (m_shadowColorTexture) {
+glDeleteTextures(1, &m_shadowColorTexture);
+}
+glGenTextures(1, &m_shadowColorTexture);
+glBindTexture(GL_TEXTURE_2D, m_shadowColorTexture);
+glTexImage2D(GL_TEXTURE_2D, 0, GL_RG32F, m_shadowMapResolution, m_shadowMapResolution, 0, GL_RGBA, GL_FLOAT, nullptr);
+glGenerateMipmap(GL_TEXTURE_2D);
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // Hardware linear filtering gives us soft shadows for free!
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); // Clamp to border to fix over-sampling
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, m_caps.MaxAnisotropy); // Anisotropic filtering for sharper angles
+glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
 
-m_shadowDepthFBO.AttachTexture(m_shadowDepthTexture, GLFramebuffer::AttachmentType::DEPTH);
-m_shadowDepthFBO.DrawBuffer(GLFramebuffer::GLBuffer::NONE);
-m_shadowDepthFBO.ReadBuffer(GLFramebuffer::GLBuffer::NONE);
+m_shadowFBO.AttachTexture(m_shadowDepthTexture, GLFramebuffer::AttachmentType::DEPTH);
+m_shadowFBO.AttachTexture(m_shadowColorTexture, GLFramebuffer::AttachmentType::COLOR0);
 
-m_shadowDepthFBO.Unbind();
+m_shadowFBO.Unbind();
 }
 
 /***********************************************************************************/

MP-APS/.vs/MP-APS/v15/Browse.VC.db

@@ -43,7 +43,7 @@ class RenderSystem {
 );
 
 private:
-struct Features {
+struct HardwareCaps {
 float MaxAnisotropy;
 int MaxArrayTextureLayers;
 int MaxTextureSamples;
@@ -53,11 +53,12 @@ class RenderSystem {
 int MaxFragmentUniformBlocks;
 int MaxComputeWorkGroupSize;
 int MaxComputeWorkGroupCount;
-} m_features;
+} m_caps;
 
 // Helper functions
 
-
+//
+void queryHardwareCaps();
 // Sets the default state required for rendering
 void setDefaultState();
 // Render models contained in the renderlist
@@ -92,8 +93,8 @@ class RenderSystem {
 GLuint m_samplerPBRTextures{ 0 };
 
 // Shadow mapping
-GLuint m_shadowMapResolution{ 1024 }, m_shadowDepthTexture{ 0 };
-GLFramebuffer m_shadowDepthFBO;
+GLuint m_shadowMapResolution{ 1024 }, m_shadowDepthTexture{ 0 }, m_shadowColorTexture{ 0 };
+GLFramebuffer m_shadowFBO;
 
 // Environment map
 Skybox m_skybox;

MP-APS/Core/RenderSystem.cpp

@@ -39,28 +39,27 @@ layout (location = 1) out vec4 BrightColor;
 const float PI = 3.14159265359;
 
 // ----------------------------------------------------------------------------
-float ComputeShadow(const vec4 fragPosLightSpace, const vec3 N, const vec3 L) {
+// Piecewise linear interpolation
+float linstep(const float low, const float high, const float value) {
+ return clamp((value - low) / (high - low), 0.0, 1.0);
+}
+
+// ----------------------------------------------------------------------------
+// Variance shadow mapping
+float ComputeShadow(const vec4 fragPosLightSpace) {
  // Perspective divide
- vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
- projCoords = projCoords * 0.5 + 0.5; // [0, 1]
+ vec2 screenCoords = fragPosLightSpace.xy / fragPosLightSpace.w;
+ screenCoords = screenCoords * 0.5 + 0.5; // [0, 1]
 
- const float closestDepth = texture(shadowMap, projCoords.xy).r; 
- const float currentDepth = projCoords.z;
- const float bias = max(0.05 * (1.0 - dot(N, L)), 0.005); // Bias to solve shadow acne
- 
- // PCF
- float shadow = 0.0;
- const vec2 texelSize = 1.0 / textureSize(shadowMap, 0);
- for(int x = -2; x <= 2; ++x) {
- for(int y = -2; y <= 2; ++y) {
- const float pcfDepth = texture(shadowMap, projCoords.xy + vec2(x, y) * texelSize).r; 
- shadow += currentDepth - bias > pcfDepth ? 1.0 : 0.0; 
- } 
- }
- 
- shadow /= 25.0;
+ const float distance = fragPosLightSpace.z; // Use raw distance instead of linear junk
+ const vec2 moments = texture2D(shadowMap, screenCoords.xy).rg;
+
+ const float p = step(distance, moments.x);
+ const float variance = max(moments.y - (moments.x * moments.x), 0.00002);
+ const float d = distance - moments.x;
+ const float pMax = linstep(0.2, 1.0, variance / (variance + d*d)); // Solve light bleeding
 
-  return shadow;
+ return min(max(p, pMax), 1.0);
 }
 
 // ----------------------------------------------------------------------------
@@ -155,9 +154,9 @@ void main() {
  // scale light by NdotL
  float NdotL = max(dot(N, L), 0.0); 
 
- const float shadow = ComputeShadow(fragData.FragPosLightSpace, N, L);
+ const float shadow = ComputeShadow(fragData.FragPosLightSpace);
  // add to outgoing radiance Lo
- Lo = (kD * albedo / PI + specular) * radiance * NdotL * (1.0 - shadow); // note that we already multiplied the BRDF by the Fresnel (kS) so we won't multiply by kS again
+ Lo = (kD * albedo / PI + specular) * radiance * NdotL * shadow; // note that we already multiplied the BRDF by the Fresnel (kS) so we won't multiply by kS again
 }
 
  // ambient lighting (we now use IBL as the ambient term)

MP-APS/Core/RenderSystem.h

@@ -1,5 +1,15 @@
 #version 440 core
 
+in float VertexDepth;
+
+out vec4 FragColor;
+
 void main() { 
- // gl_FragDepth = gl_FragCoord.z;
+const float depth = VertexDepth;
+
+const float dx = dFdx(depth);
+const float dy = dFdy(depth);
+const float moment2 = depth * depth + 0.25 * (dx * dx + dy * dy);
+
+FragColor = vec4(depth, moment2, 0.0, 1.0);
 }

MP-APS/Data/Shaders/PBRps.glsl

@@ -4,6 +4,9 @@ layout (location = 0) in vec3 position;
 uniform mat4 lightSpaceMatrix;
 uniform mat4 modelMatrix;
 
+out float VertexDepth;
+
 void main() {
  gl_Position = lightSpaceMatrix * modelMatrix * vec4(position, 1.0);
+ VertexDepth = gl_Position.z;
 }

MP-APS/Data/Shaders/shadowdepthps.glsl

@@ -15,11 +15,6 @@ void SceneBase::Init(const std::string_view sceneName) {
 void SceneBase::Update(const double dt) {
 }
 
-/***********************************************************************************/
-void SceneBase::AddIBLProbe(const glm::vec3& position, const float radiusOfInfluence) {
-m_IBLProbes.emplace_back(position, radiusOfInfluence);
-}
-
 /***********************************************************************************/
 void SceneBase::AddLight(const StaticDirectionalLight& light) {
 m_staticDirectionalLights.push_back(light);