Merge remote-tracking branch 'origin/master' into build/automation

ScriptableRenderPipeline/Core/CoreRP/RTHandle.cs

         public static int s_MaxWidthMSAAA { get { return s_MaxWidths[(int)RTCategory.MSAA]; } }
         public static int s_MaxHeightMSAA { get { return s_MaxHeights[(int)RTCategory.MSAA]; } }
 
-        private static int GetMaxWith(RTCategory category) { return s_MaxWidths[(int)category]; }
+        private static int GetMaxWidth(RTCategory category) { return s_MaxWidths[(int)category]; }
         private static int GetMaxHeight(RTCategory category) { return s_MaxHeights[(int)category]; }
 
 
         static int[] s_MaxWidths = new int[(int)RTCategory.Count];
         static int[] s_MaxHeights = new int[(int)RTCategory.Count];
 
-        public static int maxWidth { get { return GetMaxWith(s_ScaledRTCurrentCategory); } }
+        public static int maxWidth { get { return GetMaxWidth(s_ScaledRTCurrentCategory); } }
         public static int maxHeight { get { return GetMaxHeight(s_ScaledRTCurrentCategory); } }
 
         static RTHandle()
             height = Mathf.Max(height, 1);
 
             bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
-            if (width > GetMaxWith(category) || height > GetMaxHeight(category) || msaaSamplesChanged)
+            if (width > GetMaxWidth(category) || height > GetMaxHeight(category) || msaaSamplesChanged)
                 Resize(width, height, category, msaaSamples);
         }
 
             height = Mathf.Max(height, 1);
 
             bool msaaSamplesChanged = msaa && (msaaSamples != s_ScaledRTCurrentMSAASamples);
-            if (width != GetMaxWith(category) || height != GetMaxHeight(category) || msaaSamplesChanged)
+            if (width != GetMaxWidth(category) || height != GetMaxHeight(category) || msaaSamplesChanged)
                 Resize(width, height, category, msaaSamples);
         }
 
             bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
             RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
 
-            int width = Mathf.Max(Mathf.RoundToInt(scaleFactor.x * GetMaxWith(category)), 1);
+            int width = Mathf.Max(Mathf.RoundToInt(scaleFactor.x * GetMaxWidth(category)), 1);
             int height = Mathf.Max(Mathf.RoundToInt(scaleFactor.y * GetMaxHeight(category)), 1);
 
             var rth = AllocAutoSizedRenderTexture(width,
             bool allocForMSAA = s_ScaledRTSupportsMSAA ? enableMSAA : false;
             RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
 
-            var scaleFactor = scaleFunc(new Vector2Int(GetMaxWith(category), GetMaxHeight(category)));
+            var scaleFactor = scaleFunc(new Vector2Int(GetMaxWidth(category), GetMaxHeight(category)));
             int width = Mathf.Max(scaleFactor.x, 1);
             int height = Mathf.Max(scaleFactor.y, 1);
 
             }
 
             // MSAA Does not support random read/write.
-            if (allocForMSAA && enableRandomWrite == true)
+            bool UAV = enableRandomWrite;
+            if (allocForMSAA && (UAV == true))
-                Debug.LogWarning("RTHandle allocated with MSAA can't be enableRandomWrite.");
-                enableRandomWrite = false;
+                Debug.LogWarning("RTHandle that is MSAA-enabled cannot allocate MSAA RT with 'enableRandomWrite = true'.");
+                UAV = false;
-            bool UAV = enableRandomWrite;
             RTCategory category = allocForMSAA ? RTCategory.MSAA : RTCategory.Regular;
 
             var rt = new RenderTexture(width, height, (int)depthBufferBits, colorFormat, sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear)
                     anisoLevel = refRT.anisoLevel,
                     mipMapBias = refRT.mipMapBias,
                     antiAliasing = 1, // No MSAA for the regular version of the texture.
-                    bindTextureMS = refRT.bindTextureMS,
+                    bindTextureMS = false, // Somehow, this can be true even if antiAliasing == 1. Leads to Unity-internal binding errors.
                     useDynamicScale = refRT.useDynamicScale,
                     vrUsage = refRT.vrUsage,
                     memorylessMode = refRT.memorylessMode

ScriptableRenderPipeline/Core/CoreRP/Resources/GPUCopy.compute

 
 #include "../ShaderLibrary/Common.hlsl"
 
