Add support of per light shadow mask control

Add support of per light shadow mask control

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.Styles.cs

             public readonly GUIContent maxSmoothness = new GUIContent("Max Smoothness", "Very low cost way of faking spherical area lighting. This will modify the roughness of the material lit. This is useful when the specular highlight is too small or too sharp.");
             public readonly GUIContent affectDiffuse = new GUIContent("Affect Diffuse", "This will disable diffuse lighting for this light. Doesn't save performance, diffuse lighting is still computed.");
             public readonly GUIContent affectSpecular = new GUIContent("Affect Specular", "This will disable specular lighting for this light. Doesn't save performance, specular lighting is still computed.");
+            public readonly GUIContent nonLightmappedOnly = new GUIContent("Non Lightmapped Only", "This will disable the rendering of lightmapped object for shadow map. Only effective with shadow mask feature");
             public readonly GUIContent lightDimmer = new GUIContent("Dimmer", "Aim to be used with script, timeline or animation. It allows dimming one or multiple lights of heterogeneous intensity easily (without needing to know the intensity of each light).");
             public readonly GUIContent volumetricDimmer = new GUIContent("Volumetric Dimmer", "Allows to reduce the intensity of the scattered volumetric lighting.");
             public readonly GUIContent fadeDistance = new GUIContent("Fade Distance", "The distance at which the light will smoothly fade before being culled to minimize popping.");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.cs

             public SerializedProperty fadeDistance;
             public SerializedProperty affectDiffuse;
             public SerializedProperty affectSpecular;
+            public SerializedProperty nonLightmappedOnly;
             public SerializedProperty lightTypeExtent;
             public SerializedProperty spotLightShape;
             public SerializedProperty shapeWidth;
                 fadeDistance = o.Find(x => x.fadeDistance),
                 affectDiffuse = o.Find(x => x.affectDiffuse),
                 affectSpecular = o.Find(x => x.affectSpecular),
+                nonLightmappedOnly = o.Find(x => x.nonLightmappedOnly),
                 lightTypeExtent = o.Find(x => x.lightTypeExtent),
                 spotLightShape = o.Find(x => x.spotLightShape),
                 shapeWidth = o.Find(x => x.shapeWidth),
                 case LightType.Point:
                     EditorGUILayout.PropertyField(settings.bakedShadowRadiusProp, s_Styles.bakedShadowRadius);
                     break;
+            }
+
+
+            if (settings.isMixed)
+            {
+                EditorGUI.BeginChangeCheck();
+
+                EditorGUILayout.PropertyField(m_AdditionalLightData.nonLightmappedOnly, s_Styles.nonLightmappedOnly);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    ((Light)target).lightShadowCasterMode = m_AdditionalLightData.nonLightmappedOnly.boolValue ? LightShadowCasterMode.NonLightmappedOnly : LightShadowCasterMode.Everything;
+                }
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Light/HDAdditionalLightData.cs

         public bool affectDiffuse = true;
         public bool affectSpecular = true;
 
+        // This property work only with shadow mask and allow to say we don't render any lightMapped object in the shadow map
+        public bool nonLightmappedOnly = false;
+
         public LightTypeExtent lightTypeExtent = LightTypeExtent.Punctual;
 
         // Only for Spotlight, should be hide for other light
                 light.lightmapBakeType = LightmapBakeType.Realtime;
 #endif
             }
+
+            // We don't use the global settings of shadow mask by default
+            light.lightShadowCasterMode = LightShadowCasterMode.Everything;
 
             // At first init we need to initialize correctly the default value
             lightData.ConvertPhysicalLightIntensityToLightIntensity();

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs

         public float diffuseScale;
 
         public float volumetricDimmer;
-        public int dynamicShadowCasterOnly; // Use with ShadowMask feature // TODO: make it a bool
+        public int nonLightmappedOnly; // Use with ShadowMask feature // TODO: make it a bool
 
         public Vector4 shadowMaskSelector; // Use with ShadowMask feature
     };
         public float angleScale;  // Spot light
         public float angleOffset; // Spot light
         public float shadowDimmer;
-        public int dynamicShadowCasterOnly; // Use with ShadowMask feature // TODO: make it a bool
+        public int nonLightmappedOnly; // Use with ShadowMask feature // TODO: make it a bool
 
         public Vector4 shadowMaskSelector; // Use with ShadowMask feature
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs.hlsl

     float3 up;
     float diffuseScale;
     float volumetricDimmer;
