Merge Unity-2017.3

ScriptableRenderPipeline/Core/ShaderLibrary/BSDF.hlsl

 }
 
 // Precompute part of lambdaV
-float GetSmithJointGGXPreLambdaV(float NdotV, float roughness)
+float GetSmithJointGGXPartLambdaV(float NdotV, float roughness)
 {
     float a2 = roughness * roughness;
     return sqrt((-NdotV * a2 + NdotV) * NdotV + a2);
 // Ref: http://jcgt.org/published/0003/02/03/paper.pdf
-float V_SmithJointGGX(float NdotL, float NdotV, float roughness, float preLambdaV)
+float V_SmithJointGGX(float NdotL, float NdotV, float roughness, float partLambdaV)
 {
     float a2 = roughness * roughness;
 
     // G        = 1 / (1 + lambda_v + lambda_l);
 
     // Reorder code to be more optimal:
-    float lambdaV = NdotL * preLambdaV;
+    float lambdaV = NdotL * partLambdaV;
     float lambdaL = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
 
     // Simplify visibility term: (2.0 * NdotL * NdotV) /  ((4.0 * NdotL * NdotV) * (lambda_v + lambda_l));
 float V_SmithJointGGX(float NdotL, float NdotV, float roughness)
 {
-    float preLambdaV = GetSmithJointGGXPreLambdaV(NdotV, roughness);
-    return V_SmithJointGGX(NdotL, NdotV, roughness, preLambdaV);
+    float partLambdaV = GetSmithJointGGXPartLambdaV(NdotV, roughness);
+    return V_SmithJointGGX(NdotL, NdotV, roughness, partLambdaV);
-float DV_SmithJointGGX(float NdotH, float NdotL, float NdotV, float roughness, float preLambdaV)
+float DV_SmithJointGGX(float NdotH, float NdotL, float NdotV, float roughness, float partLambdaV)
-    float lambdaV = NdotL * preLambdaV;
+    float lambdaV = NdotL * partLambdaV;
     float lambdaL = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
 
     float2 G = float2(1, lambdaV + lambdaL); // Fraction without the constant (0.5)
 
 float DV_SmithJointGGX(float NdotH, float NdotL, float NdotV, float roughness)
 {
-    float preLambdaV = GetSmithJointGGXPreLambdaV(NdotV, roughness);
-    return DV_SmithJointGGX(NdotH, NdotL, NdotV, roughness, preLambdaV);
+    float partLambdaV = GetSmithJointGGXPartLambdaV(NdotV, roughness);
+    return DV_SmithJointGGX(NdotH, NdotL, NdotV, roughness, partLambdaV);
 }
 
 // Precompute a part of LambdaV.
 // https://www.desmos.com/calculator/wtp8lnjutx
-float GetSmithJointGGXPreLambdaVApprox(float NdotV, float roughness)
+float GetSmithJointGGXPartLambdaVApprox(float NdotV, float roughness)
-float V_SmithJointGGXApprox(float NdotL, float NdotV, float roughness, float preLambdaV)
+float V_SmithJointGGXApprox(float NdotL, float NdotV, float roughness, float partLambdaV)
-    float lambdaV = NdotL * preLambdaV;
+    float lambdaV = NdotL * partLambdaV;
     float lambdaL = NdotV * (NdotL * (1 - a) + a);
 
     return 0.5 / (lambdaV + lambdaL);
 {
-    float preLambdaV = GetSmithJointGGXPreLambdaVApprox(NdotV, roughness);
-    return V_SmithJointGGXApprox(NdotL, NdotV, roughness, preLambdaV);
+    float partLambdaV = GetSmithJointGGXPartLambdaVApprox(NdotV, roughness);
+    return V_SmithJointGGXApprox(NdotL, NdotV, roughness, partLambdaV);
 }
 
 // roughnessT -> roughness in tangent direction
     return INV_PI * D_GGXAnisoNoPI(TdotH, BdotH, NdotH, roughnessT, roughnessB);
 }
 
-float GetSmithJointGGXAnisoPreLambdaV(float TdotV, float BdotV, float NdotV, float roughnessT, float roughnessB)
+float GetSmithJointGGXAnisoPartLambdaV(float TdotV, float BdotV, float NdotV, float roughnessT, float roughnessB)
 {
     float aT2 = roughnessT * roughnessT;
     float aB2 = roughnessB * roughnessB;
 
 // Note: V = G / (4 * NdotL * NdotV)
 // Ref: https://cedec.cesa.or.jp/2015/session/ENG/14698.html The Rendering Materials of Far Cry 4
-float V_SmithJointGGXAniso(float TdotV, float BdotV, float NdotV, float TdotL, float BdotL, float NdotL, float roughnessT, float roughnessB, float preLambdaV)
+float V_SmithJointGGXAniso(float TdotV, float BdotV, float NdotV, float TdotL, float BdotL, float NdotL, float roughnessT, float roughnessB, float partLambdaV)
-    float lambdaV = NdotL * preLambdaV;
+    float lambdaV = NdotL * partLambdaV;
     float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);
 
     return 0.5 / (lambdaV + lambdaL);
 {
-    float preLambdaV = GetSmithJointGGXAnisoPreLambdaV(TdotV, BdotV, NdotV, roughnessT, roughnessB);
-    return V_SmithJointGGXAniso(TdotV, BdotV, NdotV, TdotL, BdotL, NdotL, roughnessT, roughnessB, preLambdaV);
+    float partLambdaV = GetSmithJointGGXAnisoPartLambdaV(TdotV, BdotV, NdotV, roughnessT, roughnessB);
+    return V_SmithJointGGXAniso(TdotV, BdotV, NdotV, TdotL, BdotL, NdotL, roughnessT, roughnessB, partLambdaV);
 }
 
 // Inline D_GGXAniso() * V_SmithJointGGXAniso() together for better code generation.
-                            float roughnessT, float roughnessB, float preLambdaV)
+                            float roughnessT, float roughnessB, float partLambdaV)
 {
     float aT2 = roughnessT * roughnessT;
     float aB2 = roughnessB * roughnessB;
 
-    float lambdaV = NdotL * preLambdaV;
+    float lambdaV = NdotL * partLambdaV;
     float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);
 
     float2 G = float2(1, lambdaV + lambdaL);               // Fraction without the constant (0.5)
                             float TdotL, float BdotL, float NdotL,
                             float roughnessT, float roughnessB)
 {
-    float preLambdaV = GetSmithJointGGXAnisoPreLambdaV(TdotV, BdotV, NdotV, roughnessT, roughnessB);
+    float partLambdaV = GetSmithJointGGXAnisoPartLambdaV(TdotV, BdotV, NdotV, roughnessT, roughnessB);
-                                 roughnessT, roughnessB, preLambdaV);
+                                 roughnessT, roughnessB, partLambdaV);
 }
 
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/Core/ShaderLibrary/ImageBasedLighting.hlsl

     float3x3 localToWorld = GetLocalFrame(N);
 
 #ifndef USE_KARIS_APPROXIMATION