-SamplerState sampler_LinearClamp;
-
-CBUFFER_START(cb)
-    float4 _Size;
-CBUFFER_END
-
 RWTexture2D<float1> _Result1;
 
 Texture2D<float4> _Source4;

ScriptableRenderPipeline/Core/CoreRP/Resources/GPUCopy.cs

 
         static readonly int _Result1 = Shader.PropertyToID("_Result1");
         static readonly int _Source4 = Shader.PropertyToID("_Source4");
-        static readonly int _Size = Shader.PropertyToID("_Size");
-                var s = new Vector4(size.x, size.y, 1f / size.x, 1f / size.y);
-                cmd.SetComputeVectorParam(m_Shader, _Size, s);
                 cmd.SetComputeTextureParam(m_Shader, k_SampleKernel_xyzw2x, _Source4, source);
                 cmd.SetComputeTextureParam(m_Shader, k_SampleKernel_xyzw2x, _Result1, target);
                 cmd.DispatchCompute(m_Shader, k_SampleKernel_xyzw2x, (int)Mathf.Max((size.x) / 8, 1), (int)Mathf.Max((size.y) / 8, 1), 1);

ScriptableRenderPipeline/Core/CoreRP/Resources/GPUCopyAsset.cs

             csc.AppendLine("        public GPUCopy(ComputeShader shader)");
             csc.AppendLine("        {");
             csc.AppendLine("            m_Shader = shader;");
-            csm.AppendLine("        static readonly int _Size = Shader.PropertyToID(\"_Size\");");
             for (var i = 0; i < operations.Length; i++)
             {
                 var o = operations[i];
                 // CSharp method
                 csm.AppendLine(string.Format(@"        public void SampleCopyChannel_{0}2{1}(CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier target, Vector2 size)", channelName, o.subscript));
                 csm.AppendLine("            {");
-                csm.AppendLine("                var s = new Vector4(size.x, size.y, 1f / size.x, 1f / size.y);");
-                csm.AppendLine("                cmd.SetComputeVectorParam(m_Shader, _Size, s);");
                 csm.AppendLine(string.Format("                cmd.SetComputeTextureParam(m_Shader, {0}, _Source{1}, source);", kernelIndexName, o.sourceChannel.ToString()));
                 csm.AppendLine(string.Format("                cmd.SetComputeTextureParam(m_Shader, {0}, _Result{1}, target);", kernelIndexName, o.targetChannel.ToString()));
                 csm.AppendLine(string.Format("                cmd.DispatchCompute(m_Shader, {0}, (int)Mathf.Max((size.x) / {1}, 1), (int)Mathf.Max((size.y) / {1}, 1), 1);", kernelIndexName, k_KernelSize.ToString()));
             cc.AppendLine(@"// Autogenerated file. Do not edit by hand");
             cc.AppendLine();
             cc.AppendLine(@"#include ""../ShaderLibrary/Common.hlsl""");
-            cc.AppendLine();
-            cc.AppendLine(@"SamplerState sampler_LinearClamp;");
-            cc.AppendLine();
-            cc.AppendLine(@"CBUFFER_START(cb)");
-            cc.AppendLine(@"    float4 _Size;");
-            cc.AppendLine(@"CBUFFER_END");
             cc.AppendLine(ccp.ToString()); // Properties
             cc.AppendLine(cck.ToString()); // Kernels
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

 
             m_ActualWidth = camera.pixelWidth;
             m_ActualHeight = camera.pixelHeight;
+            var screenWidth = m_ActualWidth;
+            var screenHeight = m_ActualHeight;
-                m_ActualWidth = XRSettings.eyeTextureWidth;
-                m_ActualHeight = XRSettings.eyeTextureHeight;
+                screenWidth = XRSettings.eyeTextureWidth;
+                screenHeight = XRSettings.eyeTextureHeight;
+
+                var xrDesc = XRSettings.eyeTextureDesc;
+                m_ActualWidth = xrDesc.width;
+                m_ActualHeight = xrDesc.height;
             }
 
             // Unfortunately sometime (like in the HDCameraEditor) HDUtils.hdrpSettings can be null because of scripts that change the current pipeline...
             m_CameraScaleBias.x = (float)m_ActualWidth / maxWidth;
             m_CameraScaleBias.y = (float)m_ActualHeight / maxHeight;
 
