URP Forward+

com.unity.render-pipelines.universal/Editor/ShaderGraph/Targets/UniversalDecalSubTarget.cs

@@ -951,6 +951,7 @@ static class Descriptors
                 { CoreKeywordDescriptors.ShadowsSoft },
                 { CoreKeywordDescriptors.LightmapShadowMixing },
                 { CoreKeywordDescriptors.ShadowsShadowmask },
+                { CoreKeywordDescriptors.ClusteredRendering },
                 { Descriptors.DecalsNormalBlend },
                 { Descriptors.LodCrossFade, new FieldCondition(Fields.LodCrossFade, true) },
             };
@@ -961,6 +962,7 @@ static class Descriptors
                 { CoreKeywordDescriptors.AdditionalLights },
                 { CoreKeywordDescriptors.AdditionalLightShadows },
                 { CoreKeywordDescriptors.ShadowsSoft },
+                { CoreKeywordDescriptors.ClusteredRendering },
                 { Descriptors.DecalsNormalBlend },
             };
 

com.unity.render-pipelines.universal/Editor/ShaderGraph/Targets/UniversalLitSubTarget.cs

@@ -742,6 +742,7 @@ static class LitKeywords
                 { CoreKeywordDescriptors.DBuffer },
                 { CoreKeywordDescriptors.LightLayers },
                 { CoreKeywordDescriptors.DebugDisplay },
+                { CoreKeywordDescriptors.ClusteredRendering },
             };
 
             public static readonly KeywordCollection GBuffer = new KeywordCollection

com.unity.render-pipelines.universal/Editor/ShaderGraph/Targets/UniversalTarget.cs

@@ -1434,6 +1434,15 @@ static class CoreKeywordDescriptors
             definition = KeywordDefinition.MultiCompile,
             scope = KeywordScope.Global,
         };
+
+        public static readonly KeywordDescriptor ClusteredRendering = new KeywordDescriptor()
+        {
+            displayName = "Clustered Rendering",
+            referenceName = "_CLUSTERED_RENDERING",
+            type = KeywordType.Boolean,
+            definition = KeywordDefinition.MultiCompile,
+            scope = KeywordScope.Global,
+        };
     }
     #endregion
 

com.unity.render-pipelines.universal/Editor/ShaderPreprocessor.cs

@@ -43,6 +43,7 @@ enum ShaderFeatures
         DecalNormalBlendLow = (1 << 22),
         DecalNormalBlendMedium = (1 << 23),
         DecalNormalBlendHigh = (1 << 24),
+        ClusteredRendering = (1 << 25)
     }
 
     internal class ShaderPreprocessor : IPreprocessShaders
@@ -82,13 +83,13 @@ internal class ShaderPreprocessor : IPreprocessShaders
         ShaderKeyword m_UseFastSRGBLinearConversion = new ShaderKeyword(ShaderKeywordStrings.UseFastSRGBLinearConversion);
         ShaderKeyword m_LightLayers = new ShaderKeyword(ShaderKeywordStrings.LightLayers);
         ShaderKeyword m_DebugDisplay = new ShaderKeyword(ShaderKeywordStrings.DEBUG_DISPLAY);
-
         ShaderKeyword m_DBufferMRT1 = new ShaderKeyword(ShaderKeywordStrings.DBufferMRT1);
         ShaderKeyword m_DBufferMRT2 = new ShaderKeyword(ShaderKeywordStrings.DBufferMRT2);
         ShaderKeyword m_DBufferMRT3 = new ShaderKeyword(ShaderKeywordStrings.DBufferMRT3);
         ShaderKeyword m_DecalNormalBlendLow = new ShaderKeyword(ShaderKeywordStrings.DecalNormalBlendLow);
         ShaderKeyword m_DecalNormalBlendMedium = new ShaderKeyword(ShaderKeywordStrings.DecalNormalBlendMedium);
         ShaderKeyword m_DecalNormalBlendHigh = new ShaderKeyword(ShaderKeywordStrings.DecalNormalBlendHigh);
+        ShaderKeyword m_ClusteredRendering = new ShaderKeyword(ShaderKeywordStrings.ClusteredRendering);
 
         ShaderKeyword m_LocalDetailMulx2;
         ShaderKeyword m_LocalDetailScaled;
@@ -122,7 +123,7 @@ bool StripUnusedPass(ShaderFeatures features, ShaderSnippetData snippetData)
             {
                 if (SupportedRenderingFeatures.active.enlighten == false ||
                     ((int)SupportedRenderingFeatures.active.lightmapBakeTypes | (int)LightmapBakeType.Realtime) == 0)
-                    return true;
+                return true;
             }
 
             if (snippetData.passType == PassType.ShadowCaster)
