Sm lights branching

Components/Hlms/Pbs/include/OgreHlmsPbs.h

@@ -270,6 +270,8 @@ namespace Ogre
         void postCommandBufferExecution( CommandBuffer *commandBuffer ) override;
         void frameEnded() override;
 
+        void setStaticBranchingLights( bool staticBranchingLights ) override;
+
         /** By default we see the reflection textures' mipmaps and store the largest one we found.
             By calling resetIblSpecMipmap; you can reset this process thus if a reflection texture
             with a large number of mipmaps was removed, these textures can be reevaluated

Components/Hlms/Pbs/src/OgreHlmsPbs.cpp

@@ -1732,6 +1732,8 @@ namespace Ogre
 
         bool isPssmBlend = getProperty( HlmsBaseProp::PssmBlend ) != 0;
         bool isPssmFade = getProperty( HlmsBaseProp::PssmFade ) != 0;
+        bool isStaticBranchShadowMapLights =
+            getProperty( HlmsBaseProp::StaticBranchShadowMapLights ) != 0;
 
         bool isShadowCastingPointLight = false;
 
@@ -1852,6 +1854,12 @@ namespace Ogre
                 // float pssmFadePoint.
                 mapSize += 4;
             }
+            if( isStaticBranchShadowMapLights )
+            {
+                // float numShadowMapPointLights;
+                // float numShadowMapSpotLights;
+                mapSize += 4 + 4;
+            }
 
             mapSize = alignToNextMultiple<size_t>( mapSize, 16 );
 
@@ -2301,6 +2309,16 @@ namespace Ogre
                 // float pssmFadePoint
                 *passBufferPtr++ = *shadowNode->getPssmFade( 0 );
             }
+            if( isStaticBranchShadowMapLights )
+            {
+                // float numShadowMapPointLights;
+                // float numShadowMapSpotLights;
+                *reinterpret_cast<uint32 * RESTRICT_ALIAS>( passBufferPtr ) = mRealShadowMapPointLights;
+                passBufferPtr++;
+                *reinterpret_cast<uint32 * RESTRICT_ALIAS>( passBufferPtr ) = mRealShadowMapSpotLights;
+                passBufferPtr++;
+                numPssmBlendsAndFade += 2;
+            }
 
             passBufferPtr += alignToNextMultiple<size_t>( numPssmSplits + numPssmBlendsAndFade, 4 ) -
                              ( numPssmSplits + numPssmBlendsAndFade );
@@ -3603,6 +3621,16 @@ namespace Ogre
         mCurrentPassBuffer = 0;
     }
     //-----------------------------------------------------------------------------------
+    void HlmsPbs::setStaticBranchingLights( bool staticBranchingLights )
+    {
+        if( staticBranchingLights )
+        {
+            // Make sure we calculate light positions in pixel shaders
+            setShadowReceiversInPixelShader( true );
+        }
+        Hlms::setStaticBranchingLights( staticBranchingLights );
+    }
+    //-----------------------------------------------------------------------------------
     void HlmsPbs::resetIblSpecMipmap( uint8 numMipmaps )
     {
         if( numMipmaps != 0u )

OgreMain/include/OgreHlms.h

@@ -211,11 +211,14 @@ namespace Ogre
         HlmsManager *mHlmsManager;
 
         LightGatheringMode mLightGatheringMode;
+        bool               mStaticBranchingLights;
         uint16             mNumLightsLimit;
         uint16             mNumAreaApproxLightsLimit;
         uint16             mNumAreaLtcLightsLimit;
         uint32             mAreaLightsGlobalLightListStart;
         uint32             mRealNumDirectionalLights;
+        uint32             mRealShadowMapPointLights;
+        uint32             mRealShadowMapSpotLights;
         uint32             mRealNumAreaApproxLightsWithMask;
         uint32             mRealNumAreaApproxLights;
         uint32             mRealNumAreaLtcLights;
@@ -524,6 +527,38 @@ namespace Ogre
         void   setMaxNonCasterDirectionalLights( uint16 maxLights );
         uint16 getMaxNonCasterDirectionalLights() const { return mNumLightsLimit; }
 
+        /** By default shadow-caster spot and point lights are hardcoded into shaders.
+
+            This means that if you have 8 spot/point lights and then you add a 9th one,
+            a whole new set of shaders will be created.
+            Even more if you have a combination of 3 spot and 5 point lights and the combination
+            has changed to 4 spot and 4 point lights then you'll get the next set of shaders
+
+            This setting allows you to tremendously reduce the amount of shader permutations
+            by forcing Ogre to switching to static branching with an upper limit to the max
+            number of shadow-casting spot or point lights.
+
+            See    Hlms::setAreaLightForwardSettings
+        @remarks
+            All point and spot lights must share the same hlms_shadowmap atlas
+
+            This is mostly an D3D11 / HLSL SM 5.0 restriction
+            (https://github.com/OGRECave/ogre-next/pull/255) but it may also help with
+            performance in other APIs.
+
+            If multiple atlas support is needed, using Texture2DArrays may be a good solution,
+            although it is currently untested and may need additional fixes to get it working
+
+        @param maxShadowMapLights
+            Maximum number of shadow-caster spot and point lights.
+            0 to allow unlimited number of lights, at the cost of shader recompilations
+            when spot or point  lights are added or removed or their combination are changed.
+
+            Default value is 0.
+         */
+        virtual void setStaticBranchingLights( bool staticBranchingLights );
+        bool         getStaticBranchingLights( void ) const { return mStaticBranchingLights; }
+
         /** Area lights use regular Forward.
         @param areaLightsApproxLimit
             Maximum number of area approx lights that will be considered by the shader.
@@ -888,6 +923,7 @@ namespace Ogre
         static const IdString DualParaboloidMapping;
         static const IdString InstancedStereo;
         static const IdString StaticBranchLights;
+        static const IdString StaticBranchShadowMapLights;
         static const IdString NumShadowMapLights;
         static const IdString NumShadowMapTextures;
         static const IdString PssmSplits;

OgreMain/src/OgreHlms.cpp

@@ -132,6 +132,8 @@ namespace Ogre
     const IdString HlmsBaseProp::DualParaboloidMapping = IdString( "hlms_dual_paraboloid_mapping" );
     const IdString HlmsBaseProp::InstancedStereo = IdString( "hlms_instanced_stereo" );
     const IdString HlmsBaseProp::StaticBranchLights = IdString( "hlms_static_branch_lights" );
+    const IdString HlmsBaseProp::StaticBranchShadowMapLights =
+        IdString( "hlms_static_branch_shadow_map_lights" );
     const IdString HlmsBaseProp::NumShadowMapLights = IdString( "hlms_num_shadow_map_lights" );
     const IdString HlmsBaseProp::NumShadowMapTextures = IdString( "hlms_num_shadow_map_textures" );
     const IdString HlmsBaseProp::PssmSplits = IdString( "hlms_pssm_splits" );
@@ -249,6 +251,7 @@ namespace Ogre
         mDataFolder( dataFolder ),
         mHlmsManager( 0 ),
         mLightGatheringMode( LightGatherForward ),
+        mStaticBranchingLights( false ),
         mNumLightsLimit( 0u ),
         mNumAreaApproxLightsLimit( 1u ),
         mNumAreaLtcLightsLimit( 1u ),
@@ -1679,6 +1682,11 @@ namespace Ogre
     //-----------------------------------------------------------------------------------
     void Hlms::setMaxNonCasterDirectionalLights( uint16 maxLights ) { mNumLightsLimit = maxLights; }
     //-----------------------------------------------------------------------------------
+    void Hlms::setStaticBranchingLights( bool staticBranchingLights )
+    {
+        mStaticBranchingLights = staticBranchingLights;
+    }
+    //-----------------------------------------------------------------------------------
     void Hlms::setAreaLightForwardSettings( uint16 areaLightsApproxLimit, uint16 areaLightsLtcLimit )
     {
         mNumAreaApproxLightsLimit = areaLightsApproxLimit;
@@ -2600,6 +2608,7 @@ namespace Ogre
         {
             size_t numShadowMapLights = 0u;
             size_t numPssmSplits = 0;
+            bool useStaticBranchShadowMapLights = false;
 
             if( shadowNode )
             {
@@ -2630,6 +2639,13 @@ namespace Ogre
                 setProperty( HlmsBaseProp::NumShadowMapTextures,
                              static_cast<int32>( contiguousShadowMapTex.size() ) );
 
+                useStaticBranchShadowMapLights =
+                    mStaticBranchingLights && numShadowMapLights > numPssmSplits;
+                if( useStaticBranchShadowMapLights )
+                    setProperty( HlmsBaseProp::StaticBranchShadowMapLights, 1 );
+                mRealShadowMapPointLights = 0u;
+                mRealShadowMapSpotLights = 0u;
+
                 {
                     const Ogre::CompositorShadowNodeDef *shadowNodeDef = shadowNode->getDefinition();
 
@@ -2660,8 +2676,9 @@ namespace Ogre
                                      static_cast<int32>( shadowNode->getIndexToContiguousShadowMapTex(
                                          shadowMapTexIdx ) ) );
 
-                        if( shadowTexDef->uvOffset != Vector2::ZERO ||
-                            shadowTexDef->uvLength != Vector2::UNIT_SCALE )
+                        if( ( shadowTexDef->uvOffset != Vector2::ZERO ||
+                              shadowTexDef->uvLength != Vector2::UNIT_SCALE ) ||
+                            useStaticBranchShadowMapLights )
                         {
                             propName.resize( basePropSize );
                             propName.a( "_uvs_fulltex" );
@@ -2708,18 +2725,8 @@ namespace Ogre
                         setProperty( propName.c_str(), shadowTexDef->arrayIdx );
 
                         const Light *light = shadowNode->getLightAssociatedWith( shadowMapTexIdx );
-                        if( light->getType() == Light::LT_DIRECTIONAL )
-                        {
-                            propName.resize( basePropSize );
-                            propName.a( "_is_directional_light" );
-                            setProperty( propName.c_str(), 1 );
-                        }
-                        else if( light->getType() == Light::LT_POINT )
+                        if( useStaticBranchShadowMapLights )
                         {
-                            propName.resize( basePropSize );
-                            propName.a( "_is_point_light" );
-                            setProperty( propName.c_str(), 1 );
-
                             fractPart = modff( (float)shadowTexDef->uvLength.x, &intPart );
                             propName.resize( basePropSize );
                             propName.a( "_uv_length_x_int" );
@@ -2735,12 +2742,58 @@ namespace Ogre
                             propName.resize( basePropSize );
                             propName.a( "_uv_length_y_fract" );
                             setProperty( propName.c_str(), ( int32 )( fractPart * 100000.0f ) );
+
+                            if( light->getType() == Light::LT_DIRECTIONAL )
+                            {
+                                propName.resize( basePropSize );
+                                propName.a( "_is_directional_light" );
+                                setProperty( propName.c_str(), 1 );
+                            }
+                            else if( light->getType() == Light::LT_POINT )
+                            {
+                                ++mRealShadowMapPointLights;
+                            }
+                            else if( light->getType() == Light::LT_SPOTLIGHT )
+                            {
+                                ++mRealShadowMapSpotLights;
+                            }
                         }
-                        else if( light->getType() == Light::LT_SPOTLIGHT )
+                        else
                         {
-                            propName.resize( basePropSize );
-                            propName.a( "_is_spot" );
-                            setProperty( propName.c_str(), 1 );
+                            if( light->getType() == Light::LT_DIRECTIONAL )
+                            {
+                                propName.resize( basePropSize );
+                                propName.a( "_is_directional_light" );
+                                setProperty( propName.c_str(), 1 );
+                            }
+                            else if( light->getType() == Light::LT_POINT )
+                            {
+                                propName.resize( basePropSize );
+                                propName.a( "_is_point_light" );
+                                setProperty( propName.c_str(), 1 );
+
+                                fractPart = modff( (float)shadowTexDef->uvLength.x, &intPart );
+                                propName.resize( basePropSize );
+                                propName.a( "_uv_length_x_int" );
+                                setProperty( propName.c_str(), (int32)intPart );
+                                propName.resize( basePropSize );
+                                propName.a( "_uv_length_x_fract" );
+                                setProperty( propName.c_str(), ( int32 )( fractPart * 100000.0f ) );
+
+                                fractPart = modff( (float)shadowTexDef->uvLength.y, &intPart );
+                                propName.resize( basePropSize );
+                                propName.a( "_uv_length_y_int" );
+                                setProperty( propName.c_str(), (int32)intPart );
+                                propName.resize( basePropSize );
+                                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;
@@ -2926,8 +2979,8 @@ namespace Ogre
                          numLightsPerType[Light::LT_POINT] + numLightsPerType[Light::LT_SPOTLIGHT] );
             setProperty( HlmsBaseProp::LightsSpotParams, numLightsPerType[Light::LT_SPOTLIGHT] );
 
-            if( numLightsPerType[Light::LT_POINT] &&         //
-                !numLightsPerType[Light::LT_DIRECTIONAL] &&  //
+            if( !useStaticBranchShadowMapLights && numLightsPerType[Light::LT_POINT] &&  //
+                !numLightsPerType[Light::LT_DIRECTIONAL] &&                              //
                 !numLightsPerType[Light::LT_SPOTLIGHT] )
             {
                 setProperty( HlmsBaseProp::AllPointLights, 1 );
@@ -3012,18 +3065,26 @@ namespace Ogre
                     }
                 }
 
-                // Deal with rest of non-caster directional lights
-                shadowMapLightIdx += numLightsPerType[Light::LT_DIRECTIONAL] - shadowCasterDirectional;
-
-                // Deal with the rest of the casting lights (point & spot)
-                const int32 numLights = numLightsPerType[Light::LT_SPOTLIGHT];
-                for( int32 i = numLightsPerType[Light::LT_DIRECTIONAL]; i < numLights; ++i )
+                if( useStaticBranchShadowMapLights )
                 {
-                    propName.resize( basePropNameSize );
-                    propName.a( shadowMapIdx, "_light_idx" );  // hlms_shadowmap0_light_idx
-                    setProperty( propName.c_str(), shadowMapLightIdx );
-                    ++shadowMapIdx;
-                    ++shadowMapLightIdx;
+                    setProperty( HlmsBaseProp::LightsPoint, 0 );
+                }
+                else
+                {
+                    // Deal with rest of non-caster directional lights
+                    shadowMapLightIdx +=
+                        numLightsPerType[Light::LT_DIRECTIONAL] - shadowCasterDirectional;
+
+                    // Deal with the rest of the casting lights (point & spot)
+                    const int32 numLights = numLightsPerType[Light::LT_SPOTLIGHT];
+                    for( int32 i = numLightsPerType[Light::LT_DIRECTIONAL]; i < numLights; ++i )
+                    {
+                        propName.resize( basePropNameSize );
+                        propName.a( shadowMapIdx, "_light_idx" );  // hlms_shadowmap0_light_idx
+                        setProperty( propName.c_str(), shadowMapLightIdx );
+                        ++shadowMapIdx;
+                        ++shadowMapLightIdx;
+                    }
                 }
             }
         }