Add light layer on indirect lighting controller #777

com.unity.render-pipelines.high-definition/CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Added support for AxF measurements importing into texture resources tilings.
 - Added Layer parameter on Area Light to modify Layer of generated Emissive Mesh
 - Added support for multiple mapping modes in AxF.
+- Add support of lightlayers on indirect lighting controller
 
 ### Fixed
 - Fixed issue with reflection probes in realtime time mode with OnEnable baking having wrong lighting with sky set to dynamic (case 1238047).

com.unity.render-pipelines.high-definition/Documentation~/Override-Indirect-Lighting-Controller.md

@@ -17,10 +17,11 @@ The **Indirect Lighting Controller** uses the [Volume](Volumes.html) framework,
 
 | Property                        | Description                                                  |
 | ------------------------------- | ------------------------------------------------------------ |
-| **Indirect Diffuse Intensity**  | A multiplier for baked and realtime Global Illumination lightmaps and Light Probes. HDRP multiplies the lightmap and Light Probe data by this value. |
-| **Indirect Specular Intensity** | A multiplier for baked, realtime, and custom Reflection Probes. HDRP multiplies the Reflection Probe data by this value. |
-
-
+| **Indirect Diffuse Lighting Multiplier**  | A multiplier for lightmaps, Light Probes, Light Probe Volumes, Screen-Space Global Illumination, and [Ray-Traced Global Illumination](Ray-Traced-Global-Illumination.md). HDRP multiplies the light data from all of these by this value. |
+| **Indirect Diffuse Lighting Layers** | Specifies the [Light Layers](Light-Layers.md) for indirect diffuse lighting. If you enable Light Layers, you can use them to decouple Meshes in your Scene from the above multiplier. |
+| **Reflection Lighting Multiplier**  | A multiplier for baked, realtime, custom [Reflection Probes](Reflection-Probe.md) and [Planar Probes](Planar-Reflection-Probe.md), [Screen-Space Reflection](Override-Screen-Space-Reflection.md), [Ray-Traced Reflection](Ray-Traced-Reflections.md), and Sky Reflection. HDRP multiplies the light data from all of these by this value. |
+| **Reflection Lighting Layers**  | LSpecifies the [Light Layers](Light-Layers.md) for reflection lighting. If you enable Light Layers, you can use them to decouple Meshes in your Scene from the above multiplier. |
+| **Reflection Probe Intensity Multiplier**  | A multiplier for baked, realtime, and custom [Reflection Probes](Reflection-Probe.md) and [Planar Probes](Planar-Reflection-Probe.md). HDRP multiplies the Reflection Probe data by this value. |
 
 ## Details
 

com.unity.render-pipelines.high-definition/Editor/Lighting/IndirectLightingControllerEditor.cs

@@ -1,26 +1,47 @@
+using UnityEngine;
 using UnityEngine.Rendering.HighDefinition;
