Merge pull request #1803 from Unity-Technologies/HDRP/staging

merge Hdrp/staging

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/ImageBasedLighting.hlsl

     return PerceptualRoughnessToMipmapLevel(perceptualRoughness, UNITY_SPECCUBE_LOD_STEPS);
 }
 
+// Mapping for convolved Texture2D, this is an empirical remapping to match GGX version of cubemap convolution
+real PlanarPerceptualRoughnessToMipmapLevel(real perceptualRoughness, uint mipMapcount)
+{
+    return PositivePow(perceptualRoughness, 0.8) * uint(max(mipMapcount - 1, 0));
+}
+
 // The *accurate* version of the non-linear remapping. It works by
 // approximating the cone of the specular lobe, and then computing the MIP map level
 // which (approximately) covers the footprint of the lobe with a single texel.

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

 - Added an option to disable light by type in the debug menu
 - Added gradient sky
 - Split EmissiveColor and bakeDiffuseLighting in forward avoiding the emissiveColor to be affect by SSAO
+- Added a volume to control indirect light intensity
+- Added EV 100 intensity unit for area lights
 
 ### Fixed
 - Fixed an issue with PreIntegratedFGD texture being sometimes destroyed and not regenerated causing rendering to break
 - Fixed the light range affecting the transform scale when changed.
 - Snap to grid now works for Decal projector resizing.
 - Added a warning for 128x128 cookie texture without mipmaps
+- Replace the sampler used for density volumes for correct wrap mode handling
 
 ### Changed
 - Movde Render Pipeline Debug "Windows from Windows->General-> Render Pipeline debug windows" to "Windows from Windows->Analysis-> Render Pipeline debug windows"
 ### Added
 - Added support for RendererPriority on Renderer. This allow to control order of transparent rendering manually. HDRP have now two stage of sorting for transparent in addition to bact to front. Material have a priority then Renderer have a priority.
 - Add Coupling of (HD)Camera and HDAdditionalCameraData for reset and remove in inspector contextual menu of Camera