@@ -228,20 +229,23 @@ bool StripUnusedFeatures(ShaderFeatures features, Shader shader, ShaderSnippetDa
             // Additional light are shaded per-vertex or per-pixel.
             bool isFeaturePerPixelLightingEnabled = IsFeatureEnabled(features, ShaderFeatures.AdditionalLights);
             bool isFeaturePerVertexLightingEnabled = IsFeatureEnabled(features, ShaderFeatures.VertexLighting);
+            bool clusteredRendering = IsFeatureEnabled(features, ShaderFeatures.ClusteredRendering);
             bool isAdditionalLightPerPixel = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsPixel);
             bool isAdditionalLightPerVertex = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsVertex);
 
             // Strip if Per-Pixel lighting is NOT used in the project and the
-            // Per-Pixel (_ADDITIONAL_LIGHTS) or additional shadows (_ADDITIONAL_LIGHT_SHADOWS)
-            // variants are enabled in the shader.
-            if (!isFeaturePerPixelLightingEnabled && (isAdditionalLightPerPixel || isAdditionalLightShadow))
+            // Per-Pixel (_ADDITIONAL_LIGHTS) variant is enabled in the shader.
+            if (!isFeaturePerPixelLightingEnabled && isAdditionalLightPerPixel)
                 return true;
 
             // Strip if Per-Vertex lighting is NOT used in the project and the
             // Per-Vertex (_ADDITIONAL_LIGHTS_VERTEX) variant is enabled in the shader.
             if (!isFeaturePerVertexLightingEnabled && isAdditionalLightPerVertex)
                 return true;
 
+            if (!clusteredRendering && compilerData.shaderKeywordSet.IsEnabled(m_ClusteredRendering))
+                return true;
+
             // Screen Space Shadows
             if (!IsFeatureEnabled(features, ShaderFeatures.ScreenSpaceShadows) &&
                 compilerData.shaderKeywordSet.IsEnabled(m_MainLightShadowsScreen))
@@ -320,7 +324,7 @@ bool StripInvalidVariants(ShaderCompilerData compilerData)
             bool isMainShadow = isMainShadowNoCascades || isMainShadowCascades || isMainShadowScreen;
 
             bool isAdditionalShadow = compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightShadows);
-            if (isAdditionalShadow && !compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsPixel))
+            if (isAdditionalShadow && !(compilerData.shaderKeywordSet.IsEnabled(m_AdditionalLightsPixel) || compilerData.shaderKeywordSet.IsEnabled(m_ClusteredRendering)))
                 return true;
 
             bool isDeferredShadow = compilerData.shaderKeywordSet.IsEnabled(m_DeferredLightShadows);
@@ -390,6 +394,7 @@ public void OnProcessShader(Shader shader, ShaderSnippetData snippetData, IList<
 #if PROFILE_BUILD
             Profiler.BeginSample(k_ProcessShaderTag);
 #endif
+
             UniversalRenderPipelineAsset urpAsset = GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset;
             if (urpAsset == null || compilerDataList == null || compilerDataList.Count == 0)
                 return;
@@ -506,9 +511,6 @@ private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipeline
             else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
             {
                 shaderFeatures |= ShaderFeatures.AdditionalLights;
-
-                if (pipelineAsset.supportsAdditionalLightShadows)
-                    shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
             }
 
             bool anyShadows = pipelineAsset.supportsMainLightShadows ||
@@ -533,6 +535,8 @@ private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipeline
             bool hasDeferredRenderer = false;
             bool withAccurateGbufferNormals = false;
             bool withoutAccurateGbufferNormals = false;
+            bool clusteredRendering = false;
+            bool onlyClusteredRendering = false;
 
             int rendererCount = pipelineAsset.m_RendererDataList.Length;
             for (int rendererIndex = 0; rendererIndex < rendererCount; ++rendererIndex)
@@ -549,6 +553,7 @@ private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipeline
                     }
                 }
 
+                var rendererClustered = false;
 
                 ScriptableRendererData rendererData = pipelineAsset.m_RendererDataList[rendererIndex];
                 if (rendererData != null)
@@ -585,7 +590,16 @@ private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipeline
                             }
                         }
                     }
+
+                    if (rendererData is UniversalRendererData universalRendererData)
+                    {
+                        rendererClustered = universalRendererData.renderingMode == RenderingMode.Forward &&
+                            universalRendererData.clusteredRendering;
+                    }
                 }
