Implemented normal offset bias (#100)

This feature produces MUCH better shadow results using front faces. It has overall fewer artifacts New features: - Added normal_offset_bias / ShadowTextureDefinition::normalOffsetBias to globally control this normal offset bias per shadow map / cascade - Added constant_bias_scale / ShadowTextureDefinition::constantBiasScale. Constant bias is still per-material, but it can be globally amplified/decrease per shadow map / cascade - Constant bias is again automatically amplified with deeper shadow maps, as otherwise acne becomes visible (most obvious when using PSSM on the higher cascades). With the previous commit it was constant across all ranges and cascades Default mShadowMappingUseBackFaces to false, but it will be removed in the next commit. This feature is much more accuratem, we don't have the resources to maintain two codepaths, and the switching between the two requires aligning many variables (shader changes so constant bias is constant across regardless of depth range, set normal offset bias to 0, set mShadowMappingUseBackFaces to true)
OGRECave · Jun 11, 2020 · f9bd68a · f9bd68a
1 parent f3c0d82
commit f9bd68a
Show file tree

Hide file tree

Showing 22 changed files with 257 additions and 47 deletions.
diff --git a/Components/Hlms/Pbs/include/OgreHlmsPbs.h b/Components/Hlms/Pbs/include/OgreHlmsPbs.h
@@ -182,6 +182,8 @@ namespace Ogre
 
         ConstBufferPool::BufferPool const *mLastBoundPool;
 
+        float mConstantBiasScale;
+
         bool mHasSeparateSamplers;
         DescriptorSetTexture const *mLastDescTexture;
         DescriptorSetSampler const *mLastDescSampler;

diff --git a/Components/Hlms/Pbs/src/OgreHlmsPbs.cpp b/Components/Hlms/Pbs/src/OgreHlmsPbs.cpp
@@ -289,6 +289,7 @@ namespace Ogre
         mDecalsDiffuseMergedEmissive( false ),
         mDecalsSamplerblock( 0 ),
         mLastBoundPool( 0 ),
+        mConstantBiasScale( 1.0f ),
         mHasSeparateSamplers( 0 ),
         mLastDescTexture( 0 ),
         mLastDescSampler( 0 ),
@@ -1491,6 +1492,7 @@ namespace Ogre
         retVal.setProperties = mSetProperties;
 
         CamerasInProgress cameras = sceneManager->getCamerasInProgress();
+        mConstantBiasScale = cameras.renderingCamera->_getConstantBiasScale();
         Matrix4 viewMatrix = cameras.renderingCamera->getVrViewMatrix( 0 );
 
         Matrix4 projectionMatrix = cameras.renderingCamera->getProjectionMatrixWithRSDepth();
@@ -1578,7 +1580,8 @@ namespace Ogre
 
             //mat4 view + mat4 shadowRcv[numShadowMapLights].texViewProj +
             //              vec2 shadowRcv[numShadowMapLights].shadowDepthRange +
-            //              vec2 padding +
+            //              float normalOffsetBias +
+            //              float padding +
             //              vec4 shadowRcv[numShadowMapLights].invShadowMapSize +
             //mat3 invViewMatCubemap (upgraded to three vec4)
             mapSize += ( 16 + (16 + 2 + 2 + 4) * numShadowMapLights + 4 * 3 ) * 4;
@@ -1899,7 +1902,7 @@ namespace Ogre
                     *passBufferPtr++ = fNear;
                 }
                 *passBufferPtr++ = 1.0f / depthRange;
-                *passBufferPtr++ = 0.0f;
+                *passBufferPtr++ = shadowNode->getNormalOffsetBias( (size_t)shadowMapTexIdx );
                 *passBufferPtr++ = 0.0f; //Padding
 
 
@@ -3210,8 +3213,8 @@ namespace Ogre
             currentMappedTexBuffer = mStartMappedTexBuffer + currentConstOffset;
         }
 
-        *reinterpret_cast<float * RESTRICT_ALIAS>( currentMappedConstBuffer+1 ) = datablock->
-                                                                                    mShadowConstantBias;
+        *reinterpret_cast<float * RESTRICT_ALIAS>( currentMappedConstBuffer + 1 ) =
+            datablock->mShadowConstantBias * mConstantBiasScale;
 #if !OGRE_NO_FINE_LIGHT_MASK_GRANULARITY
         *( currentMappedConstBuffer+2u ) = queuedRenderable.movableObject->getLightMask();
 #endif