+- Add Coupling of (HD)ReflectionProbe and HDAdditionalReflectionData for reset and remove in inspector contextual menu of ReflectoinProbe
 - Add macro to forbid unity_ObjectToWorld/unity_WorldToObject to be use as it doesn't handle camera relative rendering
 - Add opacity control on contact shadow
 

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugDisplay.cs

     {
         // Used to debug SSRay model
         // 1x32 bits
-        public Lit.ProjectionModel tracingModel;
+        public ScreenSpaceLighting.ProjectionModel tracingModel;
 
         // 6x32 bits
         public uint loopStartPositionSSX;                           // Proxy, HiZ, Linear
         public float iterationLinearDepthBufferMin;                 // HiZ, Linear
         public float iterationLinearDepthBufferMax;                 // HiZ, Linear
         public float iterationLinearDepthBufferMinThickness;        // HiZ, Linear
-        public Lit.HiZIntersectionKind iterationIntersectionKind;   // HiZ
+        public ScreenSpaceLighting.HiZIntersectionKind iterationIntersectionKind;   // HiZ
         public uint iterationCellSizeW;                             // HiZ, Linear
         public uint iterationCellSizeH;                             // HiZ, Linear
         public EnvShapeType proxyShapeType;                         // Proxy
         public static GUIContent[] debuggedAlgorithmStrings = null;
         public static int[] debuggedAlgorithmValues = null;
 
-        Lit.ProjectionModel m_LastProjectionModel = Lit.ProjectionModel.None;
+        ScreenSpaceLighting.ProjectionModel m_LastProjectionModel = ScreenSpaceLighting.ProjectionModel.None;
         ScreenSpaceTracingDebug m_ScreenSpaceTracingDebugData;
         public ScreenSpaceTracingDebug screenSpaceTracingDebugData
         {
                 if (m_LastProjectionModel != m_ScreenSpaceTracingDebugData.tracingModel)
                 {
                     m_LastProjectionModel = m_ScreenSpaceTracingDebugData.tracingModel;
-                    RefreshScreenSpaceTracingDebug<Lit.ProjectionModel>(null, m_LastProjectionModel);
+                    RefreshScreenSpaceTracingDebug<ScreenSpaceLighting.ProjectionModel>(null, m_LastProjectionModel);
-                if (m_ScreenSpaceTracingDebugData.tracingModel == Lit.ProjectionModel.Proxy)
+                if (m_ScreenSpaceTracingDebugData.tracingModel == ScreenSpaceLighting.ProjectionModel.Proxy)
                 {
                     showSSRayDepthPyramid = false;
                     showSSRayGrid = false;
             debugScreenSpaceTracingProxyValues = debugScreenSpaceTracingProxyValueList.ToArray();
             debugScreenSpaceTracingLinearStrings = debugScreenSpaceTracingLinearStringsList.ToArray();
             debugScreenSpaceTracingLinearValues = debugScreenSpaceTracingLinearValueList.ToArray();
-            debuggedAlgorithmStrings = Enum.GetNames(typeof(Lit.ProjectionModel))
+            debuggedAlgorithmStrings = Enum.GetNames(typeof(ScreenSpaceLighting.ProjectionModel))
-            debuggedAlgorithmValues = (int[])Enum.GetValues(typeof(Lit.ProjectionModel));
+            debuggedAlgorithmValues = (int[])Enum.GetValues(typeof(ScreenSpaceLighting.ProjectionModel));
         }
 
         public int GetDebugMaterialIndex()
 
                 switch (screenSpaceTracingDebugData.tracingModel)
                 {
-                    case Lit.ProjectionModel.Proxy:
+                    case ScreenSpaceLighting.ProjectionModel.Proxy:
                     {
                         debugSettingsContainer.children.Add(
                             new DebugUI.EnumField { displayName = "Debug Mode", getter = GetDebugLightingSubMode, setter = SetScreenSpaceTracingDebugMode, enumNames = debugScreenSpaceTracingProxyStrings, enumValues = debugScreenSpaceTracingProxyValues, onValueChanged = RefreshScreenSpaceTracingDebug }
                             );
                         break;
                     }
-                    case Lit.ProjectionModel.HiZ:
+                    case ScreenSpaceLighting.ProjectionModel.HiZ:
                     {
                         debugSettingsContainer.children.Insert(1, new DebugUI.Value { displayName = string.Empty, getter = () => "Press PageUp/PageDown to Increase/Decrease the HiZ step." });
                         debugSettingsContainer.children.Add(
                             );
                         break;
                     }
-                    case Lit.ProjectionModel.Linear:
+                    case ScreenSpaceLighting.ProjectionModel.Linear:
                     {
                         debugSettingsContainer.children.Add(
                             new DebugUI.EnumField { displayName = "Debug Mode", getter = GetDebugLightingSubMode, setter = SetScreenSpaceTracingDebugMode, enumNames = debugScreenSpaceTracingLinearStrings, enumValues = debugScreenSpaceTracingLinearValues, onValueChanged = RefreshScreenSpaceTracingDebug },

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugFullScreen.shader

             #include "HDRP/ShaderVariables.hlsl"
             #include "HDRP/Debug/DebugDisplay.cs.hlsl"
             #include "HDRP/Material/Builtin/BuiltinData.hlsl"
+            #include "HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceLighting.cs.hlsl"
 
             CBUFFER_START (UnityDebug)
             float _FullScreenDebugMode;

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

         {
             Lumen = LightUnit.Lumen,
             Luminance = LightUnit.Luminance,
+            Ev100 = LightUnit.Ev100,
         }
 
         enum PunctualLightUnit
 
             // For area lights
             if (oldLightUnit == LightUnit.Lumen && newLightUnit == LightUnit.Luminance)
-            {
-                if (m_LightShape == LightShape.Rectangle)
-                    intensity = LightUtils.ConvertRectLightLumenToLuminance(intensity, m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue);
-                else if (m_LightShape == LightShape.Line)
-                    intensity = LightUtils.CalculateLineLightLumenToLuminance(intensity, m_AdditionalLightData.shapeWidth.floatValue);
-            }
+                intensity = LightUtils.ConvertAreaLightLumenToLuminance((LightTypeExtent)m_AdditionalLightData.lightTypeExtent.enumValueIndex, intensity, m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue);
-            {
-                if (m_LightShape == LightShape.Rectangle)
-                    intensity = LightUtils.ConvertRectLightLuminanceToLumen(intensity, m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue);
-                else if (m_LightShape == LightShape.Line)
-                    intensity = LightUtils.CalculateLineLightLuminanceToLumen(intensity, m_AdditionalLightData.shapeWidth.floatValue);
-            }
+                intensity = LightUtils.ConvertAreaLightLuminanceToLumen((LightTypeExtent)m_AdditionalLightData.lightTypeExtent.enumValueIndex, intensity, m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue);
+            if (oldLightUnit == LightUnit.Luminance && newLightUnit == LightUnit.Ev100)
+                intensity = LightUtils.ConvertLuminanceToEv(intensity);
+            if (oldLightUnit == LightUnit.Ev100 && newLightUnit == LightUnit.Luminance)
+                intensity = LightUtils.ConvertEvToLuminance(intensity);
+            if (oldLightUnit == LightUnit.Ev100 && newLightUnit == LightUnit.Lumen)
+                intensity = LightUtils.ConvertAreaLightEvToLumen((LightTypeExtent)m_AdditionalLightData.lightTypeExtent.enumValueIndex, intensity, m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue);
+            if (oldLightUnit == LightUnit.Lumen && newLightUnit == LightUnit.Ev100)
+                intensity = LightUtils.ConvertAreaLightLumenToEv((LightTypeExtent)m_AdditionalLightData.lightTypeExtent.enumValueIndex, intensity, m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue);
 
             m_AdditionalLightData.intensity.floatValue = intensity;
         }

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.cs

     [CanEditMultipleObjects]
     partial class HDReflectionProbeEditor : Editor
     {
-        [MenuItem("CONTEXT/ReflectionProbe/Remove HD Reflection Probe", false, 0)]
-        static void RemoveLight(MenuCommand menuCommand)
+        [MenuItem("CONTEXT/ReflectionProbe/Remove Component", false, 0)]
+        static void RemoveReflectionProbe(MenuCommand menuCommand)
         {
             GameObject go = ((ReflectionProbe)menuCommand.context).gameObject;
 
             Undo.DestroyObjectImmediate(go.GetComponent<ReflectionProbe>());
             Undo.DestroyObjectImmediate(go.GetComponent<HDAdditionalReflectionData>());
+        }
+
+        [MenuItem("CONTEXT/ReflectionProbe/Reset", false, 0)]
+        static void ResetReflectionProbe(MenuCommand menuCommand)
+        {
+            GameObject go = ((ReflectionProbe)menuCommand.context).gameObject;
+
+            Assert.IsNotNull(go);
+
+            ReflectionProbe reflectionProbe = go.GetComponent<ReflectionProbe>();
+            HDAdditionalReflectionData reflectionProbeAdditionalData = go.GetComponent<HDAdditionalReflectionData>();
+
+            Assert.IsNotNull(reflectionProbe);
+            Assert.IsNotNull(reflectionProbeAdditionalData);
+
+            Undo.SetCurrentGroupName("Reset HD Reflection Probe");
+            Undo.RecordObjects(new UnityEngine.Object[] { reflectionProbe, reflectionProbeAdditionalData }, "Reset HD Reflection Probe");
+            reflectionProbe.Reset();
+            // To avoid duplicating init code we copy default settings to Reset additional data
+            // Note: we can't call this code inside the HDAdditionalReflectionData, thus why we don't wrap it in Reset() function
+            if(HDUtils.s_DefaultHDAdditionalReflectionData.influenceVolume == null)
+            {
+                HDUtils.s_DefaultHDAdditionalReflectionData.Awake();
+            }
+            HDUtils.s_DefaultHDAdditionalReflectionData.CopyTo(reflectionProbeAdditionalData);
         }
 
         static Dictionary<ReflectionProbe, HDReflectionProbeEditor> s_ReflectionProbeEditors = new Dictionary<ReflectionProbe, HDReflectionProbeEditor>();

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDScreenSpaceReflectionEditor.cs

         public override void OnInspectorGUI()
         {
             OnCommonInspectorGUI();
-            var projectionModel = (Lit.ProjectionModel)m_DeferredProjectionModel.value.enumValueIndex;
+            var projectionModel = (ScreenSpaceLighting.ProjectionModel)m_DeferredProjectionModel.value.enumValueIndex;
-                case Lit.ProjectionModel.HiZ:
+                case ScreenSpaceLighting.ProjectionModel.HiZ:
-                case Lit.ProjectionModel.Proxy:
+                case ScreenSpaceLighting.ProjectionModel.Proxy:
                     EditorGUILayout.Separator();
                     OnProxyInspectorGUI();
                     break;

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Lit/BaseLitUI.cs

         {
             base.FindBaseMaterialProperties(props);
 
-            doubleSidedNormalMode = FindProperty(kDoubleSidedNormalMode, props);
-            depthOffsetEnable = FindProperty(kDepthOffsetEnable, props);
+            doubleSidedNormalMode = FindProperty(kDoubleSidedNormalMode, props, false);
+            depthOffsetEnable = FindProperty(kDepthOffsetEnable, props, false);
-            materialID = FindProperty(kMaterialID, props);
-            transmissionEnable = FindProperty(kTransmissionEnable, props);
+            materialID = FindProperty(kMaterialID, props, false);
+            transmissionEnable = FindProperty(kTransmissionEnable, props, false);
-            displacementMode = FindProperty(kDisplacementMode, props);
-            displacementLockObjectScale = FindProperty(kDisplacementLockObjectScale, props);
-            displacementLockTilingScale = FindProperty(kDisplacementLockTilingScale, props);
+            displacementMode = FindProperty(kDisplacementMode, props, false);
+            displacementLockObjectScale = FindProperty(kDisplacementLockObjectScale, props, false);
+            displacementLockTilingScale = FindProperty(kDisplacementLockTilingScale, props, false);
-            ppdMinSamples = FindProperty(kPpdMinSamples, props);
-            ppdMaxSamples = FindProperty(kPpdMaxSamples, props);
-            ppdLodThreshold = FindProperty(kPpdLodThreshold, props);
-            ppdPrimitiveLength = FindProperty(kPpdPrimitiveLength, props);
-            ppdPrimitiveWidth  = FindProperty(kPpdPrimitiveWidth, props);
-            invPrimScale = FindProperty(kInvPrimScale, props);
+            ppdMinSamples = FindProperty(kPpdMinSamples, props, false);
+            ppdMaxSamples = FindProperty(kPpdMaxSamples, props, false);
+            ppdLodThreshold = FindProperty(kPpdLodThreshold, props, false);
+            ppdPrimitiveLength = FindProperty(kPpdPrimitiveLength, props, false);
+            ppdPrimitiveWidth  = FindProperty(kPpdPrimitiveWidth, props, false);
+            invPrimScale = FindProperty(kInvPrimScale, props, false);
 
             // tessellation specific, silent if not found
             tessellationMode = FindProperty(kTessellationMode, props, false);
             tessellationBackFaceCullEpsilon = FindProperty(kTessellationBackFaceCullEpsilon, props, false);
 
             // Wind
-            windEnable = FindProperty(kWindEnabled, props);
-            windInitialBend = FindProperty(kWindInitialBend, props);
-            windStiffness = FindProperty(kWindStiffness, props);
-            windDrag = FindProperty(kWindDrag, props);
-            windShiverDrag = FindProperty(kWindShiverDrag, props);
-            windShiverDirectionality = FindProperty(kWindShiverDirectionality, props);
+            windEnable = FindProperty(kWindEnabled, props, false);
+            windInitialBend = FindProperty(kWindInitialBend, props, false);
+            windStiffness = FindProperty(kWindStiffness, props, false);
+            windDrag = FindProperty(kWindDrag, props, false);
+            windShiverDrag = FindProperty(kWindShiverDrag, props, false);
+            windShiverDirectionality = FindProperty(kWindShiverDirectionality, props, false);
 
             // Decal
             supportDecals = FindProperty(kSupportDecals, props);
             EditorGUI.indentLevel++;
 
             // This follow double sided option
-            if (doubleSidedEnable.floatValue > 0.0f)
+            if (doubleSidedEnable != null && doubleSidedEnable.floatValue > 0.0f)
             {
                 EditorGUI.indentLevel++;
                 m_MaterialEditor.ShaderProperty(doubleSidedNormalMode, StylesBaseLit.doubleSidedNormalModeText);
-            m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
-
-            if ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitSSS)
+            if (materialID != null)
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(transmissionEnable, StylesBaseLit.transmissionEnableText);
-                EditorGUI.indentLevel--;
+                m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
+
+                if ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitSSS)
+                {
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(transmissionEnable, StylesBaseLit.transmissionEnableText);
+                    EditorGUI.indentLevel--;
+                }
-            m_MaterialEditor.ShaderProperty(enableGeometricSpecularAA, StylesBaseLit.enableGeometricSpecularAAText);
+            if (enableGeometricSpecularAA != null)
+            {
+                m_MaterialEditor.ShaderProperty(enableGeometricSpecularAA, StylesBaseLit.enableGeometricSpecularAAText);
-            if (enableGeometricSpecularAA.floatValue > 0.0)
-            {
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(specularAAScreenSpaceVariance, StylesBaseLit.specularAAScreenSpaceVarianceText);
-                m_MaterialEditor.ShaderProperty(specularAAThreshold, StylesBaseLit.specularAAThresholdText);
-                EditorGUI.indentLevel--;
+                if (enableGeometricSpecularAA.floatValue > 0.0)
+                {
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(specularAAScreenSpaceVariance, StylesBaseLit.specularAAScreenSpaceVarianceText);
+                    m_MaterialEditor.ShaderProperty(specularAAThreshold, StylesBaseLit.specularAAThresholdText);
+                    EditorGUI.indentLevel--;
+                }
-            m_MaterialEditor.ShaderProperty(enableMotionVectorForVertexAnimation, StylesBaseUnlit.enableMotionVectorForVertexAnimationText);
+            if (enableMotionVectorForVertexAnimation != null)
+                m_MaterialEditor.ShaderProperty(enableMotionVectorForVertexAnimation, StylesBaseUnlit.enableMotionVectorForVertexAnimationText);
-            EditorGUI.BeginChangeCheck();
-            m_MaterialEditor.ShaderProperty(displacementMode, StylesBaseLit.displacementModeText);
-            if (EditorGUI.EndChangeCheck())
+            if (displacementMode != null)
-                UpdateDisplacement();
-            }
+                EditorGUI.BeginChangeCheck();
+                m_MaterialEditor.ShaderProperty(displacementMode, StylesBaseLit.displacementModeText);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    UpdateDisplacement();
+                }
-            if ((DisplacementMode)displacementMode.floatValue != DisplacementMode.None)
-            {
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(displacementLockObjectScale, StylesBaseLit.lockWithObjectScaleText);
-                m_MaterialEditor.ShaderProperty(displacementLockTilingScale, StylesBaseLit.lockWithTilingRateText);
-                EditorGUI.indentLevel--;
-            }
+                if ((DisplacementMode)displacementMode.floatValue != DisplacementMode.None)
+                {
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(displacementLockObjectScale, StylesBaseLit.lockWithObjectScaleText);
+                    m_MaterialEditor.ShaderProperty(displacementLockTilingScale, StylesBaseLit.lockWithTilingRateText);
+                    EditorGUI.indentLevel--;
+                }
-            if ((DisplacementMode)displacementMode.floatValue == DisplacementMode.Pixel)
-            {
-                EditorGUILayout.Space();
-                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(ppdMinSamples, StylesBaseLit.ppdMinSamplesText);
-                m_MaterialEditor.ShaderProperty(ppdMaxSamples, StylesBaseLit.ppdMaxSamplesText);
-                ppdMinSamples.floatValue = Mathf.Min(ppdMinSamples.floatValue, ppdMaxSamples.floatValue);
-                m_MaterialEditor.ShaderProperty(ppdLodThreshold, StylesBaseLit.ppdLodThresholdText);
-                m_MaterialEditor.ShaderProperty(ppdPrimitiveLength, StylesBaseLit.ppdPrimitiveLength);
-                ppdPrimitiveLength.floatValue = Mathf.Max(0.01f, ppdPrimitiveLength.floatValue);
-                m_MaterialEditor.ShaderProperty(ppdPrimitiveWidth, StylesBaseLit.ppdPrimitiveWidth);
-                ppdPrimitiveWidth.floatValue = Mathf.Max(0.01f, ppdPrimitiveWidth.floatValue);
-                invPrimScale.vectorValue = new Vector4(1.0f / ppdPrimitiveLength.floatValue, 1.0f / ppdPrimitiveWidth.floatValue); // Precompute
-                m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText);
-                EditorGUI.indentLevel--;
+                if ((DisplacementMode)displacementMode.floatValue == DisplacementMode.Pixel)
+                {
+                    EditorGUILayout.Space();
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(ppdMinSamples, StylesBaseLit.ppdMinSamplesText);
+                    m_MaterialEditor.ShaderProperty(ppdMaxSamples, StylesBaseLit.ppdMaxSamplesText);
+                    ppdMinSamples.floatValue = Mathf.Min(ppdMinSamples.floatValue, ppdMaxSamples.floatValue);
+                    m_MaterialEditor.ShaderProperty(ppdLodThreshold, StylesBaseLit.ppdLodThresholdText);
+                    m_MaterialEditor.ShaderProperty(ppdPrimitiveLength, StylesBaseLit.ppdPrimitiveLength);
+                    ppdPrimitiveLength.floatValue = Mathf.Max(0.01f, ppdPrimitiveLength.floatValue);
+                    m_MaterialEditor.ShaderProperty(ppdPrimitiveWidth, StylesBaseLit.ppdPrimitiveWidth);
+                    ppdPrimitiveWidth.floatValue = Mathf.Max(0.01f, ppdPrimitiveWidth.floatValue);
+                    invPrimScale.vectorValue = new Vector4(1.0f / ppdPrimitiveLength.floatValue, 1.0f / ppdPrimitiveWidth.floatValue); // Precompute
+                    m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText);
+                    EditorGUI.indentLevel--;
+                }
             }
 
             EditorGUI.indentLevel--;
 
         protected override void VertexAnimationPropertiesGUI()
         {
+            if (windEnable == null)
+                return;
+
             EditorGUILayout.LabelField(StylesBaseLit.vertexAnimation, EditorStyles.boldLabel);
 
             EditorGUI.indentLevel++;
         {
             SetupBaseUnlitKeywords(material);
 
-            bool doubleSidedEnable = material.GetFloat(kDoubleSidedEnable) > 0.0f;
-
-            if (doubleSidedEnable)
+            if (material.HasProperty(kDoubleSidedEnable) && material.GetFloat(kDoubleSidedEnable) > 0.0f)
             {
                 DoubleSidedNormalMode doubleSidedNormalMode = (DoubleSidedNormalMode)material.GetFloat(kDoubleSidedNormalMode);
                 switch (doubleSidedNormalMode)
 
             // Set the reference value for the stencil test.
             int stencilRef = (int)StencilLightingUsage.RegularLighting;
-            if ((int)material.GetFloat(kMaterialID) == (int)BaseLitGUI.MaterialId.LitSSS)
+            if (material.HasProperty(kMaterialID) && (int)material.GetFloat(kMaterialID) == (int)BaseLitGUI.MaterialId.LitSSS)
             {
                 stencilRef = (int)StencilLightingUsage.SplitLighting;
             }
             material.SetInt(kStencilRefMV, (int)HDRenderPipeline.StencilBitMask.ObjectVelocity);
             material.SetInt(kStencilWriteMaskMV, (int)HDRenderPipeline.StencilBitMask.ObjectVelocity);
 
-            bool enableDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) != DisplacementMode.None;
-            bool enableVertexDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Vertex;
-            bool enablePixelDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Pixel;
-            bool enableTessellationDisplacement = ((DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Tessellation) && material.HasProperty(kTessellationMode);
+            if (material.HasProperty(kDisplacementMode))
+            {
+                bool enableDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) != DisplacementMode.None;
+                bool enableVertexDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Vertex;
+                bool enablePixelDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Pixel;
+                bool enableTessellationDisplacement = ((DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Tessellation) && material.HasProperty(kTessellationMode);
-            CoreUtils.SetKeyword(material, "_VERTEX_DISPLACEMENT", enableVertexDisplacement);
-            CoreUtils.SetKeyword(material, "_PIXEL_DISPLACEMENT", enablePixelDisplacement);
-            // Only set if tessellation exist
-            CoreUtils.SetKeyword(material, "_TESSELLATION_DISPLACEMENT", enableTessellationDisplacement);
+                CoreUtils.SetKeyword(material, "_VERTEX_DISPLACEMENT", enableVertexDisplacement);
+                CoreUtils.SetKeyword(material, "_PIXEL_DISPLACEMENT", enablePixelDisplacement);
+                // Only set if tessellation exist
+                CoreUtils.SetKeyword(material, "_TESSELLATION_DISPLACEMENT", enableTessellationDisplacement);
-            bool displacementLockObjectScale = material.GetFloat(kDisplacementLockObjectScale) > 0.0;
-            bool displacementLockTilingScale = material.GetFloat(kDisplacementLockTilingScale) > 0.0;
-            // Tessellation reuse vertex flag.
-            CoreUtils.SetKeyword(material, "_VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && (enableVertexDisplacement || enableTessellationDisplacement));
-            CoreUtils.SetKeyword(material, "_PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && enablePixelDisplacement);
-            CoreUtils.SetKeyword(material, "_DISPLACEMENT_LOCK_TILING_SCALE", displacementLockTilingScale && enableDisplacement);
+                bool displacementLockObjectScale = material.GetFloat(kDisplacementLockObjectScale) > 0.0;
+                bool displacementLockTilingScale = material.GetFloat(kDisplacementLockTilingScale) > 0.0;
+                // Tessellation reuse vertex flag.
+                CoreUtils.SetKeyword(material, "_VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && (enableVertexDisplacement || enableTessellationDisplacement));
+                CoreUtils.SetKeyword(material, "_PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && enablePixelDisplacement);
+                CoreUtils.SetKeyword(material, "_DISPLACEMENT_LOCK_TILING_SCALE", displacementLockTilingScale && enableDisplacement);
+
+                // Depth offset is only enabled if per pixel displacement is
+                bool depthOffsetEnable = (material.GetFloat(kDepthOffsetEnable) > 0.0f) && enablePixelDisplacement;
+                CoreUtils.SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable);
+            }
-            bool windEnabled = material.GetFloat(kWindEnabled) > 0.0f;
+            bool windEnabled = material.HasProperty(kWindEnabled) && material.GetFloat(kWindEnabled) > 0.0f;
-
-            // Depth offset is only enabled if per pixel displacement is
-            bool depthOffsetEnable = (material.GetFloat(kDepthOffsetEnable) > 0.0f) && enablePixelDisplacement;
-            CoreUtils.SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable);
 
             if (material.HasProperty(kTessellationMode))
             {
             // Use negation so we don't create keyword by default
             CoreUtils.SetKeyword(material, "_DISABLE_DECALS", material.GetFloat(kSupportDecals) == 0.0);
 
-            CoreUtils.SetKeyword(material, "_ENABLE_GEOMETRIC_SPECULAR_AA", material.GetFloat(kEnableGeometricSpecularAA) == 1.0);
+            CoreUtils.SetKeyword(material, "_ENABLE_GEOMETRIC_SPECULAR_AA", material.HasProperty(kEnableGeometricSpecularAA) && material.GetFloat(kEnableGeometricSpecularAA) == 1.0);
         }
 
         static public void SetupBaseLitMaterialPass(Material material)

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Lit/LitUI.cs

                     && !isPrepass)
                 {
                     m_MaterialEditor.ShaderProperty(refractionModel, Styles.refractionModelText);
-                    var mode = (Lit.RefractionModel)refractionModel.floatValue;
-                    if (mode != Lit.RefractionModel.None)
+                    var mode = (ScreenSpaceLighting.RefractionModel)refractionModel.floatValue;
+                    if (mode != ScreenSpaceLighting.RefractionModel.None)
                     {
                         m_MaterialEditor.ShaderProperty(ssrefractionProjectionModel, Styles.refractionProjectionModelText);
                         m_MaterialEditor.ShaderProperty(ior, Styles.refractionIorText);
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_IRIDESCENCE", materialId == BaseLitGUI.MaterialId.LitIridescence);
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SPECULAR_COLOR", materialId == BaseLitGUI.MaterialId.LitSpecular);
 
-            var refractionModelValue = (Lit.RefractionModel)material.GetFloat(kRefractionModel);
-            var refractionProjectionModelValue = (Lit.ProjectionModel)material.GetFloat(kSSRefractionProjectionModel);
+            var refractionModelValue = (ScreenSpaceLighting.RefractionModel)material.GetFloat(kRefractionModel);
+            var refractionProjectionModelValue = (ScreenSpaceLighting.ProjectionModel)material.GetFloat(kSSRefractionProjectionModel);
-            CoreUtils.SetKeyword(material, "_REFRACTION_PLANE", (refractionModelValue == Lit.RefractionModel.Plane) && canHaveRefraction);
-            CoreUtils.SetKeyword(material, "_REFRACTION_SPHERE", (refractionModelValue == Lit.RefractionModel.Sphere) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_PLANE", (refractionModelValue == ScreenSpaceLighting.RefractionModel.Plane) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_SPHERE", (refractionModelValue == ScreenSpaceLighting.RefractionModel.Sphere) && canHaveRefraction);
-            CoreUtils.SetKeyword(material, "_REFRACTION_SSRAY_PROXY", (refractionProjectionModelValue == Lit.ProjectionModel.Proxy) && canHaveRefraction);
-            CoreUtils.SetKeyword(material, "_REFRACTION_SSRAY_HIZ", (refractionProjectionModelValue == Lit.ProjectionModel.HiZ) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_SSRAY_PROXY", (refractionProjectionModelValue == ScreenSpaceLighting.ProjectionModel.Proxy) && canHaveRefraction);
+            CoreUtils.SetKeyword(material, "_REFRACTION_SSRAY_HIZ", (refractionProjectionModelValue == ScreenSpaceLighting.ProjectionModel.HiZ) && canHaveRefraction);
         }
     }
 } // namespace UnityEditor

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Unlit/BaseUnlitUI.cs

         // See comment in LitProperties.hlsl
         const string kEmissionColor = "_EmissionColor";
 
-        bool m_ShowBlendModePopup = true;
-        protected virtual bool showBlendModePopup { get { return m_ShowBlendModePopup; } }
+        protected virtual SurfaceType defaultSurfaceType { get { return SurfaceType.Opaque; } }
+
+        protected virtual bool showBlendModePopup { get { return true; } }
 
         // The following set of functions are call by the ShaderGraph
         // It will allow to display our common parameters + setup keyword correctly for them
         protected virtual void FindBaseMaterialProperties(MaterialProperty[] props)
         {
             // Everything is optional (except surface type) so users that derive from this class can decide what they expose or not
-            surfaceType = FindProperty(kSurfaceType, props);
+            surfaceType = FindProperty(kSurfaceType, props, false);
             alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props, false);
             alphaCutoff = FindProperty(kAlphaCutoff, props, false);
 
             enableMotionVectorForVertexAnimation = FindProperty(kEnableMotionVectorForVertexAnimation, props, false);
         }
 
+        protected SurfaceType surfaceTypeValue
+        {
+            get { return surfaceType != null ? (SurfaceType)surfaceType.floatValue : defaultSurfaceType; }
+        }
+
+            if (surfaceType == null)
+                return;
+
             EditorGUI.showMixedValue = surfaceType.hasMixedValue;
             var mode = (SurfaceType)surfaceType.floatValue;
 
             EditorGUI.indentLevel++;
 
             SurfaceTypePopup();
-            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+            if (surfaceTypeValue == SurfaceType.Transparent)
             {
                 if (blendMode != null && showBlendModePopup)
                     BlendModePopup();
 
                 // With transparent object and few specific materials like Hair, we need more control on the cutoff to apply
                 // This allow to get a better sorting (with prepass), better shadow (better silhouettes fidelity) etc...
-                if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+                if (surfaceTypeValue == SurfaceType.Transparent)
                 {
                     if (alphaCutoffShadow != null)
                     {
                 EditorGUI.indentLevel--;
             }
 
-            if (transparentBackfaceEnable != null && ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent))
+            if (transparentBackfaceEnable != null && surfaceTypeValue == SurfaceType.Transparent)
-            if (transparentSortPriority != null && ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent))
+            if (transparentSortPriority != null && surfaceTypeValue == SurfaceType.Transparent)
             {
                 EditorGUI.BeginChangeCheck();
                 m_MaterialEditor.ShaderProperty(transparentSortPriority, StylesBaseUnlit.transparentSortPriorityText);
             bool alphaTestEnable = material.HasProperty(kAlphaCutoffEnabled) && material.GetFloat(kAlphaCutoffEnabled) > 0.0f;
             CoreUtils.SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
 
-            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
+            SurfaceType surfaceType = material.HasProperty(kSurfaceType) ? (SurfaceType)material.GetFloat(kSurfaceType) : SurfaceType.Opaque;
             CoreUtils.SetKeyword(material, "_SURFACE_TYPE_TRANSPARENT", surfaceType == SurfaceType.Transparent);
 
             bool enableBlendModePreserveSpecularLighting = (surfaceType == SurfaceType.Transparent) && material.HasProperty(kEnableBlendModePreserveSpecularLighting) && material.GetFloat(kEnableBlendModePreserveSpecularLighting) > 0.0f;

com.unity.render-pipelines.high-definition/HDRP/Lighting/Light/HDAdditionalLightData.cs

         Candela,
         Lux,
         Luminance,
+        Ev100,
     }
 
     // Light layering
 
             if (lightUnit == LightUnit.Lumen)
             {
-                switch (lightTypeExtent)
-                {
-                    case LightTypeExtent.Punctual:
-                        SetLightIntensityPunctual(intensity);
-                        break;
-                    case LightTypeExtent.Line:
-                            m_Light.intensity = LightUtils.CalculateLineLightLumenToLuminance(intensity, shapeWidth);
-                        break;
-                    case LightTypeExtent.Rectangle:
-                        m_Light.intensity = LightUtils.ConvertRectLightLumenToLuminance(intensity, shapeWidth, shapeHeight);
-                        break;
-                }
+                if (lightTypeExtent == LightTypeExtent.Punctual)
+                    SetLightIntensityPunctual(intensity);
+                else
+                    m_Light.intensity = LightUtils.ConvertAreaLightLumenToLuminance(lightTypeExtent, intensity, shapeWidth, shapeHeight);
+            }
+            else if (lightUnit == LightUnit.Ev100)
+            {
+                m_Light.intensity = LightUtils.ConvertEvToLuminance(intensity);
             }
             else
                 m_Light.intensity = intensity;

com.unity.render-pipelines.high-definition/HDRP/Lighting/LightEvaluation.hlsl

             // Note: we do not modify the distance to the light, or the light angle for the back face.
             // This is a performance-saving optimization which makes sense as long as the thickness is small.
         }
+        
+        transmittance = lerp( bsdfData.transmittance, transmittance, lightData.shadowDimmer);
     }
 
     return transmittance;

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

 
         ContactShadows m_ContactShadows = null;
         bool m_EnableContactShadow = false;
+        
+        IndirectLightingController m_indirectLightingController = null;
 
         // Following is an array of material of size eight for all combination of keyword: OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
         Material[] m_deferredLightingMaterial;
 
             m_ContactShadows = VolumeManager.instance.stack.GetComponent<ContactShadows>();
             m_EnableContactShadow = m_FrameSettings.enableContactShadows && m_ContactShadows.enable && m_ContactShadows.length > 0;
+            m_indirectLightingController = VolumeManager.instance.stack.GetComponent<IndirectLightingController>();
 
             // Cluster
             {
             // Build light data
             var envLightData = new EnvLightData();
 
-
-            envLightData.multiplier = probe.multiplier;
+            envLightData.multiplier = probe.multiplier * m_indirectLightingController.indirectSpecularIntensity;
             envLightData.influenceExtents = probe.influenceExtents;
             envLightData.blendNormalDistancePositive = probe.blendNormalDistancePositive;
             envLightData.blendNormalDistanceNegative = probe.blendNormalDistanceNegative;

com.unity.render-pipelines.high-definition/HDRP/Lighting/LightUtils.cs

             return intensity * ((width * height) * Mathf.PI);
         }
 
+        public static float ConvertEvToLuminance(float ev)
+        {
+            return Mathf.Pow(2, ev - 3);
+        }
+
+        public static float ConvertLuminanceToEv(float luminance)
+        {
+            const float k = 12.5f;
+
+            return (float)Math.Log((luminance * 100f) / k, 2);
+        }
+
+        public static float ConvertAreaLightLumenToLuminance(LightTypeExtent areaLightType, float lumen, float width, float height = 0)
+        {
+            switch (areaLightType)
+            {
+                case LightTypeExtent.Line:
+                    return LightUtils.CalculateLineLightLumenToLuminance(lumen, width);
+                case LightTypeExtent.Rectangle:
+                    return LightUtils.ConvertRectLightLumenToLuminance(lumen, width, height);
+            }
+            return lumen;
+        }
+
+        public static float ConvertAreaLightLuminanceToLumen(LightTypeExtent areaLightType, float luminance, float width, float height = 0)
+        {
+            switch (areaLightType)
+            {
+                case LightTypeExtent.Line:
+                    return LightUtils.CalculateLineLightLuminanceToLumen(luminance, width);
+                case LightTypeExtent.Rectangle:
+                    return LightUtils.ConvertRectLightLuminanceToLumen(luminance, width, height);
+            }
+            return luminance;
+        }
+
+        public static float ConvertAreaLightLumenToEv(LightTypeExtent areaLightType, float lumen, float width, float height)
+        {
+            float luminance = ConvertAreaLightLumenToLuminance(areaLightType, lumen, width, height);
+
+            return ConvertLuminanceToEv(luminance);
+        }
+
+        public static float ConvertAreaLightEvToLumen(LightTypeExtent areaLightType, float ev, float width, float height)
+        {
+            float luminance = ConvertEvToLuminance(ev);
+
+            return ConvertAreaLightLuminanceToLumen(areaLightType, luminance, width, height);
+        }
+
         // convert intensity (lumen) to nits
         public static float CalculateLineLightLumenToLuminance(float intensity, float lineWidth)
         {

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/HDAdditionalReflectionData.cs

         bool needMigrateToHDProbeChild = false;
         bool needMigrateToUseInfluenceVolume = false;
 
+        public void CopyTo(HDAdditionalReflectionData data)
+        {
+            influenceVolume.CopyTo(data.influenceVolume);
+            data.influenceVolume.shape = influenceVolume.shape; //force the legacy probe to refresh its size
+
+            data.mode = mode;
+            data.refreshMode = refreshMode;
+            data.multiplier = multiplier;
+            data.weight = weight;
+        }
+
         public void OnBeforeSerialize()
         {
         }

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/HDProbe.cs

         public InfluenceVolume influenceVolume { get { return m_InfluenceVolume; } private set { m_InfluenceVolume = value; } }
 
         /// <summary>Multiplier factor of reflection (non PBR parameter).</summary>
-        public float multiplier { get { return m_Multiplier; } }
+        public float multiplier { get { return m_Multiplier; } protected set { m_Multiplier = value; } }
-        public float weight { get { return m_Weight; } }
+        public float weight { get { return m_Weight; } protected set { m_Weight = value; } }
 
         /// <summary>The capture mode.</summary>
         public virtual ReflectionProbeMode mode

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/Volumes/InfluenceVolume.cs

     [Serializable]
     public class InfluenceVolume
     {
-        HDProbe probe;
+        HDProbe m_Probe;
 
         [SerializeField, FormerlySerializedAs("m_ShapeType")]
         InfluenceShape m_Shape = InfluenceShape.Box;
         [SerializeField, FormerlySerializedAs("m_SphereInfluenceNormalFade")]
         float m_SphereBlendNormalDistance;
 
+        internal void CopyTo(InfluenceVolume data)
+        {
+            //keep the m_Probe as it is used to reset the probe
+
+            data.m_Shape = m_Shape;
+            data.m_Offset = m_Offset;
+            data.m_BoxSize = m_BoxSize;
+            data.m_BoxBlendDistancePositive = m_BoxBlendDistancePositive;
+            data.m_BoxBlendDistanceNegative = m_BoxBlendDistanceNegative;
+            data.m_BoxBlendNormalDistancePositive = m_BoxBlendNormalDistancePositive;
+            data.m_BoxBlendNormalDistanceNegative = m_BoxBlendNormalDistanceNegative;
+            data.m_BoxSideFadePositive = m_BoxSideFadePositive;
+            data.m_BoxSideFadeNegative = m_BoxSideFadeNegative;
+            data.m_SphereRadius = m_SphereRadius;
+            data.m_SphereBlendDistance = m_SphereBlendDistance;
+            data.m_SphereBlendNormalDistance = m_SphereBlendNormalDistance;
+
+            data.m_EditorAdvancedModeBlendDistancePositive = m_EditorAdvancedModeBlendDistancePositive;
+            data.m_EditorAdvancedModeBlendDistanceNegative = m_EditorAdvancedModeBlendDistanceNegative;
+            data.m_EditorSimplifiedModeBlendDistance = m_EditorSimplifiedModeBlendDistance;
+            data.m_EditorAdvancedModeBlendNormalDistancePositive = m_EditorAdvancedModeBlendNormalDistancePositive;
+            data.m_EditorAdvancedModeBlendNormalDistanceNegative = m_EditorAdvancedModeBlendNormalDistanceNegative;
+            data.m_EditorSimplifiedModeBlendNormalDistance = m_EditorSimplifiedModeBlendNormalDistance;
+            data.m_EditorAdvancedModeEnabled = m_EditorAdvancedModeEnabled;
+        }
+
         /// <summary>Shape of this InfluenceVolume.</summary>
         public InfluenceShape shape
         {
                 switch (m_Shape)
                 {
                     case InfluenceShape.Box:
-                        probe.UpdatedInfluenceVolumeShape(m_BoxSize, offset);
+                        m_Probe.UpdatedInfluenceVolumeShape(m_BoxSize, offset);
-                        probe.UpdatedInfluenceVolumeShape(Vector3.one * (2 * m_SphereRadius), offset);
+                        m_Probe.UpdatedInfluenceVolumeShape(Vector3.one * (2 * m_SphereRadius), offset);
                         break;
                 }
             }
             set
             {
                 m_BoxSize = value;
-                probe.UpdatedInfluenceVolumeShape(m_BoxSize, offset);
+                m_Probe.UpdatedInfluenceVolumeShape(m_BoxSize, offset);
             }
         }
 
             set
             {
                 m_SphereRadius = value;
-                probe.UpdatedInfluenceVolumeShape(Vector3.one * (2 * m_SphereRadius), offset);
+                m_Probe.UpdatedInfluenceVolumeShape(Vector3.one * (2 * m_SphereRadius), offset);
             }
         }
         /// <summary>
         /// Value between 0 (on InfluenceVolume hull) and sphereRadius (fade sub volume reduced to a point).
         /// </summary>
         public float sphereBlendNormalDistance { get { return m_SphereBlendNormalDistance; } set { m_SphereBlendNormalDistance = value; } }
-        
+
-            this.probe = probe;
+            this.m_Probe = probe;
         }
 
         internal BoundingSphere GetBoundingSphereAt(Transform probeTransform)

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

 
     // Ambiant occlusion
     float4 _AmbientOcclusionParam; // xyz occlusion color, w directLightStrenght
+    
+    float4 _IndirectLightingMultiplier; // .x indirect diffuse multiplier (use with indirect lighting volume controler)
+    
 #else
     // Rough refraction texture
     // Color pyramid (width, height, lodcount, Unused)

com.unity.render-pipelines.high-definition/HDRP/Lighting/Volumetrics/VolumeVoxelization.compute

     float halfTexelSize = 0.5f * rcp(mipSize);
     voxelCenterUVW.z    = clamp(voxelCenterUVW.z, offset + halfTexelSize, offset + rcpNumTextures - halfTexelSize);
     
-    return SAMPLE_TEXTURE3D_LOD(_VolumeMaskAtlas, s_trilinear_clamp_sampler, voxelCenterUVW, lod).a;
+    // Reminder: still no filtering across the the wrap in Z.
+    return SAMPLE_TEXTURE3D_LOD(_VolumeMaskAtlas, s_trilinear_repeat_sampler, voxelCenterUVW, lod).a;
 }
 
 

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.cs

             LitClearCoat            = 1 << 6
         };
 
-        public enum RefractionModel
-        {
-            None = 0,
-            Plane = 1,
-            Sphere = 2
-        };
-
-        [GenerateHLSL]
-        public enum ProjectionModel
-        {
-            None = 0,
-            Proxy = 1,
-            HiZ = 2,
-            Linear = 3
-        };
-
-        [GenerateHLSL]
-        public enum HiZIntersectionKind
-        {
-            None,
-            Cell,
-            Depth
-        }
-
         //-----------------------------------------------------------------------------
         // SurfaceData
         //-----------------------------------------------------------------------------

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.cs.hlsl

 #define MATERIALFEATUREFLAGS_LIT_CLEAR_COAT (64)
 
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.Lit+ProjectionModel:  static fields
-//
-#define PROJECTIONMODEL_NONE (0)
-#define PROJECTIONMODEL_PROXY (1)
-#define PROJECTIONMODEL_HI_Z (2)
-#define PROJECTIONMODEL_LINEAR (3)
-
-//
-// UnityEngine.Experimental.Rendering.HDPipeline.Lit+HiZIntersectionKind:  static fields
-//
-#define HIZINTERSECTIONKIND_NONE (0)
-#define HIZINTERSECTIONKIND_CELL (1)
-#define HIZINTERSECTIONKIND_DEPTH (2)
-
-//
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+SurfaceData:  static fields
 //
 #define DEBUGVIEW_LIT_SURFACEDATA_MATERIAL_FEATURES (1000)

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.hlsl

 #include "HDRP/Lighting/LightDefinition.cs.hlsl"
 #include "HDRP/Lighting/Reflection/VolumeProjection.hlsl"
 
-#define SSRTID Reflection
-#include "HDRP/Lighting/Reflection/ScreenSpaceTracing.hlsl"
-#undef SSRTID
+#include "HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceLighting.hlsl"
-    #include "CoreRP/ShaderLibrary/Refraction.hlsl"
-    #define SSRTID Refraction
-    #include "HDRP/Lighting/Reflection/ScreenSpaceTracing.hlsl"
-    #undef SSRTID
-
     #if defined(_REFRACTION_PLANE)
     #define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelPlane(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
     #elif defined(_REFRACTION_SPHERE)
     {
         rayOriginWS             = posInput.positionWS;
         rayDirWS                = preLightData.iblR;
-        mipLevel                = PositivePow(preLightData.iblPerceptualRoughness, 0.8) * uint(max(_ColorPyramidScale.z - 1, 0));
+        mipLevel                = PlanarPerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness, _ColorPyramidScale.z);
         invScreenWeightDistance = _SSReflectionInvScreenWeightDistance;
 #ifdef DEBUG_DISPLAY
         debugMode               = DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFLECTION;
     if (IsEnvIndexTexture2D(lightData.envIndex))
     {
         // Empirical remapping
-        iblMipLevel = PositivePow(preLightData.iblPerceptualRoughness, 0.8) * uint(max(_ColorPyramidScale.z - 1, 0));
+        iblMipLevel = PlanarPerceptualRoughnessToMipmapLevel(preLightData.iblPerceptualRoughness, _ColorPyramidScale.z);
     }
     else
 #endif

com.unity.render-pipelines.high-definition/HDRP/Material/MaterialUtilities.hlsl

     else
 #endif
     {
+        // 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;
 #ifdef MODIFY_BAKED_DIFFUSE_LIGHTING
         ModifyBakedDiffuseLighting(V, posInput, surfaceData, builtinData);
 #endif

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

                     hdCamera.SetupGlobalStereoParams(cmd);
 
                 cmd.SetGlobalInt(HDShaderIDs._SSReflectionEnabled, hdCamera.frameSettings.enableSSR ? 1 : 0);
+                cmd.SetGlobalVector(HDShaderIDs._IndirectLightingMultiplier, new Vector4(VolumeManager.instance.stack.GetComponent<IndirectLightingController>().indirectDiffuseIntensity, 0, 0 , 0));
 
                 PushGlobalRTHandle(
                     cmd,
 
                 using (new ProfilingSample(cmd, "HDRenderPipeline::Render", CustomSamplerId.HDRenderPipelineRender.GetSampler()))
                 {
-                    // Do anything we need to do upon a new frame.
-                    m_LightLoop.NewFrame(currentFrameSettings);
-
                     // If we render a reflection view or a preview we should not display any debug information
                     // This need to be call before ApplyDebugDisplaySettings()
                     if (camera.cameraType == CameraType.Reflection || camera.cameraType == CameraType.Preview)
                     {
                         VolumeManager.instance.Update(hdCamera.volumeAnchor, hdCamera.volumeLayerMask);
                     }
+                    
+                    // Do anything we need to do upon a new frame.
+                    // The NewFrame must be after the VolumeManager update and before Resize because it uses properties set in NewFrame
+                    m_LightLoop.NewFrame(currentFrameSettings);
 
                     Resize(hdCamera);
 
 
                     // In both forward and deferred, everything opaque should have been rendered at this point so we can safely copy the depth buffer for later processing.
                     CopyDepthBufferIfNeeded(cmd);
+                    // Depth texture is now ready, bind it (Depth buffer could have been bind before if DBuffer is enable)
+                    cmd.SetGlobalTexture(HDShaderIDs._CameraDepthTexture, GetDepthTexture());
+
                     RenderDepthPyramid(hdCamera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
 
                     // TODO: In the future we will render object velocity at the same time as depth prepass (we need C++ modification for this)
                     RenderCameraVelocity(m_CullResults, hdCamera, renderContext, cmd);
-
-                    // Depth texture is now ready, bind it (Depth buffer could have been bind before if DBuffer is enable)
-                    cmd.SetGlobalTexture(HDShaderIDs._CameraDepthTexture, GetDepthTexture());
 
                     // Caution: We require sun light here as some skies use the sun light to render, it means that UpdateSkyEnvironment must be called after PrepareLightsForGPU.
                     // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
 
                     // Assign -1 in tracing model to notifiy we took the data.
                     // When debugging in forward, we want only the first time the pixel is drawn
-                    data.tracingModel = (Lit.ProjectionModel)(-1);
+                    data.tracingModel = (ScreenSpaceLighting.ProjectionModel)(-1);
                     m_DebugScreenSpaceTracingDataArray[0] = data;
                     m_DebugScreenSpaceTracingData.SetData(m_DebugScreenSpaceTracingDataArray);
                 }

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

         public static readonly int _NumTileFtplY = Shader.PropertyToID("_NumTileFtplY");
         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 g_isLogBaseBufferEnabled = Shader.PropertyToID("g_isLogBaseBufferEnabled");
         public static readonly int g_vLayeredOffsetsBuffer = Shader.PropertyToID("g_vLayeredOffsetsBuffer");

com.unity.render-pipelines.high-definition/HDRP/ShaderVariables.hlsl

 SAMPLER(s_linear_clamp_sampler);
 SAMPLER(s_linear_repeat_sampler);
 SAMPLER(s_trilinear_clamp_sampler);
+SAMPLER(s_trilinear_repeat_sampler);
 
 // ----------------------------------------------------------------------------
 

com.unity.render-pipelines.high-definition/HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceReflection.cs

     [Serializable]
     public class ScreenSpaceReflection : ScreenSpaceLighting
     {
-        // Values must be in sync with Lit.ProjectionModel
+        // Values must be in sync with ScreenSpaceLighting.ProjectionModel
         public enum AvailableProjectionModel
         {
             None = 0,

com.unity.render-pipelines.high-definition/HDRP/AssemblyInfo.cs

+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.RenderPipelines.HighDefinition.Editor")]
+[assembly: InternalsVisibleTo("Unity.RenderPipelines.HighDefinition.Tests")]
+

com.unity.render-pipelines.high-definition/HDRP/AssemblyInfo.cs.meta

+fileFormatVersion: 2
+guid: e57bf701e9cb4a94dadf8040bc7df0cd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System.Collections;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Experimental.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [CanEditMultipleObjects]
+    [VolumeComponentEditor(typeof(IndirectLightingController))]
+    public class IndirectLightingControllerEditor : VolumeComponentEditor
+    {
+        SerializedDataParameter m_IndirectDiffuseIntensity;
+        SerializedDataParameter m_IndirectSpecularIntensity;
+
+        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));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            PropertyField(m_IndirectDiffuseIntensity, CoreEditorUtils.GetContent("Indirect Diffuse Intensity|Multiplier for the baked diffuse lighting."));
+            PropertyField(m_IndirectSpecularIntensity, CoreEditorUtils.GetContent("Indirect Specular Intensity|Multiplier for the reflected specular light."));
+        }
+    }
+}

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

+fileFormatVersion: 2
+guid: 8f4eec32d24065f4db3249afcf3153cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public class IndirectLightingController : VolumeComponent
+    {
+        public MinFloatParameter    indirectSpecularIntensity = new MinFloatParameter(1.0f, 0.0f);
+        public MinFloatParameter    indirectDiffuseIntensity = new MinFloatParameter(1.0f, 0.0f);        
+    }
+}

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

+fileFormatVersion: 2
+guid: f034cba68ab55e046ae1445a42f18c0e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+using UnityEngine.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public abstract class ScreenSpaceLighting : VolumeComponent
+    {
+        public enum RefractionModel
+        {
+            None = 0,
+            Plane = 1,
+            Sphere = 2
+        };
+
+        [GenerateHLSL]
+        public enum ProjectionModel
+        {
+            None = 0,
+            Proxy = 1,
+            HiZ = 2,
+            Linear = 3,
+            Count
+        };
+
+        [GenerateHLSL]
+        public enum HiZIntersectionKind
+        {
+            None,
+            Cell,
+            Depth
+        }
+
+        int m_RayLevelID;
+        int m_RayMinLevelID;
+        int m_RayMaxLevelID;
+        int m_RayMaxIterationsID;
+        int m_DepthBufferThicknessID;
+        int m_InvScreenWeightDistanceID;
+        int m_RayMaxScreenDistanceID;
+        int m_RayBlendScreenDistanceID;
+        int m_RayMarchBehindObjectsID;
+
+        public IntParameter                 rayLevel = new IntParameter(2);
+        public IntParameter                 rayMinLevel = new IntParameter(2);
+        public IntParameter                 rayMaxLevel = new IntParameter(6);
+        public IntParameter                 rayMaxIterations = new IntParameter(32);
+        public FloatParameter               depthBufferThickness = new FloatParameter(1f);
+        public ClampedFloatParameter        screenWeightDistance = new ClampedFloatParameter(0.1f, 0, 1);
+        public ClampedFloatParameter        rayMaxScreenDistance = new ClampedFloatParameter(0.3f, 0, 1);
+        public ClampedFloatParameter        rayBlendScreenDistance = new ClampedFloatParameter(0.1f, 0, 1);
+        public BoolParameter                rayMarchBehindObjects = new BoolParameter(true);
+
+        public virtual void PushShaderParameters(CommandBuffer cmd)
+        {
+            cmd.SetGlobalInt(m_RayLevelID, rayLevel.value);
+            cmd.SetGlobalInt(m_RayMinLevelID, rayMinLevel.value);
+            cmd.SetGlobalInt(m_RayMaxLevelID, rayMaxLevel.value);
+            cmd.SetGlobalInt(m_RayMaxIterationsID, rayMaxIterations.value);
+            cmd.SetGlobalFloat(m_DepthBufferThicknessID, depthBufferThickness.value);
+            cmd.SetGlobalFloat(m_InvScreenWeightDistanceID, 1f / screenWeightDistance.value);
+            cmd.SetGlobalFloat(m_RayMaxScreenDistanceID, rayMaxScreenDistance.value);
+            cmd.SetGlobalFloat(m_RayBlendScreenDistanceID, rayBlendScreenDistance.value);
+            cmd.SetGlobalInt(m_RayMarchBehindObjectsID, rayMarchBehindObjects.value ? 1 : 0);
+        }
+
+        protected abstract void FetchIDs(
+            out int rayLevelID,
+            out int rayMinLevelID,
+            out int rayMaxLevelID,
+            out int rayMaxIterationsID,
+            out int DepthBufferThicknessID,
+            out int invScreenWeightDistanceID,
+            out int rayMaxScreenDistanceID,
+            out int rayBlendScreenDistanceID,
+            out int rayMarchBehindObjectsID
+            );
+
+        void Awake()
+        {
+            FetchIDs(
+                out m_RayLevelID,
+                out m_RayMinLevelID,
+                out m_RayMaxLevelID,
+                out m_RayMaxIterationsID,
+                out m_DepthBufferThicknessID,
+                out m_InvScreenWeightDistanceID,
+                out m_RayMaxScreenDistanceID,
+                out m_RayBlendScreenDistanceID,
+                out m_RayMarchBehindObjectsID
+                );
+        }
+    }
+}

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

+//
+// This file was automatically generated. Please don't edit by hand.
+//
+
+#ifndef SCREENSPACELIGHTING_CS_HLSL
+#define SCREENSPACELIGHTING_CS_HLSL
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.ScreenSpaceLighting+ProjectionModel:  static fields
+//
+#define PROJECTIONMODEL_NONE (0)
+#define PROJECTIONMODEL_PROXY (1)
+#define PROJECTIONMODEL_HI_Z (2)
+#define PROJECTIONMODEL_LINEAR (3)
+#define PROJECTIONMODEL_COUNT (4)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.ScreenSpaceLighting+HiZIntersectionKind:  static fields
+//
+#define HIZINTERSECTIONKIND_NONE (0)
+#define HIZINTERSECTIONKIND_CELL (1)
+#define HIZINTERSECTIONKIND_DEPTH (2)
+
+
+#endif

com.unity.render-pipelines.high-definition/HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceLighting.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 117f0ba79109fbf49a6f34d915d965d0
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceLighting.hlsl

+#ifndef UNITY_SCREENSPACELIGHTING_INCLUDED
+ #define UNITY_SCREENSPACELIGHTING_INCLUDED
+
+#include "HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceLighting.cs.hlsl"
+#include "HDRP/Lighting/Reflection/VolumeProjection.hlsl"
+
+#define SSRTID Reflection
+#include "HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceTracing.hlsl"
+#undef SSRTID
+
+#include "CoreRP/ShaderLibrary/Refraction.hlsl"
+#define SSRTID Refraction
+#include "HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceTracing.hlsl"
+#undef SSRTID
+
+#endif

com.unity.render-pipelines.high-definition/HDRP/Lighting/ScreenSpaceLighting/ScreenSpaceLighting.hlsl.meta

+fileFormatVersion: 2
+guid: 7f4f99197456f344d9545ac794d20867
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/ScreenSpaceLighting.cs

-using System;
-using UnityEngine.Rendering;
-
-namespace UnityEngine.Experimental.Rendering.HDPipeline
-{
-    [Serializable]
-    public abstract class ScreenSpaceLighting : VolumeComponent
-    {
-        int m_RayLevelID;
-        int m_RayMinLevelID;
-        int m_RayMaxLevelID;
-        int m_RayMaxIterationsID;
-        int m_DepthBufferThicknessID;
-        int m_InvScreenWeightDistanceID;
-        int m_RayMaxScreenDistanceID;
-        int m_RayBlendScreenDistanceID;
-        int m_RayMarchBehindObjectsID;
-
-        public IntParameter                 rayLevel = new IntParameter(2);
-        public IntParameter                 rayMinLevel = new IntParameter(2);
-        public IntParameter                 rayMaxLevel = new IntParameter(6);
-        public IntParameter                 rayMaxIterations = new IntParameter(32);
-        public FloatParameter               depthBufferThickness = new FloatParameter(1f);
-        public ClampedFloatParameter        screenWeightDistance = new ClampedFloatParameter(0.1f, 0, 1);
-        public ClampedFloatParameter        rayMaxScreenDistance = new ClampedFloatParameter(0.3f, 0, 1);
-        public ClampedFloatParameter        rayBlendScreenDistance = new ClampedFloatParameter(0.1f, 0, 1);
-        public BoolParameter                rayMarchBehindObjects = new BoolParameter(true);
-
-        public virtual void PushShaderParameters(CommandBuffer cmd)
-        {
-            cmd.SetGlobalInt(m_RayLevelID, rayLevel.value);
-            cmd.SetGlobalInt(m_RayMinLevelID, rayMinLevel.value);
-            cmd.SetGlobalInt(m_RayMaxLevelID, rayMaxLevel.value);
-            cmd.SetGlobalInt(m_RayMaxIterationsID, rayMaxIterations.value);
-            cmd.SetGlobalFloat(m_DepthBufferThicknessID, depthBufferThickness.value);
-            cmd.SetGlobalFloat(m_InvScreenWeightDistanceID, 1f / screenWeightDistance.value);
-            cmd.SetGlobalFloat(m_RayMaxScreenDistanceID, rayMaxScreenDistance.value);
-            cmd.SetGlobalFloat(m_RayBlendScreenDistanceID, rayBlendScreenDistance.value);
-            cmd.SetGlobalInt(m_RayMarchBehindObjectsID, rayMarchBehindObjects.value ? 1 : 0);
-        }
-
-        protected abstract void FetchIDs(
-            out int rayLevelID,
-            out int rayMinLevelID,
-            out int rayMaxLevelID,
-            out int rayMaxIterationsID,
-            out int DepthBufferThicknessID,
-            out int invScreenWeightDistanceID,
-            out int rayMaxScreenDistanceID,
-            out int rayBlendScreenDistanceID,
-            out int rayMarchBehindObjectsID
-            );
-
-        void Awake()
-        {
-            FetchIDs(
-                out m_RayLevelID,
-                out m_RayMinLevelID,
-                out m_RayMaxLevelID,
-                out m_RayMaxIterationsID,
-                out m_DepthBufferThicknessID,
-                out m_InvScreenWeightDistanceID,
-                out m_RayMaxScreenDistanceID,
-                out m_RayBlendScreenDistanceID,
-                out m_RayMarchBehindObjectsID
-                );
-        }
-    }
-}