+using UnityEngine.Rendering;
 
 namespace UnityEditor.Rendering.HighDefinition
 {
     [CanEditMultipleObjects]
     [VolumeComponentEditor(typeof(IndirectLightingController))]
     class IndirectLightingControllerEditor : VolumeComponentEditor
     {
-        SerializedDataParameter m_IndirectDiffuseIntensity;
-        SerializedDataParameter m_IndirectSpecularIntensity;
+        SerializedDataParameter m_IndirectDiffuseLightingMultiplier;
+        SerializedDataParameter m_IndirectDiffuseLightingLayers;
+
+        SerializedDataParameter m_ReflectionLightingMultiplier;
+        SerializedDataParameter m_ReflectionLightingLayers;
+
+        SerializedDataParameter m_ReflectionProbeIntensityMultiplier;
 
         public override void OnEnable()
         {
             var o = new PropertyFetcher<IndirectLightingController>(serializedObject);
 
-            m_IndirectSpecularIntensity = Unpack(o.Find(x => x.indirectSpecularIntensity));
-            m_IndirectDiffuseIntensity = Unpack(o.Find(x => x.indirectDiffuseIntensity));
+            m_IndirectDiffuseLightingMultiplier = Unpack(o.Find(x => x.indirectDiffuseLightingMultiplier));
+            m_IndirectDiffuseLightingLayers = Unpack(o.Find(x => x.indirectDiffuseLightingLayers));
+
+            m_ReflectionLightingMultiplier = Unpack(o.Find(x => x.reflectionLightingMultiplier));
+            m_ReflectionLightingLayers = Unpack(o.Find(x => x.reflectionLightingLayers));
+
+            m_ReflectionProbeIntensityMultiplier = Unpack(o.Find(x => x.reflectionProbeIntensityMultiplier));
         }
 
         public override void OnInspectorGUI()
         {
-            PropertyField(m_IndirectDiffuseIntensity, EditorGUIUtility.TrTextContent("Indirect Diffuse Intensity", "Sets the multiplier for baked diffuse lighting."));
-            PropertyField(m_IndirectSpecularIntensity, EditorGUIUtility.TrTextContent("Indirect Specular Intensity", "Sets the multiplier for reflected specular lighting."));
+            PropertyField(m_IndirectDiffuseLightingMultiplier, EditorGUIUtility.TrTextContent("Indirect Diffuse Lighting Multiplier", "Sets the multiplier for indirect diffuse lighting.\nIt affect Ambient Probe, Light Probes, Lightmaps, Light Probe Volumes, Screen Space Global Illumination, Raytrace Global Illumination."));
+            GUI.enabled = HDUtils.hdrpSettings.supportLightLayers;
+            PropertyField(m_IndirectDiffuseLightingLayers, EditorGUIUtility.TrTextContent("Indirect Diffuse Lighting Layers", "Sets the light layer mask for indirect diffuse lighting. Only matching RenderingLayers on Mesh will get affected by the multiplier."));
+            GUI.enabled = true;
+
+            PropertyField(m_ReflectionLightingMultiplier, EditorGUIUtility.TrTextContent("Reflection Lighting Multiplier", "Sets the multiplier for reflected specular lighting.\nIt affect Sky Reflection, Reflection Probes, Planar Probes, Screen Space Reflection, Raytrace Reflection."));
+            GUI.enabled = HDUtils.hdrpSettings.supportLightLayers;
+            PropertyField(m_ReflectionLightingLayers, EditorGUIUtility.TrTextContent("Reflection Lighting Layers", "Sets the light layer mask for reflected specular lighting. Only matching RenderingLayers on Mesh will get affected by the multiplier."));
+            GUI.enabled = true;
+
+            PropertyField(m_ReflectionProbeIntensityMultiplier, EditorGUIUtility.TrTextContent("Reflection/Planar Probe Intensity Multiplier", "Sets the intensity multiplier for Reflection/Planar Probes."));
         }
     }
 }