-    float NdotV      = 1; // N == V
-    float preLambdaV = GetSmithJointGGXPreLambdaV(NdotV, roughness);
+    float NdotV       = 1; // N == V
+    float partLambdaV = GetSmithJointGGXPartLambdaV(NdotV, roughness);
 #endif
 
     float3 lightInt = float3(0.0, 0.0, 0.0);
     #ifndef USE_KARIS_APPROXIMATION
         // The choice of the Fresnel factor does not appear to affect the result.
         float F = 1; // F_Schlick(F0, LdotH);
-        float V = V_SmithJointGGX(NdotL, NdotV, roughness, preLambdaV);
+        float V = V_SmithJointGGX(NdotL, NdotV, roughness, partLambdaV);
         float G = V * NdotL * NdotV; // 4 cancels out
 
         lightInt += F * G * val;

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

 using System;
 using UnityEngine;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 using System.Linq;
 
                 SetKeyword(material, "_DETAIL_MAP" + i, material.GetTexture(kDetailMap + i));
 
                 SetKeyword(material, "_HEIGHTMAP" + i, material.GetTexture(kHeightMap + i));
+
+                SetKeyword(material, "_SUBSURFACE_RADIUS_MAP" + i, material.GetTexture(kSubsurfaceRadiusMap + i));
+                SetKeyword(material, "_THICKNESSMAP" + i, material.GetTexture(kThicknessMap + i));
             }
 
             SetKeyword(material, "_INFLUENCEMASK_MAP", material.GetTexture(kLayerInfluenceMaskMap) && material.GetFloat(kkUseMainLayerInfluence) != 0.0f);
                 useDensityModeEnable |= material.GetFloat(kOpacityAsDensity + i) != 0.0f;
             }
             SetKeyword(material, "_DENSITY_MODE", useDensityModeEnable);
