Merge pull request #759 from Unity-Technologies/Decouple-SSS-and-transmission-option

Decouple SSS and Transmission option

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineInspector.Styles.cs

 
             public readonly GUIContent supportDBuffer = new GUIContent("Support Decal buffer");
             public readonly GUIContent supportMSAA = new GUIContent("Support MSAA");
+            public readonly GUIContent supportSubsurfaceScattering = new GUIContent("Support SubsurfaceScattering");
+
             // Shadow Settings
             public readonly GUIContent shadowSettings = new GUIContent("Shadow Settings");
             public readonly GUIContent shadowsAtlasWidth = new GUIContent("Atlas Width");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineInspector.cs

         // Global Render settings
         SerializedProperty m_supportDBuffer;
         SerializedProperty m_supportMSAA;
+        SerializedProperty m_supportSubsurfaceScattering;
         // Global Shadow settings
         SerializedProperty m_ShadowAtlasWidth;
         SerializedProperty m_ShadowAtlasHeight;
             // Global Render settings
             m_supportDBuffer = properties.Find(x => x.renderPipelineSettings.supportDBuffer);
             m_supportMSAA = properties.Find(x => x.renderPipelineSettings.supportMSAA);
+            m_supportSubsurfaceScattering = properties.Find(x => x.renderPipelineSettings.supportSubsurfaceScattering);
+
             // Global Shadow settings
             m_ShadowAtlasWidth = properties.Find(x => x.renderPipelineSettings.shadowInitParams.shadowAtlasWidth);
             m_ShadowAtlasHeight = properties.Find(x => x.renderPipelineSettings.shadowInitParams.shadowAtlasHeight);
             EditorGUI.indentLevel++;
             EditorGUILayout.PropertyField(m_supportDBuffer, s_Styles.supportDBuffer);
             EditorGUILayout.PropertyField(m_supportMSAA, s_Styles.supportMSAA);
+            EditorGUILayout.PropertyField(m_supportSubsurfaceScattering, s_Styles.supportSubsurfaceScattering);
+
             EditorGUI.indentLevel--;
         }
 

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 SubsurfaceScattering"));
+            EditorGUILayout.PropertyField(p.enableTransmission, _.GetContent("Enable Transmission"));
             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 enableTransmission;
 
         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);
+            enableTransmission = root.Find((FrameSettings d) => d.enableTransmission);
             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 _TransmittanceMultiplier = Shader.PropertyToID("_TransmittanceMultiplier");
         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.hlsl

 #define ENVMAP_FEATURE_INFLUENCENORMAL
 #define ENVMAP_FEATURE_PERFACEFADE
 
-//-----------------------------------------------------------------------------
-// SurfaceData and BSDFData
-//-----------------------------------------------------------------------------
-
-// Define refraction keyword helpers
-#define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE))
-#if HAS_REFRACTION
-# include "CoreRP/ShaderLibrary/Refraction.hlsl"
-
-# if defined(_REFRACTION_PLANE)
-#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelPlane(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
-# elif defined(_REFRACTION_SPHERE)
-#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelSphere(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
-# endif
-#endif
-
-#define GBufferType0 float4
-#define GBufferType1 float4
-#define GBufferType2 float4
-#define GBufferType3 float4
+//-----------------------------------------------------------------------------
+// Texture and constant buffer declaration
+//-----------------------------------------------------------------------------
 
 // GBuffer texture declaration
 TEXTURE2D(_GBufferTexture0);
-
-// Reference Lambert diffuse / GGX Specular for IBL and area lights
-#ifdef HAS_LIGHTLOOP // Both reference define below need to be define only if LightLoop is present, else we get a compile error
-// #define LIT_DISPLAY_REFERENCE_AREA
-// #define LIT_DISPLAY_REFERENCE_IBL
-#endif
-// Use Lambert diffuse instead of Disney diffuse
-// #define LIT_DIFFUSE_LAMBERT_BRDF
-#define LIT_USE_GGX_ENERGY_COMPENSATION
 
 // Rough refraction texture
 // Color pyramid (width, height, lodcount, Unused)
 #define LTC_LUT_SCALE  ((LTC_LUT_SIZE - 1) * rcp(LTC_LUT_SIZE))
 #define LTC_LUT_OFFSET (0.5 * rcp(LTC_LUT_SIZE))
 
