More draft

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/FrameSettingsUI.cs

         {
             EditorGUILayout.PropertyField(p.enableSSR, _.GetContent("Enable SSR"));
             EditorGUILayout.PropertyField(p.enableSSAO, _.GetContent("Enable SSAO"));
-            EditorGUILayout.PropertyField(p.enableSSSAndTransmission, _.GetContent("Enable SSS And Transmission"));
+            EditorGUILayout.PropertyField(p.enableSubsurfaceScattering, _.GetContent("Enable Subsurface Scattering"));
             EditorGUILayout.PropertyField(p.enableShadow, _.GetContent("Enable Shadow"));
             EditorGUILayout.PropertyField(p.enableShadowMask, _.GetContent("Enable Shadow Masks"));
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedFrameSettings.cs

         public SerializedProperty enableShadow;
         public SerializedProperty enableSSR;
         public SerializedProperty enableSSAO;
-        public SerializedProperty enableSSSAndTransmission;
+        public SerializedProperty enableSubsurfaceScattering;
 
         public SerializedProperty diffuseGlobalDimmer;
         public SerializedProperty specularGlobalDimmer;
             enableShadow = root.Find((FrameSettings d) => d.enableShadow);
             enableSSR = root.Find((FrameSettings d) => d.enableSSR);
             enableSSAO = root.Find((FrameSettings d) => d.enableSSAO);
-            enableSSSAndTransmission = root.Find((FrameSettings d) => d.enableSSSAndTransmission);
+            enableSubsurfaceScattering = root.Find((FrameSettings d) => d.enableSubsurfaceScattering);
             diffuseGlobalDimmer = root.Find((FrameSettings d) => d.diffuseGlobalDimmer);
             specularGlobalDimmer = root.Find((FrameSettings d) => d.specularGlobalDimmer);
             enableForwardRenderingOnly = root.Find((FrameSettings d) => d.enableForwardRenderingOnly);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 
             var options = new LightLoop.LightingPassOptions();
 
-            if (m_FrameSettings.enableSSSAndTransmission)
+            if (m_FrameSettings.enableSubsurfaceScattering)
             {
                 // Output split lighting for materials asking for it (masked in the stencil buffer)
                 options.outputSplitLighting = true;
                 if (pass == ForwardPass.Opaque)
                 {
                     // In case of forward SSS we will bind all the required target. It is up to the shader to write into it or not.
-                    if (m_FrameSettings.enableSSSAndTransmission)
+                    if (m_FrameSettings.enableSubsurfaceScattering)
                     {
                         RenderTargetIdentifier[] m_MRTWithSSS = new RenderTargetIdentifier[2 + m_SSSBufferManager.sssBufferCount];
                         m_MRTWithSSS[0] = m_CameraColorBufferRT; // Store the specular color

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _SkyTexture = Shader.PropertyToID("_SkyTexture");
         public static readonly int _SkyTextureMipCount = Shader.PropertyToID("_SkyTextureMipCount");
 
-        public static readonly int _EnableSSSAndTransmission = Shader.PropertyToID("_EnableSSSAndTransmission");
+        public static readonly int _EnableSubsurfaceScattering = Shader.PropertyToID("_EnableSubsurfaceScattering");
         public static readonly int _TexturingModeFlags = Shader.PropertyToID("_TexturingModeFlags");
         public static readonly int _TransmissionFlags = Shader.PropertyToID("_TransmissionFlags");
         public static readonly int _ThicknessRemaps = Shader.PropertyToID("_ThicknessRemaps");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Deferred.shader

                 Outputs outputs;
 
             #ifdef OUTPUT_SPLIT_LIGHTING
-                if (_EnableSSSAndTransmission != 0 && HaveSubsurfaceScattering(bsdfData))
+                if (_EnableSubsurfaceScattering != 0 && HaveSubsurfaceScattering(bsdfData))
                 {
                     outputs.specularLighting = float4(specularLighting, 1.0);
                     outputs.diffuseLighting  = TagLightingForSSS(diffuseLighting);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Deferred.compute

     float3 specularLighting;
     LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, featureFlags, diffuseLighting, specularLighting);
 
-    if (_EnableSSSAndTransmission != 0 && HaveSubsurfaceScattering(bsdfData))
+    if (_EnableSubsurfaceScattering != 0 && HaveSubsurfaceScattering(bsdfData))
     {
         specularLightingUAV[pixelCoord] = float4(specularLighting, 1.0);
         diffuseLightingUAV[pixelCoord]  = TagLightingForSSS(diffuseLighting);

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

                     {
                         // If SSS is disable, do lighting for both split lighting and no split lighting
                         // This is for debug purpose, so fine to use immediate material mode here to modify render state
-                        if (!m_FrameSettings.enableSSSAndTransmission)
+                        if (!m_FrameSettings.enableSubsurfaceScattering)
                         {
                             currentLightingMaterial.SetInt(HDShaderIDs._StencilRef, (int)StencilLightingUsage.NoLighting);
                             currentLightingMaterial.SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.NotEqual);

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

             // + Diffusion Profile
             [SurfaceDataAttributes("Thickness")]
             public float thickness;
-            [SurfaceDataAttributes("Specular SSS")]
-            public float specularSSS;
-            // Aniso
+            // Anisotropic
             [SurfaceDataAttributes("Tangent", true)]
             public Vector3 tangentWS;
             [SurfaceDataAttributes("Anisotropy")]
             public float subsurfaceMask;
 
             // Transmission
-            // Transmission
-            // Aniso
+            // Anisotropic
             [SurfaceDataAttributes("", true)]
             public Vector3 tangentWS;
             [SurfaceDataAttributes("", true)]

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

     return lerp(dielectricF0.xxx, baseColor, metallic);
 }
 
-// Fills the data which may be accessed if MATERIALFEATUREFLAGS_LIT_SSS is set.
-void FillMaterialFeatureTransmission(int diffusionProfile, float radius, float thickness, uint transmissionMode, inout BSDFData bsdfData)
+void FillMaterialDiffusionProfile(int diffusionProfile, inout BSDFData bsdfData)
+{
+    bsdfData.diffusionProfile = diffusionProfile;
+}
+
+void FillMaterialSSS(float subsurfaceMask, inout BSDFData bsdfData)
+{
+    bsdfData.fresnel0 = _TransmissionTintsAndFresnel0[bsdfData.diffusionProfile].a;
+    bsdfData.subsurfaceMask = subsurfaceMask;
+    // Note: ApplySubsurfaceScatteringTexturingMode also test the diffusionProfile for updating diffuseColor based on SSS
+}
+
+void FillMaterialTransmission(int diffusionProfile, , float thickness, uint transmissionMode, inout BSDFData bsdfData)
-    bsdfData.diffusionProfile  = diffusionProfile;
-    bsdfData.subsurfaceMask   = radius;
-    bsdfData.enableTransmission = _EnableSSSAndTransmission != 0;
+    bsdfData.enableTransmission = _EnableTransmission != 0;
 
     if (bsdfData.enableTransmission && transmissionMode != TRANSMISSION_MODE_NONE)
     {
 #if SHADEROPTIONS_USE_DISNEY_SSS
-            bsdfData.transmittance = ComputeTransmittanceDisney(_ShapeParams[diffusionProfile].rgb,
-                                                                _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
-                                                                bsdfData.thickness, bsdfData.subsurfaceMask);
+            bsdfData.transmittance = _EnableTransmission * ComputeTransmittanceDisney(  _ShapeParams[diffusionProfile].rgb,
+                                                                                        _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
+                                                                                        bsdfData.thickness, bsdfData.subsurfaceMask);
-            bsdfData.transmittance = ComputeTransmittanceJimenez(_HalfRcpVariancesAndWeights[diffusionProfile][0].rgb,
-                                                                 _HalfRcpVariancesAndWeights[diffusionProfile][0].a,
-                                                                 _HalfRcpVariancesAndWeights[diffusionProfile][1].rgb,
-                                                                 _HalfRcpVariancesAndWeights[diffusionProfile][1].a,
-                                                                 _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
-                                                                 bsdfData.thickness, bsdfData.subsurfaceMask);
+            bsdfData.transmittance = _EnableTransmission * ComputeTransmittanceJimenez( _HalfRcpVariancesAndWeights[diffusionProfile][0].rgb,
+                                                                                        _HalfRcpVariancesAndWeights[diffusionProfile][0].a,
+                                                                                        _HalfRcpVariancesAndWeights[diffusionProfile][1].rgb,
+                                                                                        _HalfRcpVariancesAndWeights[diffusionProfile][1].a,
+                                                                                        _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
+                                                                                        bsdfData.thickness, bsdfData.subsurfaceMask);
 #endif
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.hlsl

 CBUFFER_START(UnitySSSAndTransmissionParameters)
 // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
 // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
-uint   _EnableSSSAndTransmission; // Globally toggles subsurface and transmission scattering on/off
+uint   _EnableSubsurfaceScattering; // Globally toggles subsurface and transmission scattering on/off
 float  _TexturingModeFlags;       // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
 float  _TransmissionFlags;        // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
 // Old SSS Model >>>
 {
 #if defined(SHADERPASS) && (SHADERPASS == SHADERPASS_SUBSURFACE_SCATTERING)
     // If the SSS pass is executed, we know we have SSS enabled.
-    bool enableSssAndTransmission = true;
+    bool enableSss = true;
-    bool enableSssAndTransmission = _EnableSSSAndTransmission != 0;
+    bool enableSss = _EnableSubsurfaceScattering != 0;
-    if (enableSssAndTransmission)
+    if (enableSss)
     {
         bool performPostScatterTexturing = IsBitSet(asuint(_TexturingModeFlags), diffusionProfile);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScatteringManager.cs

         public void PushGlobalParams(CommandBuffer cmd, DiffusionProfileSettings sssParameters, FrameSettings frameSettings)
         {
             // Broadcast SSS parameters to all shaders.
-            cmd.SetGlobalInt(HDShaderIDs._EnableSSSAndTransmission, frameSettings.enableSSSAndTransmission ? 1 : 0);
+            cmd.SetGlobalInt(HDShaderIDs._EnableSubsurfaceScattering, frameSettings.enableSubsurfaceScattering ? 1 : 0);
             unsafe
             {
                 // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
         public void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, DiffusionProfileSettings sssParameters, FrameSettings frameSettings,
                                             RenderTargetIdentifier colorBufferRT, RenderTargetIdentifier diffuseBufferRT, RenderTargetIdentifier depthStencilBufferRT, RenderTargetIdentifier depthTextureRT)
         {
-            if (sssParameters == null || !frameSettings.enableSSSAndTransmission)
+            if (sssParameters == null || !frameSettings.enableSubsurfaceScattering)
                 return;
 
             using (new ProfilingSample(cmd, "Subsurface Scattering", HDRenderPipeline.GetSampler(CustomSamplerId.SubsurfaceScattering)))

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

         public bool enableShadow = true;
         public bool enableSSR = true; // Depends on DepthPyramid
         public bool enableSSAO = true;
-        public bool enableSSSAndTransmission = true;
+        public bool enableSubsurfaceScattering = true;
 
         // Setup by system
         public float diffuseGlobalDimmer = 1.0f;
             frameSettings.enableShadow = this.enableShadow;
             frameSettings.enableSSR = this.enableSSR;
             frameSettings.enableSSAO = this.enableSSAO;
-            frameSettings.enableSSSAndTransmission = this.enableSSSAndTransmission;
+            frameSettings.enableSubsurfaceScattering = this.enableSubsurfaceScattering;
 
             frameSettings.diffuseGlobalDimmer = this.diffuseGlobalDimmer;
             frameSettings.specularGlobalDimmer = this.specularGlobalDimmer;
             aggregate.enableShadow = frameSettings.enableShadow;
             aggregate.enableSSR = camera.cameraType == CameraType.Reflection ? false : frameSettings.enableSSR && renderPipelineSettings.supportSSR;
             aggregate.enableSSAO = frameSettings.enableSSAO && renderPipelineSettings.supportSSAO;
-            aggregate.enableSSSAndTransmission = camera.cameraType == CameraType.Reflection ? false : frameSettings.enableSSSAndTransmission && renderPipelineSettings.supportSSSAndTransmission;
+            aggregate.enableSubsurfaceScattering = camera.cameraType == CameraType.Reflection ? false : frameSettings.enableSubsurfaceScattering && renderPipelineSettings.supportSSSAndTransmission;
 
             // We have to fall back to forward-only rendering when scene view is using wireframe rendering mode
             // as rendering everything in wireframe + deferred do not play well together
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableShadow, () => frameSettings.enableShadow, (value) => frameSettings.enableShadow = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableSSR, () => frameSettings.enableSSR, (value) => frameSettings.enableSSR = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableSSAO, () => frameSettings.enableSSAO, (value) => frameSettings.enableSSAO = (bool)value);
-            DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableSSSAndTransmission, () => frameSettings.enableSSSAndTransmission, (value) => frameSettings.enableSSSAndTransmission = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableSSSAndTransmission, () => frameSettings.enableSubsurfaceScattering, (value) => frameSettings.enableSubsurfaceScattering = (bool)value);
 
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kForwardOnly, () => frameSettings.enableForwardRenderingOnly, (value) => frameSettings.enableForwardRenderingOnly = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kDeferredDepthPrepass, () => frameSettings.enableDepthPrepassWithDeferredRendering, (value) => frameSettings.enableDepthPrepassWithDeferredRendering = (bool)value);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassForward.hlsl

         LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, featureFlags, diffuseLighting, specularLighting);
 
 #ifdef OUTPUT_SPLIT_LIGHTING
-        if (_EnableSSSAndTransmission != 0 && HaveSubsurfaceScattering(bsdfData))
+        if (_EnableSubsurfaceScattering != 0 && HaveSubsurfaceScattering(bsdfData))
         {
             outColor = float4(specularLighting, 1.0);
             outDiffuseLighting = float4(TagLightingForSSS(diffuseLighting), 1.0);