+
+            Lit.MaterialId materialId = (Lit.MaterialId)material.GetFloat(kMaterialID);
+
+            SetKeyword(material, "_MATID_SSS", materialId == Lit.MaterialId.LitSSS);
+            //SetKeyword(material, "_MATID_STANDARD", materialId == Lit.MaterialId.LitStandard); // See comment in Lit.shader, it is the default, we don't define it
         }
         private void DoEmissiveGUI(Material material)
         {

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace2("NormalMap space", Float) = 0
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace3("NormalMap space", Float) = 0
 
+        _SubsurfaceProfile0("Subsurface Profile0", Int) = 0
+        _SubsurfaceProfile1("Subsurface Profile1", Int) = 0
+        _SubsurfaceProfile2("Subsurface Profile2", Int) = 0
+        _SubsurfaceProfile3("Subsurface Profile3", Int) = 0
+
+        _SubsurfaceRadius0("Subsurface Radius0", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceRadius1("Subsurface Radius1", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceRadius2("Subsurface Radius2", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceRadius3("Subsurface Radius3", Range(0.0, 1.0)) = 1.0
+
+        _SubsurfaceRadiusMap0("Subsurface Radius Map0", 2D) = "white" {}
+        _SubsurfaceRadiusMap1("Subsurface Radius Map1", 2D) = "white" {}
+        _SubsurfaceRadiusMap2("Subsurface Radius Map2", 2D) = "white" {}
+        _SubsurfaceRadiusMap3("Subsurface Radius Map3", 2D) = "white" {}
+
+        _Thickness0("Thickness", Range(0.0, 1.0)) = 1.0
+        _Thickness1("Thickness", Range(0.0, 1.0)) = 1.0
+        _Thickness2("Thickness", Range(0.0, 1.0)) = 1.0
+        _Thickness3("Thickness", Range(0.0, 1.0)) = 1.0
+
+        _ThicknessMap0("Thickness Map", 2D) = "white" {}
+        _ThicknessMap1("Thickness Map", 2D) = "white" {}
+        _ThicknessMap2("Thickness Map", 2D) = "white" {}
+        _ThicknessMap3("Thickness Map", 2D) = "white" {}
+
         // All the following properties exist only in layered lit material
 
         // Layer blending options
         [ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0
         [Enum(None, 0, Mirror, 1, Flip, 2)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
+
+        [Enum(Subsurface Scattering, 0, Standard, 1)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
 
         [Enum(None, 0, Vertex displacement, 1, Pixel displacement, 2)] _DisplacementMode("DisplacementMode", Int) = 0
         [ToggleOff] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0
     #pragma shader_feature _BENTNORMALMAP3
     #pragma shader_feature _EMISSIVE_COLOR_MAP
     #pragma shader_feature _ENABLESPECULAROCCLUSION
+    #pragma shader_feature _DETAIL_MAP0
+    #pragma shader_feature _DETAIL_MAP1
+    #pragma shader_feature _DETAIL_MAP2
+    #pragma shader_feature _DETAIL_MAP3
-    #pragma shader_feature _DETAIL_MAP0
-    #pragma shader_feature _DETAIL_MAP1
-    #pragma shader_feature _DETAIL_MAP2
-    #pragma shader_feature _DETAIL_MAP3
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP0
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP1
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP2
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP3
+    #pragma shader_feature _THICKNESSMAP0
+    #pragma shader_feature _THICKNESSMAP1
+    #pragma shader_feature _THICKNESSMAP2
+    #pragma shader_feature _THICKNESSMAP3
+
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
     #pragma shader_feature _MAIN_LAYER_INFLUENCE_MODE
     #pragma shader_feature _INFLUENCEMASK_MAP
     #pragma shader_feature _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_MULTIPLY _BLENDMODE_PRE_MULTIPLY
     #pragma shader_feature _BLENDMODE_PRESERVE_SPECULAR_LIGHTING
     #pragma shader_feature _ENABLE_FOG_ON_TRANSPARENT
+
+    // MaterialId are used as shader feature to allow compiler to optimize properly
+    // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
+    #pragma shader_feature _ _MATID_SSS
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace2("NormalMap space", Float) = 0
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace3("NormalMap space", Float) = 0
 
+        _SubsurfaceProfile0("Subsurface Profile0", Int) = 0
+        _SubsurfaceProfile1("Subsurface Profile1", Int) = 0
+        _SubsurfaceProfile2("Subsurface Profile2", Int) = 0
+        _SubsurfaceProfile3("Subsurface Profile3", Int) = 0
+
+        _SubsurfaceRadius0("Subsurface Radius0", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceRadius1("Subsurface Radius1", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceRadius2("Subsurface Radius2", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceRadius3("Subsurface Radius3", Range(0.0, 1.0)) = 1.0
+
+        _SubsurfaceRadiusMap0("Subsurface Radius Map0", 2D) = "white" {}
+        _SubsurfaceRadiusMap1("Subsurface Radius Map1", 2D) = "white" {}
+        _SubsurfaceRadiusMap2("Subsurface Radius Map2", 2D) = "white" {}
+        _SubsurfaceRadiusMap3("Subsurface Radius Map3", 2D) = "white" {}
+
+        _Thickness0("Thickness", Range(0.0, 1.0)) = 1.0
+        _Thickness1("Thickness", Range(0.0, 1.0)) = 1.0
+        _Thickness2("Thickness", Range(0.0, 1.0)) = 1.0
+        _Thickness3("Thickness", Range(0.0, 1.0)) = 1.0
+
+        _ThicknessMap0("Thickness Map", 2D) = "white" {}
+        _ThicknessMap1("Thickness Map", 2D) = "white" {}
+        _ThicknessMap2("Thickness Map", 2D) = "white" {}
+        _ThicknessMap3("Thickness Map", 2D) = "white" {}
+
         // All the following properties exist only in layered lit material
 
         // Layer blending options
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
 
         // Stencil state
-        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting (fixed at compile time)
+        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
         [Enum(None, 0, Mirror, 1, Flip, 2)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1
         [HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0)
 
+    	[Enum(Subsurface Scattering, 0, Standard, 1)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
         [Enum(None, 0, Vertex displacement, 1, Pixel displacement, 2, Tessellation displacement, 3)] _DisplacementMode("DisplacementMode", Int) = 0
         [ToggleOff] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0
         [ToggleOff] _DisplacementLockTilingScale("displacement lock tiling scale", Float) = 1.0
     #pragma shader_feature _BENTNORMALMAP3
     #pragma shader_feature _EMISSIVE_COLOR_MAP
     #pragma shader_feature _ENABLESPECULAROCCLUSION
+    #pragma shader_feature _DETAIL_MAP0
+    #pragma shader_feature _DETAIL_MAP1
+    #pragma shader_feature _DETAIL_MAP2
+    #pragma shader_feature _DETAIL_MAP3
-    #pragma shader_feature _DETAIL_MAP0
-    #pragma shader_feature _DETAIL_MAP1
-    #pragma shader_feature _DETAIL_MAP2
-    #pragma shader_feature _DETAIL_MAP3
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP0
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP1
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP2
+    #pragma shader_feature _SUBSURFACE_RADIUS_MAP3
+    #pragma shader_feature _THICKNESSMAP0
+    #pragma shader_feature _THICKNESSMAP1
+    #pragma shader_feature _THICKNESSMAP2
+    #pragma shader_feature _THICKNESSMAP3
+
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
     #pragma shader_feature _MAIN_LAYER_INFLUENCE_MODE
     #pragma shader_feature _INFLUENCEMASK_MAP
     #pragma shader_feature _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_MULTIPLY _BLENDMODE_PRE_MULTIPLY
     #pragma shader_feature _BLENDMODE_PRESERVE_SPECULAR_LIGHTING
     #pragma shader_feature _ENABLE_FOG_ON_TRANSPARENT
+
+    // MaterialId are used as shader feature to allow compiler to optimize properly
+    // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
+    #pragma shader_feature _ _MATID_SSS
 
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED

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

             // Material ID
             public static GUIContent materialIDText = new GUIContent("Material type", "Subsurface Scattering: enable for translucent materials such as skin, vegetation, fruit, marble, wax and milk.");
 
-            // Per pixel displacement            
+            // Per pixel displacement
             public static GUIContent ppdMinSamplesText = new GUIContent("Minimum steps", "Minimum steps (texture sample) to use with per pixel displacement mapping");
             public static GUIContent ppdMaxSamplesText = new GUIContent("Maximum steps", "Maximum steps (texture sample) to use with per pixel displacement mapping");
             public static GUIContent ppdLodThresholdText = new GUIContent("Fading mip level start", "Starting heightmap mipmap lod number where the parallax occlusion mapping effect start to disappear");
             depthOffsetEnable = FindProperty(kDepthOffsetEnable, props);
 
             // MaterialID
-            materialID = FindProperty(kMaterialID, props, false); // LayeredLit is force to be standard for now, so materialID could not exist
+            materialID = FindProperty(kMaterialID, props);
 
             displacementMode = FindProperty(kDisplacementMode, props);
             displacementLockObjectScale = FindProperty(kDisplacementLockObjectScale, props);
             ppdLodThreshold = FindProperty(kPpdLodThreshold, props);
             ppdPrimitiveLength = FindProperty(kPpdPrimitiveLength, props);
             ppdPrimitiveWidth  = FindProperty(kPpdPrimitiveWidth, props);
-            invPrimScale = FindProperty(kInvPrimScale, props);            
+            invPrimScale = FindProperty(kInvPrimScale, props);
 
             // tessellation specific, silent if not found
             tessellationMode = FindProperty(kTessellationMode, props, false);
                 EditorGUI.indentLevel--;
             }
 
-            if (materialID != null)
-                m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
+            m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
 
             m_MaterialEditor.ShaderProperty(displacementMode, StylesBaseLit.displacementModeText);
             if ((DisplacementMode)displacementMode.floatValue != DisplacementMode.None)
 
             // Set the reference value for the stencil test.
             int stencilRef = (int)StencilLightingUsage.RegularLighting;
-            if (material.HasProperty(kMaterialID))
+            if ((int)material.GetFloat(kMaterialID) == (int)Lit.MaterialId.LitSSS)
-                if ((int)material.GetFloat(kMaterialID) == (int)UnityEngine.Experimental.Rendering.HDPipeline.Lit.MaterialId.LitSSS)
-                {
-                    stencilRef = (int)StencilLightingUsage.SplitLighting;
-                }
+                stencilRef = (int)StencilLightingUsage.SplitLighting;
             }
             material.SetInt(kStencilRef, stencilRef);
 
             SetKeyword(material, "_VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && (enableVertexDisplacement || enableTessellationDisplacement));
             SetKeyword(material, "_PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && enablePixelDisplacement);
             SetKeyword(material, "_DISPLACEMENT_LOCK_TILING_SCALE", displacementLockTilingScale && enableDisplacement);
-         
+
             bool windEnabled = material.GetFloat(kWindEnabled) > 0.0f;
             SetKeyword(material, "_VERTEX_WIND", windEnabled);
 

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

         protected MaterialProperty[] heightMax = new MaterialProperty[kMaxLayerCount];
         protected const string kHeightMax = "_HeightMax";
 
+        protected MaterialProperty[] subsurfaceProfileID = new MaterialProperty[kMaxLayerCount];
+        protected const string kSubsurfaceProfileID = "_SubsurfaceProfile";
+        protected MaterialProperty[] subsurfaceRadius = new MaterialProperty[kMaxLayerCount];
+        protected const string kSubsurfaceRadius = "_SubsurfaceRadius";
+        protected MaterialProperty[] subsurfaceRadiusMap = new MaterialProperty[kMaxLayerCount];
+        protected const string kSubsurfaceRadiusMap = "_SubsurfaceRadiusMap";
+        protected MaterialProperty[] thickness = new MaterialProperty[kMaxLayerCount];
+        protected const string kThickness = "_Thickness";
+        protected MaterialProperty[] thicknessMap = new MaterialProperty[kMaxLayerCount];
+        protected const string kThicknessMap = "_ThicknessMap";
+
         protected MaterialProperty[] UVDetail = new MaterialProperty[kMaxLayerCount];
         protected const string kUVDetail = "_UVDetail";
         protected MaterialProperty[] UVDetailsMappingMask = new MaterialProperty[kMaxLayerCount];
         protected MaterialProperty anisotropyMap = null;
         protected const string kAnisotropyMap = "_AnisotropyMap";
 
-        protected MaterialProperty subsurfaceProfileID  = null;
-        protected const string     kSubsurfaceProfileID = "_SubsurfaceProfile";
-        protected MaterialProperty subsurfaceRadius     = null;
-        protected const string     kSubsurfaceRadius    = "_SubsurfaceRadius";
-        protected MaterialProperty subsurfaceRadiusMap  = null;
-        protected const string     kSubsurfaceRadiusMap = "_SubsurfaceRadiusMap";
-        protected MaterialProperty thickness            = null;
-        protected const string     kThickness           = "_Thickness";
-        protected MaterialProperty thicknessMap         = null;
-        protected const string     kThicknessMap        = "_ThicknessMap";
-
         protected MaterialProperty coatCoverage = null;
         protected const string kCoatCoverage = "_CoatCoverage";
         protected MaterialProperty coatIOR = null;
                 heightMax[i] = FindProperty(string.Format("{0}{1}", kHeightMax, m_PropertySuffixes[i]), props);
                 heightCenter[i] = FindProperty(string.Format("{0}{1}", kHeightCenter, m_PropertySuffixes[i]), props);
 
+                // Sub surface
+                subsurfaceProfileID[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceProfileID, m_PropertySuffixes[i]), props);
+                subsurfaceRadius[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceRadius, m_PropertySuffixes[i]), props);
+                subsurfaceRadiusMap[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceRadiusMap, m_PropertySuffixes[i]), props);
+                thickness[i] = FindProperty(string.Format("{0}{1}", kThickness, m_PropertySuffixes[i]), props);
+                thicknessMap[i] = FindProperty(string.Format("{0}{1}", kThicknessMap, m_PropertySuffixes[i]), props);
+
                 // Details
                 UVDetail[i] = FindProperty(string.Format("{0}{1}", kUVDetail, m_PropertySuffixes[i]), props);
                 UVDetailsMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVDetailsMappingMask, m_PropertySuffixes[i]), props);
             anisotropy = FindProperty(kAnisotropy, props);
             anisotropyMap = FindProperty(kAnisotropyMap, props);
 
-            // Sub surface
-            subsurfaceProfileID = FindProperty(kSubsurfaceProfileID, props);
-            subsurfaceRadius = FindProperty(kSubsurfaceRadius, props);
-            subsurfaceRadiusMap = FindProperty(kSubsurfaceRadiusMap, props);
-            thickness = FindProperty(kThickness, props);
-            thicknessMap = FindProperty(kThicknessMap, props);
-
             // clear coat
             coatCoverage = FindProperty(kCoatCoverage, props);
             coatIOR = FindProperty(kCoatIOR, props);
             // We reuse thickness from SSS
         }
 
-        protected void ShaderSSSInputGUI(Material material)
+        protected void ShaderSSSInputGUI(Material material, int layerIndex)
         {
             var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
             var sssSettings = hdPipeline.sssSettings;
 
             using (var scope = new EditorGUI.ChangeCheckScope())
             {
-                int profileID = (int)subsurfaceProfileID.floatValue;
+                int profileID = (int)subsurfaceProfileID[layerIndex].floatValue;
 
                 using (new EditorGUILayout.HorizontalScope())
                 {
                 }
 
                 if (scope.changed)
-                    subsurfaceProfileID.floatValue = profileID;
+                    subsurfaceProfileID[layerIndex].floatValue = profileID;
-            m_MaterialEditor.ShaderProperty(subsurfaceRadius, Styles.subsurfaceRadiusText);
-            m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceRadiusMapText, subsurfaceRadiusMap);
-            m_MaterialEditor.ShaderProperty(thickness, Styles.thicknessText);
-            m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap);
+            m_MaterialEditor.ShaderProperty(subsurfaceRadius[layerIndex], Styles.subsurfaceRadiusText);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceRadiusMapText, subsurfaceRadiusMap[layerIndex]);
+            m_MaterialEditor.ShaderProperty(thickness[layerIndex], Styles.thicknessText);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap[layerIndex]);
         }
 
         protected void ShaderClearCoatInputGUI()
 
             m_MaterialEditor.TexturePropertySingleLine(refractionEnable ? Styles.baseColorRefractionMaskText : Styles.baseColorText, baseColorMap[layerIndex], baseColor[layerIndex]);
 
-            if ( materialID == null || // Will be the case for Layered materials where we only support standard and the parameter does not exist
-                (Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitStandard || (Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitAniso)
+            if ((Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitStandard || (Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitAniso)
             {
                 m_MaterialEditor.ShaderProperty(metallic[layerIndex], Styles.metallicText);
             }
                 }
             }
 
-            m_MaterialEditor.TexturePropertySingleLine((materialID != null && (Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitSpecular) ? Styles.maskMapSpecularText : Styles.maskMapSText, maskMap[layerIndex]);
+            m_MaterialEditor.TexturePropertySingleLine(((Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitSpecular) ? Styles.maskMapSpecularText : Styles.maskMapSText, maskMap[layerIndex]);
 
             m_MaterialEditor.ShaderProperty(normalMapSpace[layerIndex], Styles.normalMapSpaceText);
 
                 heightAmplitude[layerIndex].floatValue = (heightMax[layerIndex].floatValue - heightMin[layerIndex].floatValue) * 0.01f; // Conversion centimeters to meters.
             }
 
-            if (materialID != null)
-            {
-                    ShaderSSSInputGUI(material);
+                    ShaderSSSInputGUI(material, layerIndex);
+
+                // Following mode are not supported by layered lit and will not be call by it
+                // as the MaterialId enum don't define it
                 case Lit.MaterialId.LitAniso:
                     ShaderAnisoInputGUI();
                     break;
                 default:
                     Debug.Assert(false, "Encountered an unsupported MaterialID.");
                     break;
-            }
             }
 
             EditorGUILayout.Space();
 
                         blendMode.floatValue = (float)BlendMode.Alpha;
 
-                        if (thicknessMap.textureValue == null)
-                            m_MaterialEditor.ShaderProperty(thickness, Styles.refractionThicknessText);
-                        m_MaterialEditor.TexturePropertySingleLine(Styles.refractionThicknessMapText, thicknessMap);
+                        if (thicknessMap[0].textureValue == null)
+                            m_MaterialEditor.ShaderProperty(thickness[0], Styles.refractionThicknessText);
+                        m_MaterialEditor.TexturePropertySingleLine(Styles.refractionThicknessMapText, thicknessMap[0]);
 
                         ++EditorGUI.indentLevel;
                         m_MaterialEditor.ShaderProperty(thicknessMultiplier, Styles.refractionThicknessMultiplierText);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

     // General
     float NdotV;                         // Geometric version (could be negative)
 
-    // GGX iso
-    float ggxPreLambdaV;
-
-    // GGX Aniso
+    // GGX
+    float partLambdaV;
-    float anisoGGXPreLambdaV;
 
     // Clear coat
     float coatNdotV;
 
     // In the case of IBL we want  shift a bit the normal that are not toward the viewver to reduce artifact
     float3 iblNormalWS = GetViewShiftedNormal(bsdfData.normalWS, V, preLightData.NdotV, MIN_N_DOT_V); // Use non-clamped NdotV
-    float3 iblR = reflect(-V, iblNormalWS);
+    float3 iblR;
-    // GGX iso
-    preLightData.ggxPreLambdaV = GetSmithJointGGXPreLambdaV(NdotV, bsdfData.roughness);
-
-    // For GGX aniso and IBL we have done an empirical (eye balled) approximation compare to the reference. 
-    // We use a single fetch, and we stretch the normal to use based on various criteria.
-    // result are far away from the reference but better than nothing
-    preLightData.TdotV = 0.0;
-    preLightData.BdotV = 0.0;
-        preLightData.TdotV = dot(bsdfData.tangentWS, V);
-        preLightData.BdotV = dot(bsdfData.bitangentWS, V);
-        preLightData.anisoGGXPreLambdaV = GetSmithJointGGXAnisoPreLambdaV(preLightData.TdotV, preLightData.BdotV, NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
+        preLightData.TdotV       = dot(bsdfData.tangentWS, V);
+        preLightData.BdotV       = dot(bsdfData.bitangentWS, V);
+        preLightData.partLambdaV = GetSmithJointGGXAnisoPartLambdaV(preLightData.TdotV, preLightData.BdotV, NdotV, bsdfData.roughnessT, bsdfData.roughnessB);
+
+        // For GGX aniso and IBL we have done an empirical (eye balled) approximation compare to the reference.
+        // We use a single fetch, and we stretch the normal to use based on various criteria.
+        // result are far away from the reference but better than nothing
-        float3 anisoIblNormalWS = GetAnisotropicModifiedNormal(grainDirWS, iblNormalWS, V, stretch);
-
+        float3 anisoIblNormalWS = GetAnisotropicModifiedNormal(grainDirWS, iblNormalWS, V, stretch);
+    }
+    else // GGX iso
+    {
+        preLightData.TdotV       = 0;
+        preLightData.BdotV       = 0;
+        preLightData.partLambdaV = GetSmithJointGGXPartLambdaV(NdotV, bsdfData.roughness);
+        iblR                     = reflect(-V, iblNormalWS);
     }
 
     // IBL
     }
     else
     {
-        float minRoughness, minPerceptualRoughness;
+        // Note: this is a ad-hoc tweak.
+        float iblRoughness, iblPerceptualRoughness;
-            minRoughness           = saturate(min(bsdfData.roughnessT, bsdfData.roughnessB) + roughnessBias);
-            minPerceptualRoughness = RoughnessToPerceptualRoughness(minRoughness);
+            iblRoughness           = saturate(min(bsdfData.roughnessT, bsdfData.roughnessB) + roughnessBias);
+            iblPerceptualRoughness = RoughnessToPerceptualRoughness(iblRoughness);
-            minRoughness           = bsdfData.roughness;
-            minPerceptualRoughness = bsdfData.perceptualRoughness;
+            iblRoughness           = bsdfData.roughness;
+            iblPerceptualRoughness = bsdfData.perceptualRoughness;
-        preLightData.iblDirWS    = GetSpecularDominantDir(iblNormalWS, iblR, minRoughness, NdotV);
-        preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(minPerceptualRoughness);
+        preLightData.iblDirWS    = GetSpecularDominantDir(iblNormalWS, iblR, iblRoughness, NdotV);
+        preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(iblPerceptualRoughness);
     }
 
     // Area light
                                    TdotL, BdotL, NdotL,
                                    bsdfData.roughnessT, bsdfData.roughnessB
         #ifdef LIT_USE_BSDF_PRE_LAMBDAV
-                                 , preLightData.preLambdaV);
+                                 , preLightData.partLambdaV);
         #else
                                    );
         #endif
 
         DV = DV_SmithJointGGX(NdotH, NdotL, NdotV, bsdfData.roughness
         #ifdef LIT_USE_BSDF_PRE_LAMBDAV
-                            , preLightData preLambdaV);
+                            , preLightData partLambdaV);
         #else
                               );
         #endif

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

 #define SAMPLER_MASKMAP_IDX sampler_MaskMap
 #define SAMPLER_HEIGHTMAP_IDX sampler_HeightMap
 