com.unity.render-pipelines.high-definition/Runtime/Lighting/IndirectLightingController.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 
 namespace UnityEngine.Rendering.HighDefinition
 {
@@ -8,9 +9,54 @@ namespace UnityEngine.Rendering.HighDefinition
     [Serializable, VolumeComponentMenu("Lighting/Indirect Lighting Controller")]
     public class IndirectLightingController : VolumeComponent
     {
-        /// <summary>Indirect specular intensity multiplier, between 0 and 1</summary>
-        public MinFloatParameter    indirectSpecularIntensity = new MinFloatParameter(1.0f, 0.0f);
-        /// <summary>Indirect diffuse intensity multiplier, between 0 and 1</summary>
-        public MinFloatParameter    indirectDiffuseIntensity = new MinFloatParameter(1.0f, 0.0f);
+        [UnityEngine.Serialization.FormerlySerializedAs("indirectDiffuseIntensity")]
+        /// <summary>Indirect diffuse lighting multiplier, between 0 and 1</summary>
+        public MinFloatParameter indirectDiffuseLightingMultiplier = new MinFloatParameter(1.0f, 0.0f);
+        /// Controls which layer will be affected by the indirect diffuse lighting multiplier 
+        public LightLayerEnumParameter indirectDiffuseLightingLayers = new LightLayerEnumParameter(LightLayerEnum.LightLayerDefault);
+
+        /// <summary>Reflection lighting multiplier, between 0 and 1</summary>
+        public MinFloatParameter reflectionLightingMultiplier = new MinFloatParameter(1.0f, 0.0f);
+        /// Controls which layer will be affected by the reflection lighting multiplier 
+        public LightLayerEnumParameter reflectionLightingLayers = new LightLayerEnumParameter(LightLayerEnum.LightLayerDefault);
+
+        [UnityEngine.Serialization.FormerlySerializedAs("indirectSpecularIntensity")]
+        /// <summary>Reflection probe intensity multiplier, between 0 and 1</summary>
+        public MinFloatParameter reflectionProbeIntensityMultiplier = new MinFloatParameter(1.0f, 0.0f);
+
+        /// <summary>
+        /// Returns a mask of reflection lighting layers as uint and handle the case of Everything as being 0xFF and not -1
+        /// </summary>
+        /// <returns></returns>
+        public uint GetReflectionLightingLayers()
+        {
+            int value = (int)reflectionLightingLayers.GetValue<LightLayerEnum>();
+            return value < 0 ? (uint)LightLayerEnum.Everything : (uint)value;
+        }
+
+        /// <summary>
+        /// Returns a mask of indirect diffuse lighting layers as uint and handle the case of Everything as being 0xFF and not -1
+        /// </summary>
+        /// <returns></returns>
+        public uint GetIndirectDiffuseLightingLayers()
+        {
+            int value = (int)indirectDiffuseLightingLayers.GetValue<LightLayerEnum>();
+            return value < 0 ? (uint)LightLayerEnum.Everything : (uint)value;
+        }
+
+        /// <summary>
+        /// Sky Ambient Mode volume parameter.
+        /// </summary>
+        [Serializable, DebuggerDisplay(k_DebuggerDisplay)]
+        public sealed class LightLayerEnumParameter : VolumeParameter<LightLayerEnum>
+        {
+            /// <summary>
+            /// Light Layer Enum parameterconstructor.
+            /// </summary>
+            /// <param name="value">Light Layer Enum parameter.</param>
+            /// <param name="overrideState">Initial override value.</param>
+            public LightLayerEnumParameter(LightLayerEnum value, bool overrideState = false)
+                : base(value, overrideState) { }
+        }
     }
 }

com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.cs