-// Constant value for clear coat
+//-----------------------------------------------------------------------------
+// Definition
+//-----------------------------------------------------------------------------
+
+#define GBufferType0 float4
+#define GBufferType1 float4
+#define GBufferType2 float4
+#define GBufferType3 float4
+
+#define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE))
+
+#define DEFAULT_SPECULAR_VALUE 0.04
+
+#define GBUFFER_LIT_SPECULAR_COLOR 15
+#define GBUFFER_LIT_SSS_OR_TRANSMISSION 14
+#define GBUFFER_LIT_IRIDESCENCE 13
+
 #define CLEAR_COAT_IOR 1.5
 #define CLEAR_COAT_IETA (1.0 / CLEAR_COAT_IOR)
 #define CLEAR_COAT_F0 0.04 // IORToFresnel0(CLEAR_COAT_IOR)
 //-----------------------------------------------------------------------------
-// Helper for cheap screen space raycasting
+// Configuration
-float3 EstimateRaycast(float3 V, PositionInputs posInputs, float3 positionWS, float3 rayWS)
-{
-    // For all refraction approximation, to calculate the refracted point in world space,
-    //   we approximate the scene as a plane (back plane) with normal -V at the depth hit point.
-    //   (We avoid to raymarch the depth texture to get the refracted point.)
-
-    uint2 depthSize = uint2(_PyramidDepthMipSize.xy);
-
-    // Get the depth of the approximated back plane
-    float pyramidDepth = LOAD_TEXTURE2D_LOD(_PyramidDepthTexture, posInputs.positionNDC * (depthSize >> 2), 2).r;
-    float depth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
-
-    // Distance from point to the back plane
-    float depthFromPositionInput = depth - posInputs.linearDepth;
-
-    float offset = dot(-V, positionWS - posInputs.positionWS);
-    float depthFromPosition = depthFromPositionInput - offset;
-
-    float hitDistanceFromPosition = depthFromPosition / dot(-V, rayWS);
+// Choose between Lambert diffuse and Disney diffuse (enable only one of them)
+// #define LIT_DIFFUSE_LAMBERT_BRDF
+#define LIT_USE_GGX_ENERGY_COMPENSATION
-    return positionWS + rayWS * hitDistanceFromPosition;
-}
+// Enable reference mode for IBL and area lights
+// Both reference define below can be define only if LightLoop is present, else we get a compile error
+#ifdef HAS_LIGHTLOOP
+// #define LIT_DISPLAY_REFERENCE_AREA
+// #define LIT_DISPLAY_REFERENCE_IBL
+#endif
 
 //-----------------------------------------------------------------------------
 // Ligth and material classification for the deferred rendering path
 // Helper functions/variable specific to this material
 //-----------------------------------------------------------------------------
 
+#if HAS_REFRACTION
+# include "CoreRP/ShaderLibrary/Refraction.hlsl"
+
+# if defined(_REFRACTION_PLANE)
+#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelPlane(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
+# elif defined(_REFRACTION_SPHERE)
+#  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelSphere(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
+# endif
+#endif
+
+float3 EstimateRaycast(float3 V, PositionInputs posInputs, float3 positionWS, float3 rayWS)
+{
+    // For all refraction approximation, to calculate the refracted point in world space,
+    //   we approximate the scene as a plane (back plane) with normal -V at the depth hit point.
+    //   (We avoid to raymarch the depth texture to get the refracted point.)
+
+    uint2 depthSize = uint2(_PyramidDepthMipSize.xy);
+
+    // Get the depth of the approximated back plane
+    float pyramidDepth = LOAD_TEXTURE2D_LOD(_PyramidDepthTexture, posInputs.positionNDC * (depthSize >> 2), 2).r;
+    float depth = LinearEyeDepth(pyramidDepth, _ZBufferParams);
+
+    // Distance from point to the back plane
+    float depthFromPositionInput = depth - posInputs.linearDepth;
+
+    float offset = dot(-V, positionWS - posInputs.positionWS);
+    float depthFromPosition = depthFromPositionInput - offset;
+
+    float hitDistanceFromPosition = depthFromPosition / dot(-V, rayWS);
+
+    return positionWS + rayWS * hitDistanceFromPosition;
+}
+
 float PackMaterialId(int materialId)
 {
     return float(materialId) / 3.0;
 }
 
 // Fills the data which may be accessed if MATERIALFEATUREFLAGS_LIT_SSS is set.