+#define SAMPLER_SUBSURFACE_RADIUSMAP_IDX sampler_SubsurfaceRadiusMap
+#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap
+
 // include LitDataInternal to define GetSurfaceData
 #define LAYER_INDEX 0
 #define ADD_IDX(Name) Name
 #endif
 #ifdef _DETAIL_MAP
 #define _DETAIL_MAP_IDX
+#endif
+#ifdef _SUBSURFACE_RADIUS_MAP
+#define _SUBSURFACE_RADIUS_MAP_IDX
+#endif
+#ifdef _THICKNESSMAP
+#define _THICKNESSMAP_IDX
 #endif
 #ifdef _MASKMAP
 #define _MASKMAP_IDX
 #define SAMPLER_HEIGHTMAP_IDX sampler_HeightMap3
 #endif
 
+#if defined(_SUBSURFACE_RADIUS_MAP0)
+#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap0
+#elif defined(_SUBSURFACE_RADIUS_MAP1)
+#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap1
+#elif defined(_SUBSURFACE_RADIUS_MAP2)
+#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap2
+#elif defined(_SUBSURFACE_RADIUS_MAP3)
+#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap3
+#endif
+
+#if defined(_THICKNESSMAP0)
+#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap0
+#elif defined(_THICKNESSMAP1)
+#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap1
+#elif defined(_THICKNESSMAP2)
+#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap2
+#elif defined(_THICKNESSMAP3)
+#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap3
+#endif
+
 // Define a helper macro
 
 #define ADD_ZERO_IDX(Name) Name##0
 #ifdef _DETAIL_MAP0
 #define _DETAIL_MAP_IDX
 #endif
