Merge pull request #1873 from Unity-Technologies/HDRP/add-LightLayer-in-probes

Hdrp/add light layer in probes

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

                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField("Additional Settings", EditorStyles.boldLabel);
                 EditorGUI.indentLevel++;
-                m_AdditionalLightData.lightLayers.intValue = Convert.ToInt32(EditorGUILayout.EnumFlagsField(s_Styles.lightLayer, (LightLayerEnum)m_AdditionalLightData.lightLayers.intValue));
+                var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+                using (new SettingsDisableScope(hdPipeline.asset.renderPipelineSettings.supportLightLayers))
+                {
+                    m_AdditionalLightData.lightLayers.intValue = Convert.ToInt32(EditorGUILayout.EnumFlagsField(s_Styles.lightLayer, (LightLayerEnum)m_AdditionalLightData.lightLayers.intValue));
+                }
                 EditorGUILayout.PropertyField(m_AdditionalLightData.affectDiffuse, s_Styles.affectDiffuse);
                 EditorGUILayout.PropertyField(m_AdditionalLightData.affectSpecular, s_Styles.affectSpecular);
                 if (m_LightShape != LightShape.Directional)

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDProbeUI.ContextualMenu.cs.meta

 fileFormatVersion: 2
-guid: 3f4d3bee74f54434ca6db826ccc28f6f
+guid: f9ddf94c77394c14986865eb30c51d79
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

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

 using System.Collections.Generic;
 using UnityEditorInternal;
 using UnityEngine;