diff --git a/Components/Hlms/Unlit/include/OgreHlmsUnlit.h b/Components/Hlms/Unlit/include/OgreHlmsUnlit.h
@@ -73,6 +73,8 @@ namespace Ogre
         DescriptorSetTexture const *mLastDescTexture;
         DescriptorSetSampler const *mLastDescSampler;
 
+        float mConstantBiasScale;
+
         bool    mUsingExponentialShadowMaps;
         uint16  mEsmK; /// K parameter for ESM.
         uint32  mTexUnitSlotStart;

diff --git a/Components/Hlms/Unlit/src/OgreHlmsUnlit.cpp b/Components/Hlms/Unlit/src/OgreHlmsUnlit.cpp
@@ -79,6 +79,7 @@ namespace Ogre
         mHasSeparateSamplers( 0 ),
         mLastDescTexture( 0 ),
         mLastDescSampler( 0 ),
+        mConstantBiasScale( 1.0f ),
         mUsingExponentialShadowMaps( false ),
         mEsmK( 600u ),
         mTexUnitSlotStart( 2u ),
@@ -99,6 +100,7 @@ namespace Ogre
         mLastBoundPool( 0 ),
         mLastDescTexture( 0 ),
         mLastDescSampler( 0 ),
+        mConstantBiasScale( 1.0f ),
         mUsingExponentialShadowMaps( false ),
         mEsmK( 600u ),
         mTexUnitSlotStart( 2u ),
@@ -601,6 +603,7 @@ namespace Ogre
         retVal.setProperties = mSetProperties;
         retVal.pso.pass = passCache.passPso;
 
+        mConstantBiasScale = cameras.renderingCamera->_getConstantBiasScale();
         Matrix4 viewMatrix = cameras.renderingCamera->getViewMatrix(true);
 
         Matrix4 projectionMatrix = cameras.renderingCamera->getProjectionMatrixWithRSDepth();
@@ -888,8 +891,8 @@ namespace Ogre
 
         //uint materialIdx[]
         *currentMappedConstBuffer = datablock->getAssignedSlot();
-        *reinterpret_cast<float * RESTRICT_ALIAS>( currentMappedConstBuffer+1 ) = datablock->
-                                                                                    mShadowConstantBias;
+        *reinterpret_cast<float * RESTRICT_ALIAS>( currentMappedConstBuffer + 1 ) =
+            datablock->mShadowConstantBias * mConstantBiasScale;
         *(currentMappedConstBuffer+2) = useIdentityProjection;
         currentMappedConstBuffer += 4;
 

diff --git a/Docs/src/manual/compositor.md b/Docs/src/manual/compositor.md
@@ -1290,6 +1290,22 @@ thus the recommended values are num\_stable\_splits = 1 or num\_stable\_splits =
 
 The default is num\_stable\_splits = 0 which disables the feature
 