+#ifdef _SUBSURFACE_RADIUS_MAP0
+#define _SUBSURFACE_RADIUS_MAP_IDX
+#endif
+#ifdef _THICKNESSMAP0
+#define _THICKNESSMAP_IDX
+#endif
 #ifdef _MASKMAP0
 #define _MASKMAP_IDX
 #endif
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
+#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
 
 #ifdef _DETAIL_MAP1
 #define _DETAIL_MAP_IDX
 #endif
+#ifdef _SUBSURFACE_RADIUS_MAP1
+#define _SUBSURFACE_RADIUS_MAP_IDX
+#endif
+#ifdef _THICKNESSMAP1
+#define _THICKNESSMAP_IDX
+#endif
 #ifdef _MASKMAP1
 #define _MASKMAP_IDX
 #endif
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
+#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
 
 #ifdef _DETAIL_MAP2
 #define _DETAIL_MAP_IDX
 #endif
+#ifdef _SUBSURFACE_RADIUS_MAP2
+#define _SUBSURFACE_RADIUS_MAP_IDX
+#endif
+#ifdef _THICKNESSMAP2
+#define _THICKNESSMAP_IDX
+#endif
 #ifdef _MASKMAP2
 #define _MASKMAP_IDX
 #endif
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
+#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
 
 #ifdef _DETAIL_MAP3
 #define _DETAIL_MAP_IDX
 #endif