-            screenSize = new Vector4(m_ActualWidth, m_ActualHeight, 1.0f / m_ActualWidth, 1.0f / m_ActualHeight);
+            screenSize = new Vector4(screenWidth, screenHeight, 1.0f / screenWidth, 1.0f / screenHeight);
         }
 
         // Warning: different views can use the same camera!

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineMenuItems.cs

             }
         }
 
+        [MenuItem("Internal/HDRenderPipeline/Update/Update material for subsurface")]
+        static void UpdateMaterialForSubsurface()
+        {
+            try
+            {
+                var matIds = AssetDatabase.FindAssets("t:Material");
+
+                for (int i = 0, length = matIds.Length; i < length; i++)
+                {
+                    var path = AssetDatabase.GUIDToAssetPath(matIds[i]);
+                    var mat = AssetDatabase.LoadAssetAtPath<Material>(path);
+
+                    EditorUtility.DisplayProgressBar(
+                        "Setup materials Keywords...",
+                        string.Format("{0} / {1} materials subsurface updated.", i, length),
+                        i / (float)(length - 1));
+
+                    bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
+
+                    if (mat.shader.name == "HDRenderPipeline/LitTessellation" ||
+                        mat.shader.name == "HDRenderPipeline/Lit" ||
+                        mat.shader.name == "HDRenderPipeline/LayeredLit" ||
+                        mat.shader.name == "HDRenderPipeline/LayeredLitTessellation")
+                    {
+                        float materialID = mat.GetInt("_MaterialID");
+                        if (materialID != 0.0)
+                            continue;
+
+                        if (mat.HasProperty("_SSSAndTransmissionType"))
+                        {
+                            CheckOutFile(VSCEnabled, mat);
+
+                            int materialSSSAndTransmissionID = mat.GetInt("_SSSAndTransmissionType");
+
+                            // Both;, SSS only, Transmission only
+                            if (materialSSSAndTransmissionID == 2.0)
+                            {
+                                mat.SetInt("_MaterialID", 5);
+                            }
+                            else
+                            {
+                                if (materialSSSAndTransmissionID == 0.0)
+                                    mat.SetFloat("_TransmissionEnable", 1.0f);
+                                else
+                                    mat.SetFloat("_TransmissionEnable", 0.0f);
+                            }
+
+                            EditorUtility.SetDirty(mat);
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
+        }
+
         //
         [MenuItem("Internal/HDRenderPipeline/Update/Update Height Maps parametrization")]
         static void UpdateHeightMapParametrization()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/LayeredLit/LayeredLitUI.cs

             public readonly GUIContent inheritBaseNormalText = new GUIContent("Normal influence", "Inherit the normal from the base layer.");
             public readonly GUIContent inheritBaseHeightText = new GUIContent("Heightmap influence", "Inherit the height from the base layer.");
             public readonly GUIContent inheritBaseColorText = new GUIContent("BaseColor influence", "Inherit the base color from the base layer.");
-            public readonly GUIContent heightOffset = new GUIContent("Height Offset", "Offset applied to the height before layering.");
             public readonly GUIContent heightTransition = new GUIContent("Height Transition", "Size in world units of the smooth transition between layers.");
 
             public readonly GUIContent perPixelDisplacementLayersWarning = new GUIContent("For pixel displacement to work correctly, all layers with a heightmap must use the same UV mapping");
         const string kInheritBaseColor = "_InheritBaseColor";
 
         // Height blend
-        MaterialProperty[] heightBlendOffset = new MaterialProperty[kMaxLayerCount];
-        const string kHeightBlendOffset = "_HeightOffset";
         MaterialProperty heightTransition = null;
         const string kHeightTransition = "_HeightTransition";
 
             {
                 // Density/opacity mode
                 opacityAsDensity[i] = FindProperty(string.Format("{0}{1}", kOpacityAsDensity, i), props);
-                heightBlendOffset[i] = FindProperty(string.Format("{0}{1}", kHeightBlendOffset, i), props);
                 showLayer[i] = FindProperty(string.Format("{0}{1}", kShowLayer, i), props);
 
                 if (i != 0)
             Material material = m_MaterialEditor.target as Material;
 
             bool mainLayerInfluenceEnable = useMainLayerInfluence.floatValue > 0.0f;
-            bool heightBasedBlend = useHeightBasedBlend.floatValue > 0.0f;
-            EditorGUILayout.LabelField(styles.layeringOptionText, EditorStyles.boldLabel);
-            EditorGUI.indentLevel++;
-
-            // Main layer does not have any options but height base blend.
-            if (layerIndex > 0)
+            if(mainLayerInfluenceEnable) // This is the only case where we need this sub category.
-                int paramIndex = layerIndex - 1;
+                EditorGUILayout.LabelField(styles.layeringOptionText, EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(opacityAsDensity[layerIndex], styles.opacityAsDensityText);
+                // Main layer does not have any options but height base blend.
+                if (layerIndex > 0)
+                {
+                    int paramIndex = layerIndex - 1;
-                if (mainLayerInfluenceEnable)
-                {
-                    m_MaterialEditor.ShaderProperty(inheritBaseColor[paramIndex], styles.inheritBaseColorText);
-                    m_MaterialEditor.ShaderProperty(inheritBaseNormal[paramIndex], styles.inheritBaseNormalText);
-                    // Main height influence is only available if the shader use the heightmap for displacement (per vertex or per level)
-                    // We always display it as it can be tricky to know when per pixel displacement is enabled or not
-                    m_MaterialEditor.ShaderProperty(inheritBaseHeight[paramIndex], styles.inheritBaseHeightText);
+                    m_MaterialEditor.ShaderProperty(opacityAsDensity[layerIndex], styles.opacityAsDensityText);
+
+                    if (mainLayerInfluenceEnable)
+                    {
+                        m_MaterialEditor.ShaderProperty(inheritBaseColor[paramIndex], styles.inheritBaseColorText);
+                        m_MaterialEditor.ShaderProperty(inheritBaseNormal[paramIndex], styles.inheritBaseNormalText);
+                        // Main height influence is only available if the shader use the heightmap for displacement (per vertex or per level)
+                        // We always display it as it can be tricky to know when per pixel displacement is enabled or not
+                        m_MaterialEditor.ShaderProperty(inheritBaseHeight[paramIndex], styles.inheritBaseHeightText);
+                    }
-            }
-            else
-            {
-                if (!useMainLayerInfluence.hasMixedValue && useMainLayerInfluence.floatValue != 0.0f)
+                else
-                    m_MaterialEditor.TexturePropertySingleLine(styles.layerInfluenceMapMaskText, layerInfluenceMaskMap);
+                    if (!useMainLayerInfluence.hasMixedValue && useMainLayerInfluence.floatValue != 0.0f)
+                    {
+                        m_MaterialEditor.TexturePropertySingleLine(styles.layerInfluenceMapMaskText, layerInfluenceMaskMap);
+                    }
-            }
-            if (heightBasedBlend)
-            {
-                m_MaterialEditor.ShaderProperty(heightBlendOffset[layerIndex], styles.heightOffset);
+                EditorGUI.indentLevel--;
+                EditorGUILayout.Space();
-
-            EditorGUI.indentLevel--;
-            EditorGUILayout.Space();
 
             DoLayerGUI(material, layerIndex, true);
 
             CoreUtils.SetKeyword(material, "_DENSITY_MODE", useDensityModeEnable);
 
             BaseLitGUI.MaterialId materialId = (BaseLitGUI.MaterialId)material.GetFloat(kMaterialID);
-            BaseLitGUI.SSSAndTransmissionType sssAndTransmissionType = (BaseLitGUI.SSSAndTransmissionType)material.GetFloat(kSSSAndTransmissionType);
-
-            if (materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission)
-            {
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSOnly);
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitTransmissionOnly);
-            }
-            else
-            {
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", false);
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", false);
-            }
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", materialId == BaseLitGUI.MaterialId.LitSSS);
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", materialId == BaseLitGUI.MaterialId.LitTranslucent || (materialId == BaseLitGUI.MaterialId.LitSSS && material.GetFloat(kTransmissionEnable) > 0.0f));
         }
 
         public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/BaseLitUI.cs

 
             // Material ID
             public static GUIContent materialIDText = new GUIContent("Material type", "Select a material feature to enable on top of regular material");
-            public static GUIContent SSSAndTransmissionTypeText = new GUIContent("SSS and Transmission type", "Subsurface Scattering for translucent materials such as skin, vegetation, fruit, marble, wax and milk., Transmission for back lighting");
+            public static GUIContent transmissionEnableText = new GUIContent("Enable Transmission", "Enable Transmission for getting  back lighting");
 
             // Per pixel displacement
             public static GUIContent ppdMinSamplesText = new GUIContent("Minimum steps", "Minimum steps (texture sample) to use with per pixel displacement mapping");
 
         public enum MaterialId
         {
-            LitSSSAndTransmission = 0,
+            LitSSS = 0,
-            LitSpecular = 4
-        };
-
-        public enum SSSAndTransmissionType
-        {
-            LitSSSAndTransmission = 0,
-            LitSSSOnly = 1,
-            LitTransmissionOnly = 2,
+            LitSpecular = 4,
+            LitTranslucent = 5
         };
 
         public enum HeightmapParametrization
         // Material ID
         protected MaterialProperty materialID  = null;
         protected const string kMaterialID = "_MaterialID";
-        protected MaterialProperty sssAndTransmissionType = null;
-        protected const string kSSSAndTransmissionType = "_SSSAndTransmissionType";        
+        protected MaterialProperty transmissionEnable = null;
+        protected const string kTransmissionEnable = "_TransmissionEnable";
 
         protected const string kStencilRef = "_StencilRef";
         protected const string kStencilWriteMask = "_StencilWriteMask";
 
             // MaterialID
             materialID = FindProperty(kMaterialID, props);
-            sssAndTransmissionType = FindProperty(kSSSAndTransmissionType, props);      
+            transmissionEnable = FindProperty(kTransmissionEnable, props);
 
             displacementMode = FindProperty(kDisplacementMode, props);
             displacementLockObjectScale = FindProperty(kDisplacementLockObjectScale, props);
 
             m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
 
-            if ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitSSSAndTransmission)
+            if ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitSSS)
-                m_MaterialEditor.ShaderProperty(sssAndTransmissionType, StylesBaseLit.SSSAndTransmissionTypeText);                
-            }                
+                EditorGUI.indentLevel++;
+                m_MaterialEditor.ShaderProperty(transmissionEnable, StylesBaseLit.transmissionEnableText);
+                EditorGUI.indentLevel--;
+            }
 
             m_MaterialEditor.ShaderProperty(supportDBuffer, StylesBaseLit.supportDBufferText);
 
 
             // Set the reference value for the stencil test.
             int stencilRef = (int)StencilLightingUsage.RegularLighting;
-            if ((int)material.GetFloat(kMaterialID) == (int)BaseLitGUI.MaterialId.LitSSSAndTransmission)
+            if ((int)material.GetFloat(kMaterialID) == (int)BaseLitGUI.MaterialId.LitSSS)
-                if ((int)material.GetFloat(kSSSAndTransmissionType) == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission ||
-                    (int)material.GetFloat(kSSSAndTransmissionType) == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSOnly)
-                {
-                    stencilRef = (int)StencilLightingUsage.SplitLighting;
-                }
+                stencilRef = (int)StencilLightingUsage.SplitLighting;
             }
             // As we tag both during velocity pass and Gbuffer pass we need a separate state and we need to use the write mask
             material.SetInt(kStencilRef, stencilRef);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/LitUI.cs

 
             // clear coat
             coatMask = FindProperty(kCoatMask, props);