+-	normal\_offset\_bias <value>
+
+Normal-offset bias is per cascade / shadow map to fight shadow acne and self shadowing artifacts
+Very large values can cause misalignments between the objects and their shadows (if they're touching)
+
+Default is 0.00004
+
+-	constant\_bias\_scale <value>
+
+Constant bias is per material (tweak HlmsDatablock::mShadowConstantBias).
+This value lets you multiply it 'mShadowConstantBias * constantBiasScale' per cascade / shadow map
+
+Large values can cause peter-panning.
+
+Default is 1.0
+
 -   pssm\_lambda \<lambda\>
 
 Only used by PSSM techniques. Value usually between 0 & 1. The default

diff --git a/OgreMain/include/Compositor/OgreCompositorShadowNode.h b/OgreMain/include/Compositor/OgreCompositorShadowNode.h
@@ -222,6 +222,9 @@ namespace Ogre
         /// return a valid pointer.
         const Light* getLightAssociatedWith( uint32 shadowMapIdx ) const;
 
+        /// Returns 0 if shadowMapIdx is out of bounds
+        size_t getLightIdxAssociatedWith( const size_t shadowMapIdx ) const;
+
         /** Outputs the min & max depth range for the given camera. 0 & 100000 if camera not found
         @remarks
             Performs linear search O(N), except the overload that provides a shadowMapIdx
@@ -280,6 +283,8 @@ namespace Ogre
         const TextureGpuVec& getContiguousShadowMapTex(void) const  { return mContiguousShadowMapTex; }
         uint32 getIndexToContiguousShadowMapTex( size_t shadowMapIdx ) const;
 
+        float getNormalOffsetBias( const size_t shadowMapIdx ) const;
+
         /** Marks a shadow map as statically updated, and ties the given light to always use
             that shadow map.
         @remarks

diff --git a/OgreMain/include/Compositor/OgreCompositorShadowNodeDef.h b/OgreMain/include/Compositor/OgreCompositorShadowNodeDef.h
@@ -63,6 +63,13 @@ namespace Ogre
         size_t      light;  //Render Nth closest light
         size_t      split;  //Split for that light (only for PSSM/CSM)
 
+        /// Constant bias is per material (tweak HlmsDatablock::mShadowConstantBias).
+        /// This value lets you multiply it 'mShadowConstantBias * constantBiasScale'
+        /// per cascade / shadow map
+        float constantBiasScale;
+        /// Normal offset bias is per cascade / shadow map
+        float normalOffsetBias;
+
         ShadowMapTechniques shadowMapTechnique;
 
         //PSSM params
@@ -87,6 +94,8 @@ namespace Ogre
             arrayIdx( _arrayIdx ),
             light( _light ),
             split( _split ),
+            constantBiasScale( 1.0f ),
+            normalOffsetBias( 0.00004f ),
             shadowMapTechnique( t ),
             pssmLambda( 0.95f ),
             splitPadding( 1.0f ),

diff --git a/OgreMain/include/OgreCamera.h b/OgreMain/include/OgreCamera.h
@@ -195,6 +195,8 @@ namespace Ogre {
         /// @see Camera::getPixelDisplayRatio
         Real mPixelDisplayRatio;
 
+        float mConstantBiasScale;
+
         /// Each frame it is set to all false. After rendering each RQ, it is set to true
         vector<bool>::type  mRenderedRqs;
 
@@ -721,6 +723,9 @@ namespace Ogre {
         */
         Real getPixelDisplayRatio() const { return mPixelDisplayRatio; }
 
+        void _setConstantBiasScale( const float bias ) { mConstantBiasScale = bias; }
+        float _getConstantBiasScale( void ) const { return mConstantBiasScale; }
+
         /** Called at the beginning of each frame to know which RenderQueue IDs have been rendered
         @param numRqs
             Max number of total possible render queues in this frame

diff --git a/OgreMain/include/OgreScriptCompiler.h b/OgreMain/include/OgreScriptCompiler.h
@@ -1002,6 +1002,8 @@ namespace Ogre
         ID_SHADOW_NODE,
             ID_NUM_SPLITS,
             ID_NUM_STABLE_SPLITS,
+            ID_NORMAL_OFFSET_BIAS,
+            ID_CONSTANT_BIAS_SCALE,
             ID_PSSM_SPLIT_PADDING,
             ID_PSSM_SPLIT_BLEND,
             ID_PSSM_SPLIT_FADE,

diff --git a/OgreMain/src/Compositor/OgreCompositorShadowNode.cpp b/OgreMain/src/Compositor/OgreCompositorShadowNode.cpp
@@ -566,6 +566,8 @@ namespace Ogre
                     texCamera->setAutoAspectRatio( false );
                 }
 
+                texCamera->_setConstantBiasScale( itor->constantBiasScale );
+
                 if( itor->shadowMapTechnique == SHADOWMAP_PSSM )
                 {
                     assert( dynamic_cast<PSSMShadowCameraSetup*>
@@ -828,6 +830,14 @@ namespace Ogre
         return retVal;
     }
     //-----------------------------------------------------------------------------------
+    size_t CompositorShadowNode::getLightIdxAssociatedWith( const size_t shadowMapIdx ) const
+    {
+        size_t retVal = 0;
+        if( shadowMapIdx < mDefinition->mShadowMapTexDefinitions.size() )
+            retVal = mDefinition->mShadowMapTexDefinitions[shadowMapIdx].light;
+        return retVal;
+    }
+    //-----------------------------------------------------------------------------------
     void CompositorShadowNode::getMinMaxDepthRange( const Frustum *shadowMapCamera,
                                                     Real &outMin, Real &outMax ) const
     {
@@ -950,6 +960,11 @@ namespace Ogre
         return mShadowMapCameras[shadowMapIdx].idxToContiguousTex;
     }
     //-----------------------------------------------------------------------------------
+    float CompositorShadowNode::getNormalOffsetBias( const size_t shadowMapIdx ) const
+    {
+        return mDefinition->mShadowMapTexDefinitions[shadowMapIdx].normalOffsetBias;
+    }
+    //-----------------------------------------------------------------------------------
     void CompositorShadowNode::setLightFixedToShadowMap( size_t shadowMapIdx, Light *light )
     {
         assert( shadowMapIdx < mShadowMapCameras.size() );

diff --git a/OgreMain/src/OgreCamera.cpp b/OgreMain/src/OgreCamera.cpp
@@ -57,7 +57,8 @@ namespace Ogre {
         mUseRenderingDistance(true),
         mLodCamera(0),
         mUseMinPixelSize(false),
-        mPixelDisplayRatio(0)
+        mPixelDisplayRatio(0),
+        mConstantBiasScale(1.0f)
     {
 
         // Reasonable defaults to camera params

diff --git a/OgreMain/src/OgreHlms.cpp b/OgreMain/src/OgreHlms.cpp
@@ -2627,6 +2627,12 @@ namespace Ogre
                         setProperty( propName.c_str(),
                                      shadowNode->getIndexToContiguousShadowMapTex( shadowMapTexIdx ) );
 
+                        propName.resize( basePropSize );
+                        propName.a( "_light_idx" );
+                        setProperty( propName.c_str(),
+                                     static_cast<int32>(
+                                         shadowNode->getLightIdxAssociatedWith( shadowMapTexIdx ) ) );
+
                         if( shadowTexDef->uvOffset != Vector2::ZERO ||
                             shadowTexDef->uvLength != Vector2::UNIT_SCALE )
                         {
@@ -2703,6 +2709,12 @@ namespace Ogre
                             propName.a( "_uv_length_y_fract" );
                             setProperty( propName.c_str(), (int32)(fractPart * 100000.0f) );
                         }
+                        else if( light->getType() == Light::LT_SPOTLIGHT )
+                        {
+                            propName.resize( basePropSize );
+                            propName.a( "_is_spot" );
+                            setProperty( propName.c_str(), 1 );
+                        }
 
                         ++shadowMapTexIdx;
                     }

diff --git a/OgreMain/src/OgreHlmsDatablock.cpp b/OgreMain/src/OgreHlmsDatablock.cpp
@@ -115,7 +115,7 @@ namespace Ogre
         mAlphaTestCmp( CMPF_ALWAYS_PASS ),
         mAlphaTestShadowCasterOnly( false ),
         mAlphaTestThreshold( 0.5f ),
-        mShadowConstantBias( 0.01f )
+        mShadowConstantBias( 0.001f )
     {
         mMacroblockHash[0] = mMacroblockHash[1] = 0;
         mMacroblock[0] = mMacroblock[1] = 0;

diff --git a/OgreMain/src/OgreHlmsManager.cpp b/OgreMain/src/OgreHlmsManager.cpp
@@ -44,7 +44,7 @@ namespace Ogre
     HlmsManager::HlmsManager() :
         mComputeHlms( 0 ),
         mRenderSystem( 0 ),
-        mShadowMappingUseBackFaces( true ),
+        mShadowMappingUseBackFaces( false ),
         mDefaultHlmsType( HLMS_PBS )
   #if !OGRE_NO_JSON
     ,   mJsonListener( 0 )

diff --git a/OgreMain/src/OgreScriptCompiler.cpp b/OgreMain/src/OgreScriptCompiler.cpp
@@ -1377,6 +1377,8 @@ namespace Ogre
         mIds["compositor_node_shadow"]  = ID_SHADOW_NODE;
         mIds["num_splits"]              = ID_NUM_SPLITS;
         mIds["num_stable_splits"]       = ID_NUM_STABLE_SPLITS;
+        mIds["normal_offset_bias"]      = ID_NORMAL_OFFSET_BIAS;
+        mIds["constant_bias_scale"]     = ID_CONSTANT_BIAS_SCALE;
         mIds["pssm_split_padding"]      = ID_PSSM_SPLIT_PADDING;
         mIds["pssm_split_blend"]        = ID_PSSM_SPLIT_BLEND;
         mIds["pssm_split_fade"]         = ID_PSSM_SPLIT_FADE;

diff --git a/OgreMain/src/OgreScriptTranslator.cpp b/OgreMain/src/OgreScriptTranslator.cpp
@@ -7514,7 +7514,51 @@ namespace Ogre{
                         }
                     }
                     break;
-                case ID_PSSM_SPLIT_PADDING:
+                    case ID_NORMAL_OFFSET_BIAS:
+                    {
+                        if( prop->values.empty() )
+                        {
+                            compiler->addError( ScriptCompiler::CE_NUMBEREXPECTED, prop->file,
+                                                prop->line );
+                        }
+                        else if( prop->values.size() != 1 )
+                        {
+                            compiler->addError( ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file,
+                                                prop->line );
+                        }
+
+                        AbstractNodeList::const_iterator it0 = prop->values.begin();
+                        if( !getReal( *it0, &defaultParams.normalOffsetBias ) )
+                        {
+                            compiler->addError( ScriptCompiler::CE_NUMBEREXPECTED, prop->file,
+                                                prop->line );
+                            return;
+                        }
+                    }
+                    break;
+                    case ID_CONSTANT_BIAS_SCALE:
+                    {
+                        if( prop->values.empty() )
+                        {
+                            compiler->addError( ScriptCompiler::CE_NUMBEREXPECTED, prop->file,
+                                                prop->line );
+                        }
+                        else if( prop->values.size() != 1 )
+                        {
+                            compiler->addError( ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file,
+                                                prop->line );
+                        }
+
+                        AbstractNodeList::const_iterator it0 = prop->values.begin();
+                        if( !getReal( *it0, &defaultParams.constantBiasScale ) )
+                        {
+                            compiler->addError( ScriptCompiler::CE_NUMBEREXPECTED, prop->file,
+                                                prop->line );
+                            return;
+                        }
+                    }
+                    break;
+                    case ID_PSSM_SPLIT_PADDING:
                     {
                         if(prop->values.empty())
                         {

diff --git a/Samples/2.0/ApiUsage/ShadowMapDebugging/ShadowMapDebuggingGameState.cpp b/Samples/2.0/ApiUsage/ShadowMapDebugging/ShadowMapDebuggingGameState.cpp
@@ -450,11 +450,6 @@ namespace Demo
             }
 #endif
 
-            if( nextFilter == Ogre::HlmsPbs::ExponentialShadowMaps )
-                pbs->getHlmsManager()->setShadowMappingUseBackFaces( false );
-            else
-                pbs->getHlmsManager()->setShadowMappingUseBackFaces( true );
-
             pbs->setShadowSettings( nextFilter );
 
             if( nextFilter == Ogre::HlmsPbs::ExponentialShadowMaps )

diff --git a/Samples/Media/Hlms/Common/Any/ShadowCaster_piece_vs.any b/Samples/Media/Hlms/Common/Any/ShadowCaster_piece_vs.any
@@ -12,17 +12,17 @@
 		@property( !hlms_shadow_uses_depth_texture && !hlms_shadowcaster_point && !exponential_shadow_maps )
 			//Linear depth
 			@property( hlms_shadowcaster_directional || !hlms_no_reverse_depth )
-				outVs.depth	= outVs_Position.z + shadowConstantBias * passBuf.depthRange.y * passBuf.depthRange.y;
+				outVs.depth	= outVs_Position.z + shadowConstantBias;
 			@else
-				outVs.depth	= (outVs_Position.z + shadowConstantBias * passBuf.depthRange.y) * passBuf.depthRange.y;
+				outVs.depth	= outVs_Position.z * passBuf.depthRange.y + shadowConstantBias;
 			@end
 			@property( hlms_no_reverse_depth && (syntax == glsl || syntax == glsles) )outVs.depth = (outVs.depth * 0.5) + 0.5;@end
 		@end
 
 		@property( hlms_shadowcaster_point )
 			outVs.toCameraWS	= worldPos.xyz - passBuf.cameraPosWS.xyz;
 			@property( !exponential_shadow_maps )
-				outVs.constBias = shadowConstantBias * passBuf.depthRange.y * passBuf.depthRange.y;
+				outVs.constBias = shadowConstantBias;
 			@end
 		@end
 
@@ -31,16 +31,16 @@
 			//however we can use a cheap approximation ("pseudo linear depth")
 			//see http://www.yosoygames.com.ar/wp/2014/01/linear-depth-buffer-my-ass/
 			@property( hlms_shadowcaster_directional || !hlms_no_reverse_depth )
-				outVs_Position.z = outVs_Position.z + shadowConstantBias * passBuf.depthRange.y * passBuf.depthRange.y;
+				outVs_Position.z = outVs_Position.z + shadowConstantBias;
 			@else
-				outVs_Position.z = (outVs_Position.z + shadowConstantBias * passBuf.depthRange.y) * passBuf.depthRange.y * outVs_Position.w;
+				outVs_Position.z = (outVs_Position.z * passBuf.depthRange.y + shadowConstantBias) * outVs_Position.w;
 			@end
 		@end
 
 		@property( exponential_shadow_maps && !hlms_shadowcaster_point )
 			//It's the same as (float4( worldPos.xyz, 1 ) * viewMatrix).z
 			float linearZ = -(dot( worldPos.xyz, passBuf.viewZRow.xyz ) + passBuf.viewZRow.w);
-            //linearZ += (shadowConstantBias * passBuf.depthRange.y);
+			//linearZ += shadowConstantBias;
 			outVs.depth = (linearZ - passBuf.depthRange.x) * passBuf.depthRange.y;
 		@end
 	@end