+#ifdef _SUBSURFACE_RADIUS_MAP3
+#define _SUBSURFACE_RADIUS_MAP_IDX
+#endif
+#ifdef _THICKNESSMAP3
+#define _THICKNESSMAP_IDX
+#endif
 #ifdef _MASKMAP3
 #define _MASKMAP_IDX
 #endif
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
+#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
 
     return result;
 }
 
+// In the case of subsurface profile index, the goal is to take the index with the hights weights.
+// Or the last found in case of equality.
+float BlendLayeredSSSprofile(float x0, float x1, float x2, float x3, float weight[4])
+{
+    int sssProfileIndex = x0;
+    float currentMax = weight[0];
+
+    sssProfileIndex = currentMax < weight[1] ? x1 : sssProfileIndex;
+    currentMax = max(currentMax, weight[1]);
+
+#if _LAYER_COUNT >= 3
+    sssProfileIndex = currentMax < weight[2] ? x2 : sssProfileIndex;
+    currentMax = max(currentMax, weight[2]);
+#endif
+#if _LAYER_COUNT >= 4
+    sssProfileIndex = currentMax < weight[3] ? x3 : sssProfileIndex;
+#endif
+
+    return sssProfileIndex;
+}
+
+#define SURFACEDATA_BLEND_SSS_PROFILE(surfaceData, name, mask) BlendLayeredSSSprofile(MERGE_NAME(surfaceData, 0) MERGE_NAME(., name), MERGE_NAME(surfaceData, 1) MERGE_NAME(., name), MERGE_NAME(surfaceData, 2) MERGE_NAME(., name), MERGE_NAME(surfaceData, 3) MERGE_NAME(., name), mask);
 #define PROP_BLEND_SCALAR(name, mask) BlendLayeredScalar(name##0, name##1, name##2, name##3, mask);
 
 void GetLayerTexCoord(float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3,
     surfaceData.ambientOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, ambientOcclusion, weights);
     surfaceData.metallic = SURFACEDATA_BLEND_SCALAR(surfaceData, metallic, weights);
     surfaceData.tangentWS = normalize(input.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. Tag: SURFACE_GRADIENT
+    surfaceData.subsurfaceRadius = SURFACEDATA_BLEND_SCALAR(surfaceData, subsurfaceRadius, weights);
+    surfaceData.thickness = SURFACEDATA_BLEND_SCALAR(surfaceData, thickness, weights);
+    surfaceData.subsurfaceProfile = SURFACEDATA_BLEND_SSS_PROFILE(surfaceData, subsurfaceProfile, weights);
+
+    // Layered shader support either SSS or standard (can't mix them)
+#ifdef _MATID_SSS
+    surfaceData.materialId = MATERIALID_LIT_SSS;
+#else // Default
+    surfaceData.materialId = MATERIALID_LIT_STANDARD;
+#endif
+
-    surfaceData.materialId = 1; // MaterialId.LitStandard
-    surfaceData.subsurfaceRadius = 1.0;
-    surfaceData.thickness = 0.0;
-    surfaceData.subsurfaceProfile = 0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
     surfaceData.coatNormalWS = float3(0.0, 0.0, 0.0);
     surfaceData.coatCoverage = 0.0f;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

 #endif
     surfaceData.metallic *= ADD_IDX(_Metallic);
 
+    surfaceData.subsurfaceProfile = ADD_IDX(_SubsurfaceProfile);
+    surfaceData.subsurfaceRadius = ADD_IDX(_SubsurfaceRadius);
+    surfaceData.thickness = ADD_IDX(_Thickness);
+
+#ifdef _SUBSURFACE_RADIUS_MAP_IDX
+    surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_SubsurfaceRadiusMap), SAMPLER_SUBSURFACE_RADIUSMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
+#endif
+
+#ifdef _THICKNESSMAP_IDX
+    surfaceData.thickness *= SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_ThicknessMap), SAMPLER_THICKNESSMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
+#endif
+
     // This part of the code is not used in case of layered shader but we keep the same macro system for simplicity
 #if !defined(LAYERED_LIT_SHADER)
 
 #endif
     surfaceData.anisotropy *= ADD_IDX(_Anisotropy);
 