+
+                clusteredRendering |= rendererClustered;
+                onlyClusteredRendering &= rendererClustered;
             }
 
             if (hasDeferredRenderer)
@@ -610,6 +624,24 @@ private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipeline
             if (pipelineAsset.reflectionProbeBoxProjection)
                 shaderFeatures |= ShaderFeatures.ReflectionProbeBoxProjection;
 
+            if (clusteredRendering)
+            {
+                shaderFeatures |= ShaderFeatures.ClusteredRendering;
+            }
+
+            if (onlyClusteredRendering)
+            {
+                shaderFeatures &= ~(ShaderFeatures.AdditionalLights | ShaderFeatures.VertexLighting);
+            }
+
+            if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel || clusteredRendering)
+            {
+                if (pipelineAsset.supportsAdditionalLightShadows)
+                {
+                    shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
+                }
+            }
+
             return shaderFeatures;
         }
 

com.unity.render-pipelines.universal/Editor/UniversalRendererDataEditor.cs

@@ -25,6 +25,7 @@ private static class Styles
             public static readonly GUIContent defaultStencilStateLabel = EditorGUIUtility.TrTextContent("Default Stencil State", "Configure the stencil state for the opaque and transparent render passes.");
             public static readonly GUIContent shadowTransparentReceiveLabel = EditorGUIUtility.TrTextContent("Transparent Receive Shadows", "When disabled, none of the transparent objects will receive shadows.");
             public static readonly GUIContent invalidStencilOverride = EditorGUIUtility.TrTextContent("Error: When using the deferred rendering path, the Renderer requires the control over the 4 highest bits of the stencil buffer to store Material types. The current combination of the stencil override options prevents the Renderer from controlling the required bits. Try changing one of the options to Replace.");
+            public static readonly GUIContent clusteredRenderingLabel = EditorGUIUtility.TrTextContent("Clustered (experimental)", "(Experimental) Enables clustered rendering, allowing for more lights per object and more accurate light cullling.");
         }
 
         SerializedProperty m_OpaqueLayerMask;
@@ -33,6 +34,8 @@ private static class Styles
         SerializedProperty m_DepthPrimingMode;
         SerializedProperty m_AccurateGbufferNormals;
         //SerializedProperty m_TiledDeferredShading;
+        SerializedProperty m_ClusteredRendering;
+        SerializedProperty m_TileSize;
 #if ENABLE_RENDER_PASS_UI
         SerializedProperty m_UseNativeRenderPass;
 #endif
@@ -41,6 +44,12 @@ private static class Styles
         SerializedProperty m_Shaders;
         SerializedProperty m_ShadowTransparentReceiveProp;
 
+#if URP_ENABLE_CLUSTERED_UI
+        static bool s_EnableClusteredUI => true;
+#else
+        static bool s_EnableClusteredUI => false;
+#endif
+
         private void OnEnable()
         {
             m_OpaqueLayerMask = serializedObject.FindProperty("m_OpaqueLayerMask");
@@ -50,6 +59,8 @@ private void OnEnable()
             m_AccurateGbufferNormals = serializedObject.FindProperty("m_AccurateGbufferNormals");
             // Not exposed yet.
             //m_TiledDeferredShading = serializedObject.FindProperty("m_TiledDeferredShading");
+            m_ClusteredRendering = serializedObject.FindProperty("m_ClusteredRendering");
+            m_TileSize = serializedObject.FindProperty("m_TileSize");
 #if ENABLE_RENDER_PASS_UI
             m_UseNativeRenderPass = serializedObject.FindProperty("m_UseNativeRenderPass");
 #endif
@@ -86,11 +97,21 @@ public override void OnInspectorGUI()
             if (m_RenderingMode.intValue == (int)RenderingMode.Forward)
             {
                 EditorGUI.indentLevel++;
+
+                if (s_EnableClusteredUI)
+                {
+                    EditorGUILayout.PropertyField(m_ClusteredRendering, Styles.clusteredRenderingLabel);
+                    EditorGUI.BeginDisabledGroup(!m_ClusteredRendering.boolValue);
+                    EditorGUILayout.PropertyField(m_TileSize);
+                    EditorGUI.EndDisabledGroup();
+                }
+
                 EditorGUILayout.PropertyField(m_DepthPrimingMode, Styles.DepthPrimingModeLabel);
                 if (m_DepthPrimingMode.intValue != (int)DepthPrimingMode.Disabled)
                 {
                     EditorGUILayout.HelpBox(Styles.DepthPrimingModeInfo.text, MessageType.Info);
                 }
+
                 EditorGUI.indentLevel--;
             }