+using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 using UnityEngine.Rendering;
 
 
         protected static void Drawer_SectionCustomSettings(HDProbeUI s, SerializedHDProbe d, Editor o)
         {
+            var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+            using (new SettingsDisableScope(hdPipeline.asset.renderPipelineSettings.supportLightLayers))
+            {
+                d.lightLayers.intValue = Convert.ToInt32(EditorGUILayout.EnumFlagsField(lightLayersContent, (LightLayerEnum)d.lightLayers.intValue));
+            }
+
             EditorGUILayout.PropertyField(d.weight, weightContent);
 
             EditorGUI.BeginChangeCheck();

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

 
         static readonly GUIContent weightContent = CoreEditorUtils.GetContent("Weight|Blend weight applied on this reflection probe. This can be used for fading in or out a reflection probe.");
         static readonly GUIContent multiplierContent = CoreEditorUtils.GetContent("Intensity Multiplier|Allows you to boost or dimmer the reflected cubemap. Values above 1 will make reflections brighter and values under 1 will make reflections darker. Using values different than 1 is not physically correct.");
+        static readonly GUIContent lightLayersContent = CoreEditorUtils.GetContent("Light Layers|Specifies the current light layers that the light affect. Corresponding renderer with the same flags will be lit by this light.");
 
         static readonly GUIContent textureSizeContent = CoreEditorUtils.GetContent("Probe Texture Size (Set By HDRP)");
         static readonly GUIContent compressionTextureContent = CoreEditorUtils.GetContent("Probe Compression (Set By HDRP)");

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

 
         internal SerializedFrameSettings frameSettings;
 
+        internal SerializedProperty lightLayers;
+
         internal SerializedProperty mode;
         internal SerializedProperty refreshMode;
 
 
             frameSettings = new SerializedFrameSettings(serializedObject.Find((HDProbe p) => p.frameSettings));
 
+            lightLayers = serializedObject.Find((HDProbe p) => p.lightLayers);
+
             mode = serializedObject.Find((HDProbe p) => p.mode);
             refreshMode = serializedObject.Find((HDProbe p) => p.refreshMode);
         }

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

     public struct EnvLightData
     {
         // Packing order depends on chronological access to avoid cache misses
+        public uint lightLayers;
 
         // Proxy properties
         public Vector3 capturePositionRWS;

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

 // PackingRules = Exact
 struct EnvLightData
 {
+    uint lightLayers;
     float3 capturePositionRWS;
     int influenceShapeType;
     float3 proxyExtents;

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

             // Build light data
             var envLightData = new EnvLightData();
 
+            envLightData.lightLayers = probe.GetLightLayers();
             envLightData.influenceShapeType = probe.influenceShapeType;
             envLightData.weight = probe.weight;
             envLightData.multiplier = probe.multiplier * m_indirectLightingController.indirectSpecularIntensity;

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

     }
 
     // Define macro for a better understanding of the loop
-#define EVALUATE_BSDF_ENV(envLightData, TYPE, type) \
-    IndirectLighting lighting = EvaluateBSDF_Env(context, V, posInput, preLightData, envLightData, bsdfData, envLightData.influenceShapeType, MERGE_NAME(GPUIMAGEBASEDLIGHTINGTYPE_, TYPE), MERGE_NAME(type, HierarchyWeight)); \
-    AccumulateIndirectLighting(lighting, aggregateLighting);
+#define EVALUATE_BSDF_ENV_SKY(envLightData, TYPE, type) \
+        IndirectLighting lighting = EvaluateBSDF_Env(context, V, posInput, preLightData, envLightData, bsdfData, envLightData.influenceShapeType, MERGE_NAME(GPUIMAGEBASEDLIGHTINGTYPE_, TYPE), MERGE_NAME(type, HierarchyWeight)); \
+        AccumulateIndirectLighting(lighting, aggregateLighting);
+
+// Environment cubemap test lightlayers, sky don't test it
+#define EVALUATE_BSDF_ENV(envLightData, TYPE, type) if (IsMatchingLightLayer(envLightData.lightLayers, builtinData.renderingLayers)) { EVALUATE_BSDF_ENV_SKY(envLightData, TYPE, type) }
 
     // First loop iteration
     if (featureFlags & (LIGHTFEATUREFLAGS_ENV | LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_SSREFRACTION | LIGHTFEATUREFLAGS_SSREFLECTION))
             // Only apply the sky if we haven't yet accumulated enough IBL lighting.
             if (reflectionHierarchyWeight < 1.0)
             {
-                EVALUATE_BSDF_ENV(envLightSky, REFLECTION, reflection);
+                EVALUATE_BSDF_ENV_SKY(envLightSky, REFLECTION, reflection);
             }
 
             if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
-                    EVALUATE_BSDF_ENV(envLightSky, REFRACTION, refraction);
+                    EVALUATE_BSDF_ENV_SKY(envLightSky, REFRACTION, refraction);
+#undef EVALUATE_BSDF_ENV_SKY    
 
     // Also Apply indiret diffuse (GI)
     // PostEvaluateBSDF will perform any operation wanted by the material and sum everything into diffuseLighting and specularLighting

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

 {
     EnvLightData output;
     ZERO_INITIALIZE(EnvLightData, output);
+    output.lightLayers = 0xFFFFFFFF; // Enable sky for all layers
     output.influenceShapeType = ENVSHAPETYPE_SKY;
     // 31 bit index, 1 bit cache type
     output.envIndex = ENVCACHETYPE_CUBEMAP | (envIndex << 1);

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

         
         RenderTexture m_RealtimeTexture = null;
 
+        /// <summary>Light layer to use by this probe.</summary>
+        public LightLayerEnum lightLayers = LightLayerEnum.LightLayerDefault;
+
+        // This function return a mask of light layers as uint and handle the case of Everything as being 0xFF and not -1
+        public uint GetLightLayers()
+        {
+            int value = (int)(lightLayers);
+            return value < 0 ? (uint)LightLayerEnum.Everything : (uint)value;
+        }
+
         /// <summary>ProxyVolume currently used by this probe.</summary>
         public ReflectionProxyVolumeComponent proxyVolume { get { return m_ProxyVolume; } }
 

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

         public abstract Matrix4x4 proxyToWorld { get; }
         public abstract Vector3 proxyExtents { get; }
         public abstract bool infiniteProjection { get; }
+        public abstract uint GetLightLayers();
     }
 
     class VisibleReflectionProbeWrapper : ProbeWrapper
                     : influenceToWorld;
             }
         }
+
+        public override uint GetLightLayers() { return additional.GetLightLayers(); }
     }
 
     class PlanarReflectionProbeWrapper : ProbeWrapper
         public override ReflectionProbeMode mode { get { return planarReflectionProbe.mode; } }
 
         public override Matrix4x4 proxyToWorld { get { return planarReflectionProbe.proxyToWorld; } }
+
+        public override uint GetLightLayers() { return planarReflectionProbe.GetLightLayers(); }
     }
 }

com.unity.render-pipelines.core/CoreRP/Editor/SettingsDisableScope.cs

+using System;
+using UnityEngine;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    public class SettingsDisableScope : IDisposable
+    {
+        bool enable;
+
+        public SettingsDisableScope(bool enable)
+        {
+            this.enable = enable;
+            if (!enable)
+                GUI.enabled = false;
+        }
+
+        public void Dispose()
+        {
+            if (!enable)
+                GUI.enabled = true;
+        }
+    }
+}

com.unity.render-pipelines.core/CoreRP/Editor/SettingsDisableScope.cs.meta

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