-    surfaceData.subsurfaceProfile = _SubsurfaceProfile;
-    surfaceData.subsurfaceRadius  = _SubsurfaceRadius;
-    surfaceData.thickness         = _Thickness;
-
-#ifdef _SUBSURFACE_RADIUS_MAP
-    surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(_SubsurfaceRadiusMap, sampler_SubsurfaceRadiusMap, layerTexCoord.base).r;
-#endif
-
-#ifdef _THICKNESSMAP
-    surfaceData.thickness *= SAMPLE_UVMAPPING_TEXTURE2D(_ThicknessMap, sampler_ThicknessMap, layerTexCoord.base).r;
-#endif
-
     surfaceData.specularColor = _SpecularColor.rgb;
 #ifdef _SPECULARCOLORMAP
     surfaceData.specularColor *= SAMPLE_UVMAPPING_TEXTURE2D(_SpecularColorMap, sampler_SpecularColorMap, layerTexCoord.base).rgb;
     // Note: any parameters set here must also be set in GetSurfaceAndBuiltinData() layer version
     surfaceData.tangentWS = float3(0.0, 0.0, 0.0);
     surfaceData.anisotropy = 0.0;
-    surfaceData.subsurfaceRadius = 0.0;
-    surfaceData.thickness = 0.0;
-    surfaceData.subsurfaceProfile = 0;
     surfaceData.specularColor = float3(0.0, 0.0, 0.0);
     surfaceData.coatNormalWS = float3(0.0, 0.0, 0.0);
     surfaceData.coatCoverage = 0.0f;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 PROP_DECL_TEX2D(_BentNormalMap);
 PROP_DECL_TEX2D(_NormalMap);
 PROP_DECL_TEX2D(_NormalMapOS);