-            coatMaskMap = FindProperty(kCoatMaskMap, props);            
+            coatMaskMap = FindProperty(kCoatMaskMap, props);
 
             // Transparency
             refractionMode = FindProperty(kRefractionMode, props, false);
                     diffusionProfileID[layerIndex].floatValue = profileID;
             }
 
-            if ((int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || (int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSOnly)
+            if ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitSSS)
-            if ((int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || (int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitTransmissionOnly)
+            if ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitTranslucent ||
+                ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitSSS && transmissionEnable.floatValue > 0.0f))
             {
                 m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap[layerIndex]);
                 if (thicknessMap[layerIndex].textureValue != null)
 
             switch ((BaseLitGUI.MaterialId)materialID.floatValue)
             {
-                case BaseLitGUI.MaterialId.LitSSSAndTransmission:
+                case BaseLitGUI.MaterialId.LitSSS:
+                case BaseLitGUI.MaterialId.LitTranslucent:
                     ShaderSSSAndTransmissionInputGUI(material, layerIndex);
                     break;
                 case BaseLitGUI.MaterialId.LitStandard:
             if (!isLayeredLit)
             {
                 ShaderClearCoatInputGUI();
-            }            
+            }
 
             EditorGUILayout.Space();
 
             }
 
             BaseLitGUI.MaterialId materialId = (BaseLitGUI.MaterialId)material.GetFloat(kMaterialID);