-    int dynamicShadowCasterOnly;
+    int nonLightmappedOnly;
     float4 shadowMaskSelector;
 };
 
     float angleScale;
     float angleOffset;
     float shadowDimmer;
-    int dynamicShadowCasterOnly;
+    int nonLightmappedOnly;
     float4 shadowMaskSelector;
     float2 size;
     int lightType;
 {
 	return value.volumetricDimmer;
 }
-int GetDynamicShadowCasterOnly(DirectionalLightData value)
+int GetNonLightmappedOnly(DirectionalLightData value)
-	return value.dynamicShadowCasterOnly;
+	return value.nonLightmappedOnly;
 }
 float4 GetShadowMaskSelector(DirectionalLightData value)
 {
 {
 	return value.shadowDimmer;
 }
-int GetDynamicShadowCasterOnly(LightData value)
+int GetNonLightmappedOnly(LightData value)
-	return value.dynamicShadowCasterOnly;
+	return value.nonLightmappedOnly;
 }
 float4 GetShadowMaskSelector(LightData value)
 {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightEvaluation.hlsl

         fade = ((shadowSplitIndex + 1) == cascadeCount || shadowSplitIndex == -1.0) ? fade : 0.0;
 
         // See comment in EvaluateBSDF_Punctual
-        shadow = lightData.dynamicShadowCasterOnly ? min(shadowMask, shadow) : shadow;
+        shadow = lightData.nonLightmappedOnly ? min(shadowMask, shadow) : shadow;
         // In the transition code (both dithering and blend) we use shadow = lerp( shadow, 1.0, fade ) for last transition
         // mean if we expend the code we have (shadow * (1 - fade) + fade). Here to make transition with shadow mask
         // we will remove fade and add fade * shadowMask which mean we do a lerp with shadow mask
         // The min handle the case of having only dynamic objects in the ShadowMap
         // The second case for blend with distance is handled with ShadowDimmer. ShadowDimmer is define manually and by shadowDistance by light.
         // With distance, ShadowDimmer become one and only the ShadowMask appear, we get the blend with distance behavior.
-        shadow = lightData.dynamicShadowCasterOnly ? min(shadowMask, shadow) : shadow;
+        shadow = lightData.nonLightmappedOnly ? min(shadowMask, shadow) : shadow;
         shadow = lerp(shadowMask, shadow, lightData.shadowDimmer);
 #else
         shadow = lerp(1.0, shadow, lightData.shadowDimmer);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

             if (IsBakedShadowMaskLight(light.light))
             {
                 directionalLightData.shadowMaskSelector[light.light.bakingOutput.occlusionMaskChannel] = 1.0f;
-                // TODO: make this option per light, not global
-                directionalLightData.dynamicShadowCasterOnly = QualitySettings.shadowmaskMode == ShadowmaskMode.Shadowmask ? 1 : 0;
+                directionalLightData.nonLightmappedOnly = light.light.lightShadowCasterMode == LightShadowCasterMode.NonLightmappedOnly ? 1 : 0;
-                directionalLightData.dynamicShadowCasterOnly = 0;
+                directionalLightData.nonLightmappedOnly = 0;
             }
 
             // Fallback to the first non shadow casting directional light.
             {
                 lightData.shadowMaskSelector[light.light.bakingOutput.occlusionMaskChannel] = 1.0f;
                 // TODO: make this option per light, not global
-                lightData.dynamicShadowCasterOnly = QualitySettings.shadowmaskMode == ShadowmaskMode.Shadowmask ? 1 : 0;
+                lightData.nonLightmappedOnly = light.light.lightShadowCasterMode == LightShadowCasterMode.NonLightmappedOnly ? 1 : 0;
-                lightData.dynamicShadowCasterOnly = 0;
+                lightData.nonLightmappedOnly = 0;
             }
 
             m_lightList.lights.Add(lightData);
 
                 // If any light require it, we need to enabled bake shadow mask feature
                 m_enableBakeShadowMask = false;
- 
+
                 m_lightList.Clear();
 
                 // We need to properly reset this here otherwise if we go from 1 light to no visible light we would keep the old reference active.