-void FillMaterialIdSssData(int diffusionProfile, float radius, float thickness, uint transmissionMode,
-                           inout BSDFData bsdfData)
+void FillMaterialIdSssData(int diffusionProfile, float subsurfaceMask, float thickness, uint transmissionMode, inout BSDFData bsdfData)
-    bsdfData.diffusionProfile  = diffusionProfile;
-    bsdfData.subsurfaceMask   = radius;
-    bsdfData.enableTransmission = _EnableSSSAndTransmission != 0;
+    bsdfData.diffusionProfile = diffusionProfile;
+    bsdfData.subsurfaceMask = subsurfaceMask;
+    bsdfData.enableTransmission = (transmissionMode != TRANSMISSION_MODE_NONE);
-    if (bsdfData.enableTransmission && transmissionMode != TRANSMISSION_MODE_NONE)
+    if (bsdfData.enableTransmission)
-            bsdfData.transmittance = ComputeTransmittanceDisney(_ShapeParams[diffusionProfile].rgb,
-                                                                _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
-                                                                bsdfData.thickness, bsdfData.subsurfaceMask);
+        bsdfData.transmittance = _TransmittanceMultiplier * ComputeTransmittanceDisney( _ShapeParams[diffusionProfile].rgb,
+                                                                                        _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
+                                                                                        bsdfData.thickness, 1.0);
-            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 = _TransmittanceMultiplier * ComputeTransmittanceJimenez( _HalfRcpVariancesAndWeights[diffusionProfile][0].rgb,
+                                                                                            _HalfRcpVariancesAndWeights[diffusionProfile][0].a,
+                                                                                            _HalfRcpVariancesAndWeights[diffusionProfile][1].rgb,
+                                                                                            _HalfRcpVariancesAndWeights[diffusionProfile][1].a,
+                                                                                            _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
+                                                                                            bsdfData.thickness, 1.0);
 #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  _TransmittanceMultiplier;    // Allow to switch on/off the transmittance but doesn't save the cost
 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);
+            cmd.SetGlobalFloat(HDShaderIDs._TransmittanceMultiplier, frameSettings.enableTransmission ? 1.0f : 0.0f);
             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 static string kEnableShadow = "Enable Shadow";
         public static string kEnableSSR = "Enable SSR";
         public static string kEnableSSAO = "Enable SSAO";
-        public static string kEnableSSSAndTransmission = "Enable SSS and Transmission";
+        public static string kEnableSubsurfaceScattering = "Enable SubsurfaceScattering";
+        public static string kEnableTransmission = "Enable Transmission";
 
         public static string kForwardOnly = "Forward Only";
         public static string kDeferredDepthPrepass = "Deferred Depth Prepass";
         public bool enableShadow = true;
         public bool enableSSR = true; // Depends on DepthPyramid
         public bool enableSSAO = true;
-        public bool enableSSSAndTransmission = true;
+        public bool enableSubsurfaceScattering = true;
+        public bool enableTransmission = true;  // Caution: this is only for debug, it doesn't save the cost of Transmission execution
 
         // 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.enableTransmission = this.enableTransmission;
 
             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.supportSubsurfaceScattering;
+            aggregate.enableTransmission = frameSettings.enableTransmission;
 
             // 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, kEnableSubsurfaceScattering, () => frameSettings.enableSubsurfaceScattering, (value) => frameSettings.enableSubsurfaceScattering = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableTransmission, () => frameSettings.enableTransmission, (value) => frameSettings.enableTransmission = (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);
             DebugMenuManager.instance.RemoveDebugItem(menuName, kEnableShadow);
             DebugMenuManager.instance.RemoveDebugItem(menuName, kEnableSSR);
             DebugMenuManager.instance.RemoveDebugItem(menuName, kEnableSSAO);
-            DebugMenuManager.instance.RemoveDebugItem(menuName, kEnableSSSAndTransmission);
+            DebugMenuManager.instance.RemoveDebugItem(menuName, kEnableSubsurfaceScattering);
+            DebugMenuManager.instance.RemoveDebugItem(menuName, kEnableTransmission);
 
             DebugMenuManager.instance.RemoveDebugItem(menuName, kForwardOnly);
             DebugMenuManager.instance.RemoveDebugItem(menuName, kDeferredDepthPrepassATestOnly);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/RenderPipelineSettings.cs

         public bool supportShadowMask = true;
         public bool supportSSR = true;
         public bool supportSSAO = true;
-        public bool supportSSSAndTransmission = true;
+        public bool supportSubsurfaceScattering = true;
 
         // Engine
         public bool supportDBuffer = false;

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);