-            BaseLitGUI.SSSAndTransmissionType sssAndTransmissionType = (BaseLitGUI.SSSAndTransmissionType)material.GetFloat(kSSSAndTransmissionType);
-
-            if (materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission)
-            {
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSOnly);
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitTransmissionOnly);
-            }
-            else
-            {
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", false);
-                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", false);
-            }
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", materialId == BaseLitGUI.MaterialId.LitSSS);
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", materialId == BaseLitGUI.MaterialId.LitTranslucent || (materialId == BaseLitGUI.MaterialId.LitSSS && material.GetFloat(kTransmissionEnable) > 0.0f));
 
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_ANISOTROPY", materialId == BaseLitGUI.MaterialId.LitAniso);
             // No material Id for clear coat, just test the attribute

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

                             RenderSSAO(cmd, hdCamera, renderContext, postProcessLayer);
                         }
 
+                        // Clear and copy the stencil texture needs to be moved to before we invoke the async light list build,
+                        // otherwise the async compute queue can end up using that texture before the graphics queue is done with it.
+                        // TODO: Move this code inside LightLoop
+                        if (m_LightLoop.GetFeatureVariantsEnabled())
+                        {
+                            // For material classification we use compute shader and so can't read into the stencil, so prepare it.
+                            using (new ProfilingSample(cmd, "Clear and copy stencil texture", CustomSamplerId.ClearAndCopyStencilTexture.GetSampler()))
+                            {
+                                HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraStencilBufferCopy, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+
+                                // In the material classification shader we will simply test is we are no lighting
+                                // Use ShaderPassID 1 => "Pass 1 - Write 1 if value different from stencilRef to output"
+                                HDUtils.DrawFullScreen(cmd, hdCamera, m_CopyStencilForNoLighting, m_CameraStencilBufferCopy, m_CameraDepthStencilBuffer, null, 1);
+                            }
+                        }
+
                         GPUFence buildGPULightListsCompleteFence = new GPUFence();
                         if (m_FrameSettings.enableAsyncCompute)
                         {
 
                             m_LightLoop.RenderDeferredDirectionalShadow(hdCamera, m_DeferredShadowBuffer, GetDepthTexture(), cmd);
                             PushFullScreenDebugTexture(cmd, m_DeferredShadowBuffer, hdCamera, FullScreenDebugMode.DeferredShadows);
-                        }
-
-                        // TODO: Move this code inside LightLoop
-                        if (m_LightLoop.GetFeatureVariantsEnabled())
-                        {
-                            // For material classification we use compute shader and so can't read into the stencil, so prepare it.
-                            using (new ProfilingSample(cmd, "Clear and copy stencil texture", CustomSamplerId.ClearAndCopyStencilTexture.GetSampler()))
-                            {
-                                HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraStencilBufferCopy, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-
-                                // In the material classification shader we will simply test is we are no lighting
-                                // Use ShaderPassID 1 => "Pass 1 - Write 1 if value different from stencilRef to output"
-                                HDUtils.DrawFullScreen(cmd, hdCamera, m_CopyStencilForNoLighting, m_CameraStencilBufferCopy, m_CameraDepthStencilBuffer, null, 1);
-                            }
                         }
 
                         if (m_FrameSettings.enableAsyncCompute)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.cs

                 m_FrameSettings.CopyTo(m_FrameSettingsRuntime);
 
                 m_frameSettingsIsDirty = false;