@@ -1816,7 +1816,7 @@ internal bool GetEnvLightData(CommandBuffer cmd, HDCamera hdCamera, in Processed
             envLightData.lightLayers = hdCamera.frameSettings.IsEnabled(FrameSettingsField.LightLayers) ? probe.lightLayersAsUInt : uint.MaxValue;
             envLightData.influenceShapeType = influence.envShape;
             envLightData.weight = processedProbe.weight;
-            envLightData.multiplier = probe.multiplier * m_indirectLightingController.indirectSpecularIntensity.value;
+            envLightData.multiplier = probe.multiplier * m_indirectLightingController.reflectionProbeIntensityMultiplier.value;
             envLightData.rangeCompressionFactorCompensation = Mathf.Max(probe.rangeCompressionFactor, 1e-6f);
             envLightData.influenceExtents = influence.extents;
             switch (influence.envShape)

com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl

@@ -466,6 +466,10 @@ void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BS
 
     ApplyDebugToLighting(context, builtinData, aggregateLighting);
 
+    // Note: We can't apply the IndirectDiffuseMultiplier here as with GBuffer, Emissive is part of the bakeDiffuseLighting.
+    // so IndirectDiffuseMultiplier is apply in PostInitBuiltinData or related location (like for probe volume)
+    aggregateLighting.indirect.specularReflected *= GetIndirectSpecularMultiplier(builtinData.renderingLayers);
+
     // Also Apply indiret diffuse (GI)
     // PostEvaluateBSDF will perform any operation wanted by the material and sum everything into diffuseLighting and specularLighting
     PostEvaluateBSDF(   context, V, posInput, preLightData, bsdfData, builtinData, aggregateLighting,

com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ShaderVariablesScreenSpaceLighting.cs

@@ -12,7 +12,10 @@ struct ShaderVariablesScreenSpaceLighting
         // Ambient occlusion
         public Vector4 _AmbientOcclusionParam; // xyz occlusion color, w directLightStrenght
 
-        public Vector4 _IndirectLightingMultiplier; // .x indirect diffuse multiplier (use with indirect lighting volume controler)
+        public float _IndirectDiffuseLightingMultiplier;
+        public uint _IndirectDiffuseLightingLayers;
+        public float _ReflectionLightingMultiplier;
+        public uint _ReflectionLightingLayers;
 
         // Screen space refraction
         public float   _SSRefractionInvScreenWeightDistance; // Distance for screen space smoothstep with fallback

com.unity.render-pipelines.high-definition/Runtime/Lighting/ScreenSpaceLighting/ShaderVariablesScreenSpaceLighting.cs.hlsl

@@ -11,7 +11,10 @@
     float4 _DepthPyramidScale;
     float4 _CameraMotionVectorsScale;
     float4 _AmbientOcclusionParam;
-    float4 _IndirectLightingMultiplier;
+    float _IndirectDiffuseLightingMultiplier;
+    uint _IndirectDiffuseLightingLayers;
+    float _ReflectionLightingMultiplier;
+    uint _ReflectionLightingLayers;
     float _SSRefractionInvScreenWeightDistance;
 
 

com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl

@@ -105,8 +105,9 @@ void PostInitBuiltinData(   float3 V, PositionInputs posInput, SurfaceData surfa
 {
     // Apply control from the indirect lighting volume settings - This is apply here so we don't affect emissive
     // color in case of lit deferred for example and avoid material to have to deal with it
-    builtinData.bakeDiffuseLighting *= _IndirectLightingMultiplier.x;
-    builtinData.backBakeDiffuseLighting *= _IndirectLightingMultiplier.x;
+    float multiplier = GetIndirectDiffuseMultiplier(builtinData.renderingLayers);
+    builtinData.bakeDiffuseLighting *= multiplier;
+    builtinData.backBakeDiffuseLighting *= multiplier;
 
 #ifdef MODIFY_BAKED_DIFFUSE_LIGHTING
 

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.cs

@@ -1047,7 +1047,11 @@ void PushGlobalParams(HDCamera hdCamera, CommandBuffer cmd)
                 // Set up UnityPerView CBuffer.
                 hdCamera.SetupGlobalParams(cmd, m_FrameCount);
 
-                cmd.SetGlobalVector(HDShaderIDs._IndirectLightingMultiplier, new Vector4(hdCamera.volumeStack.GetComponent<IndirectLightingController>().indirectDiffuseIntensity.value, 0, 0, 0));
+                IndirectLightingController indirectLightingController = hdCamera.volumeStack.GetComponent<IndirectLightingController>();
+                cmd.SetGlobalFloat(HDShaderIDs._IndirectDiffuseLightingMultiplier, indirectLightingController.indirectDiffuseLightingMultiplier.value);
+                cmd.SetGlobalInt(HDShaderIDs._IndirectDiffuseLightingLayers, hdCamera.frameSettings.IsEnabled(FrameSettingsField.LightLayers) ? (int)indirectLightingController.GetIndirectDiffuseLightingLayers() : -1);
+                cmd.SetGlobalFloat(HDShaderIDs._ReflectionLightingMultiplier, indirectLightingController.reflectionLightingMultiplier.value);
+                cmd.SetGlobalInt(HDShaderIDs._ReflectionLightingLayers, hdCamera.frameSettings.IsEnabled(FrameSettingsField.LightLayers) ? (int)indirectLightingController.GetReflectionLightingLayers() : -1);
 
                 // It will be overridden for transparent pass.
                 cmd.SetGlobalInt(HDShaderIDs._ColorMaskTransparentVel, (int)UnityEngine.Rendering.ColorWriteMask.All);

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDStringConstants.cs

@@ -166,7 +166,10 @@ static class HDShaderIDs
         public static readonly int _NumTileClusteredX = Shader.PropertyToID("_NumTileClusteredX");
         public static readonly int _NumTileClusteredY = Shader.PropertyToID("_NumTileClusteredY");
 
-        public static readonly int _IndirectLightingMultiplier = Shader.PropertyToID("_IndirectLightingMultiplier");
+        public static readonly int _IndirectDiffuseLightingMultiplier = Shader.PropertyToID("_IndirectDiffuseLightingMultiplier");
+        public static readonly int _IndirectDiffuseLightingLayers = Shader.PropertyToID("_IndirectDiffuseLightingLayers");
+        public static readonly int _ReflectionLightingMultiplier = Shader.PropertyToID("_ReflectionLightingMultiplier");
+        public static readonly int _ReflectionLightingLayers = Shader.PropertyToID("_ReflectionLightingLayers");
 
         public static readonly int g_isLogBaseBufferEnabled = Shader.PropertyToID("g_isLogBaseBufferEnabled");
         public static readonly int g_vLayeredOffsetsBuffer = Shader.PropertyToID("g_vLayeredOffsetsBuffer");

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/HDRaytracingIndirectDiffuse.cs

@@ -87,7 +87,12 @@ void RenderIndirectDiffuse(HDCamera hdCamera, CommandBuffer cmd, ScriptableRende
                 // Bind the output texture
                 cmd.SetComputeTextureParam(indirectDiffuseCS, indirectDiffuseKernel, HDShaderIDs._GBufferTexture[0], m_GbufferManager.GetBuffer(0));
                 cmd.SetComputeTextureParam(indirectDiffuseCS, indirectDiffuseKernel, HDShaderIDs._GBufferTexture[3], m_GbufferManager.GetBuffer(3));
-                cmd.SetComputeVectorParam(indirectDiffuseCS, HDShaderIDs._IndirectLightingMultiplier, new Vector4(hdCamera.volumeStack.GetComponent<IndirectLightingController>().indirectDiffuseIntensity.value, 0, 0, 0));
+
+                IndirectLightingController indirectLightingController = hdCamera.volumeStack.GetComponent<IndirectLightingController>();
+                cmd.SetComputeFloatParam(indirectDiffuseCS, HDShaderIDs._IndirectDiffuseLightingMultiplier, indirectLightingController.indirectDiffuseLightingMultiplier.value);
+                cmd.SetComputeIntParam(indirectDiffuseCS, HDShaderIDs._IndirectDiffuseLightingLayers, hdCamera.frameSettings.IsEnabled(FrameSettingsField.LightLayers) ? (int)indirectLightingController.GetIndirectDiffuseLightingLayers() : -1);
+                cmd.SetComputeFloatParam(indirectDiffuseCS, HDShaderIDs._ReflectionLightingMultiplier, indirectLightingController.reflectionLightingMultiplier.value);
+                cmd.SetComputeIntParam(indirectDiffuseCS, HDShaderIDs._ReflectionLightingLayers, hdCamera.frameSettings.IsEnabled(FrameSettingsField.LightLayers) ? (int)indirectLightingController.GetReflectionLightingLayers() : -1);
 
                 // Evaluate the dispatch parameters
                 int areaTileSize = 8;

com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/Shaders/IndirectDiffuse/RaytracingIndirectDiffuse.compute

@@ -255,6 +255,7 @@ void IndirectDiffuseAccumulation(uint3 dispatchThreadId : SV_DispatchThreadID, u
     uint2 currentPixelCoordinate = groupId * RAYTRACING_INDIRECT_DIFFUSE_TILE_SIZE + groupThreadId;
 
     // Add the indirect diffuse to the buffer (while pre-multiplying by the base color)
-    _GBufferTexture3[COORD_TEXTURE2D_X(currentPixelCoordinate)] += LOAD_TEXTURE2D_X(_IndirectDiffuseTexture, currentPixelCoordinate) * LOAD_TEXTURE2D_X(_GBufferTexture0, currentPixelCoordinate) * _IndirectLightingMultiplier.x;
+    float indirectDiffuseMultiplier = GetIndirectDiffuseMultiplier(0xFF); // We don't have renderinglayer here
+    _GBufferTexture3[COORD_TEXTURE2D_X(currentPixelCoordinate)] += LOAD_TEXTURE2D_X(_IndirectDiffuseTexture, currentPixelCoordinate) * LOAD_TEXTURE2D_X(_GBufferTexture0, currentPixelCoordinate) * indirectDiffuseMultiplier;
 #endif
 }

com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl

@@ -434,6 +434,17 @@ float GetInversePreviousExposureMultiplier()
     return rcp(exposure + (exposure == 0.0)); // zero-div guard
 }
 
+// Helper function for indirect control volume
+float GetIndirectDiffuseMultiplier(uint renderingLayers)
+{
+    return (_IndirectDiffuseLightingLayers & renderingLayers) ? _IndirectDiffuseLightingMultiplier : 1.0f;
+}
+
+float GetIndirectSpecularMultiplier(uint renderingLayers)
+{
+    return (_ReflectionLightingLayers & renderingLayers) ? _ReflectionLightingMultiplier : 1.0f;
+}
+
 // Functions to clamp UVs to use when RTHandle system is used.
 
 float2 ClampAndScaleUV(float2 UV, float2 texelSize, float numberOfTexels)