+PROP_DECL_TEX2D(_DetailMap);
-PROP_DECL_TEX2D(_DetailMap);
+
+PROP_DECL_TEX2D(_SubsurfaceRadiusMap);
+PROP_DECL_TEX2D(_ThicknessMap);
 
 TEXTURE2D(_LayerMaskMap);
 SAMPLER2D(sampler_LayerMaskMap);
 
 PROP_DECL(float, _HeightAmplitude);
 PROP_DECL(float, _HeightCenter);
+
+PROP_DECL(int, _SubsurfaceProfile);
+PROP_DECL(float, _SubsurfaceRadius);
+PROP_DECL(float, _Thickness);
 
 PROP_DECL(float, _OpacityAsDensity);
 float _InheritBaseNormal1;

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

             EditorGUI.indentLevel++;
 
             SurfaceTypePopup();
-            if (blendMode != null && showBlendModePopup)
-                BlendModePopup();
+            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+            {
+                if (blendMode != null && showBlendModePopup)
+                    BlendModePopup();
-            EditorGUI.indentLevel++;
-            if (enableBlendModePreserveSpecularLighting != null && blendMode != null && showBlendModePopup)
-                m_MaterialEditor.ShaderProperty(enableBlendModePreserveSpecularLighting, StylesBaseUnlit.enableBlendModePreserveSpecularLightingText);
-            if (enableFogOnTransparent != null)
-                m_MaterialEditor.ShaderProperty(enableFogOnTransparent, StylesBaseUnlit.enableTransparentFogText);
-            if (preRefractionPass != null)
-                m_MaterialEditor.ShaderProperty(preRefractionPass, StylesBaseUnlit.transparentPrePassText);
-            EditorGUI.indentLevel--;
+                EditorGUI.indentLevel++;
+                if (enableBlendModePreserveSpecularLighting != null && blendMode != null && showBlendModePopup)
+                    m_MaterialEditor.ShaderProperty(enableBlendModePreserveSpecularLighting, StylesBaseUnlit.enableBlendModePreserveSpecularLightingText);
+                if (enableFogOnTransparent != null)
+                    m_MaterialEditor.ShaderProperty(enableFogOnTransparent, StylesBaseUnlit.enableTransparentFogText);
+                if (preRefractionPass != null)
+                    m_MaterialEditor.ShaderProperty(preRefractionPass, StylesBaseUnlit.transparentPrePassText);
+                EditorGUI.indentLevel--;
+            }
 
             if (alphaCutoffEnable != null)
                 m_MaterialEditor.ShaderProperty(alphaCutoffEnable, StylesBaseUnlit.alphaCutoffEnableText);

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Assets/CommonAssets/HDRP_Test_Camera.prefab

   m_Script: {fileID: 11500000, guid: c20dfc007a9a74ad8a2bfd0d59abe398, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  renderPipeline: {fileID: 11400000, guid: c6b8fc12516a4434f9ec8ea872147e68, type: 2}
+  renderPipeline: {fileID: 11400000, guid: 449281dd2b4fbee49b8397de0541ea3c, type: 2}
   cameraToUse: {fileID: 20109210616973140}
   hdr: 1
   msaaSamples: 1