+
+                // In Editor we can have plenty of camera that are not render at the same time as SceneView.
+                // It is really tricky to keep in sync with them. To have a coherent state. When a change is done
+                // on HDRenderPipelineAsset, we tag all camera as dirty so we are sure that they will get the
+                // correct default FrameSettings when the camera will be in the HDRenderPipeline.Render() call
+                // otherwise, as SceneView and Game camera are not in the same call Render(), Game camera that use default
+                // will not be update correctly.
+                #if UNITY_EDITOR
+                Camera[] cameras = Camera.allCameras;
+                foreach (Camera camera in cameras)
+                {
+                    var additionalCameraData = camera.GetComponent<HDAdditionalCameraData>();
+                    if (additionalCameraData)
+                    {
+                        // Call OnAfterDeserialize that set dirty on FrameSettings
+                        additionalCameraData.OnAfterDeserialize();
+                    }
+                }
+                #endif
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLit.shader

         _LayerInfluenceMaskMap("LayerInfluenceMaskMap", 2D) = "white" {}
         [ToggleUI] _UseHeightBasedBlend("UseHeightBasedBlend", Float) = 0.0
 
-        _HeightOffset0("Height Offset0", Float) = 0
-        _HeightOffset1("Height Offset1", Float) = 0
-        _HeightOffset2("Height Offset2", Float) = 0
-        _HeightOffset3("Height Offset3", Float) = 0
-
         _HeightTransition("Height Transition", Range(0, 1.0)) = 0.0
 
         [ToggleUI] _UseDensityMode("Use Density mode", Float) = 0.0
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         // For layering, due to combinatorial explosion, we only support SSS/Transmission and Standard. We let other case for the shader graph
-        [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
-        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
+        [Enum(Subsurface Scattering, 0, Standard, 1, Translucent, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
+        [ToggleUI] _TransmissionEnable("_TransmissionEnable", Float) = 1.0
 
         [Enum(None, 0, Vertex displacement, 1, Pixel displacement, 2)] _DisplacementMode("DisplacementMode", Int) = 0
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitData.hlsl

 // Returns layering blend mask after application of height based blend.
 float4 ApplyHeightBlend(float4 heights, float4 blendMask)
 {
-    // Add offsets for all the layers.
-    heights = heights + float4(_HeightOffset0, _HeightOffset1, _HeightOffset2, _HeightOffset3);
-
     // We need to mask out inactive layers so that their height does not impact the result.
     float4 maskedHeights = heights * blendMask.argb;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

         _LayerInfluenceMaskMap("LayerInfluenceMaskMap", 2D) = "white" {}
         [ToggleUI] _UseHeightBasedBlend("UseHeightBasedBlend", Float) = 0.0
 
-        _HeightOffset0("Height Offset0", Float) = 0
-        _HeightOffset1("Height Offset1", Float) = 0
-        _HeightOffset2("Height Offset2", Float) = 0
-        _HeightOffset3("Height Offset3", Float) = 0
-
         _HeightTransition("Height Transition", Range(0, 1.0)) = 0.0
 
         [ToggleUI] _UseDensityMode("Use Density mode", Float) = 0.0
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
         // For layering, due to combinatorial explosion, we only support SSS/Transmission and Standard. We let other case for the shader graph
-        [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
-        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
+        [Enum(Subsurface Scattering, 0, Standard, 1, Translucent, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
+        [ToggleUI] _TransmissionEnable("_TransmissionEnable", Float) = 1.0
 
         [Enum(None, 0, Tessellation displacement, 3)] _DisplacementMode("DisplacementMode", Int) = 3
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

         // Following enum should be material feature flags (i.e bitfield), however due to Gbuffer encoding constrain many combination exclude each other
         // so we use this enum as "material ID" which can be interpreted as preset of bitfield of material feature
         // The only material feature flag that can be added in all cases is clear coat
-        [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1, Anisotropy, 2, Iridescence, 3, Specular Color, 4)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
-        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
+        [Enum(Subsurface Scattering, 0, Standard, 1, Anisotropy, 2, Iridescence, 3, Specular Color, 4, Translucent, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
+        [ToggleUI] _TransmissionEnable("_TransmissionEnable", Float) = 1.0
 
         [Enum(None, 0, Vertex displacement, 1, Pixel displacement, 2)] _DisplacementMode("DisplacementMode", Int) = 0
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

         // Following enum should be material feature flags (i.e bitfield), however due to Gbuffer encoding constrain many combination exclude each other
         // so we use this enum as "material ID" which can be interpreted as preset of bitfield of material feature
         // The only material feature flag that can be added in all cases is clear coat
-        [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1, Anisotropy, 2, Iridescence, 3, Specular Color, 4)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
-        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
+        [Enum(Subsurface Scattering, 0, Standard, 1, Anisotropy, 2, Iridescence, 3, Specular Color, 4, Translucent, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
+        [ToggleUI] _TransmissionEnable("_TransmissionEnable", Float) = 1.0
 
         [Enum(None, 0, Tessellation displacement, 3)] _DisplacementMode("DisplacementMode", Int) = 3
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0