Revert back to wrapped diffuse for the transmission angular dependency

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             Shader.SetGlobalInt(     "_TransmissionFlags",  (int)sssParameters.transmissionFlags);
             cmd.SetGlobalFloatArray( "_ThicknessRemaps",         sssParameters.thicknessRemaps);
             cmd.SetGlobalVectorArray("_ShapeParameters",         sssParameters.shapeParameters);
-            cmd.SetGlobalVectorArray("_SurfaceAlbedos",          sssParameters.surfaceAlbedos);
+            cmd.SetGlobalVectorArray("_VolumeAlbedos",           sssParameters.volumeAlbedos);
 
             renderContext.ExecuteCommandBuffer(cmd);
             cmd.Dispose();

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

     float3 positionWS = posInput.positionWS;
 
     float3 L = -lightData.forward; // Lights are pointing backward in Unity
-    float illuminance = saturate(dot(bsdfData.normalWS, L));
+    float NdotL = dot(bsdfData.normalWS, L);
+    float illuminance = saturate(NdotL);
 
     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
 
     [branch] if (bsdfData.enableTransmission)
     {
-        float LdotV = dot(L, V); // Also computed in BSDF()
-        // Compute the normal at the back of the object as R = reflect(N, -V)
-        // float RdotL = NdotL - 2 * preLightData.NdotV * LdotV;
-        float illuminance = saturate(-LdotV);
+        // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
+        // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+        const float w = 0.3;
+        illuminance = saturate((-NdotL + w) / ((1.0 + w) * (1.0 + w)));
 
         // For low thickness, we can reuse the shadowing status for the back of the object.
         shadow       = bsdfData.useThinObjectMode ? shadow : 1;
     float attenuation = GetDistanceAttenuation(unL, lightData.invSqrAttenuationRadius);
     // Reminder: lights are ortiented backward (-Z)
     attenuation *= GetAngleAttenuation(L, -lightData.forward, lightData.angleScale, lightData.angleOffset);
-    float illuminance = saturate(dot(bsdfData.normalWS, L)) * attenuation;
+    float NdotL = dot(bsdfData.normalWS, L);
+    float illuminance = saturate(NdotL * attenuation);
 
     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
 
     [branch] if (bsdfData.enableTransmission)
     {
-        float LdotV = dot(L, V); // Also computed in BSDF()
-        // Compute the normal at the back of the object as R = reflect(N, -V)
-        // float RdotL = NdotL - 2 * preLightData.NdotV * LdotV;
-        float illuminance = saturate(-LdotV * attenuation);
+        // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
+        // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+        const float w = 0.3;
+        illuminance = saturate((-NdotL + w) / ((1.0 + w) * (1.0 + w)));
 
         // For low thickness, we can reuse the shadowing status for the back of the object.
         shadow       = bsdfData.useThinObjectMode ? shadow : 1;
     float clipFactor = ((positionLS.z >= 0) && (abs(positionNDC.x) <= 1 && abs(positionNDC.y) <= 1)) ? 1 : 0;
 
     float3 L = -lightData.forward; // Lights are pointing backward in Unity
-    float illuminance = saturate(dot(bsdfData.normalWS, L) * clipFactor);
+    float NdotL = dot(bsdfData.normalWS, L);
+    float illuminance = saturate(NdotL * clipFactor);
 
     diffuseLighting  = float3(0.0, 0.0, 0.0);
     specularLighting = float3(0.0, 0.0, 0.0);
 
     [branch] if (bsdfData.enableTransmission)
     {
-        float LdotV = dot(L, V); // Also computed in BSDF()
-        // Compute the normal at the back of the object as R = reflect(N, -V)
-        // float RdotL = NdotL - 2 * preLightData.NdotV * LdotV;
-        float illuminance = saturate(-LdotV * clipFactor);
+        // Reverse the normal + do some wrap lighting to have a nicer transition between regular lighting and transmittance
+        // Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+        const float w = 0.3;
+        illuminance = saturate((-NdotL + w) / ((1.0 + w) * (1.0 + w)));
 
         // For low thickness, we can reuse the shadowing status for the back of the object.
         shadow       = bsdfData.useThinObjectMode ? shadow : 1;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

     // Done one time for all layered - cumulate with spec occ alpha for now
     surfaceData.specularOcclusion *= GetHorizonOcclusion(V, surfaceData.normalWS, interpolatedVertexNormal, _HorizonFade);
 
-    uint transmissionMode = BitFieldExtract(_TransmissionFlags, 2u, 2u * surfaceData.subsurfaceProfile);
-
-    if (transmissionMode != SSS_TRSM_MODE_THIN)
-    {
-        // Convert thickness along the normal to thickness along the viewing direction.
-        // We assume that the thickness along the normal corresponds to the diameter of a sphere.
-        // We then find a position on the sphere which corresponds to the normal, and
-        // compute the length of the chord of the sphere along the viewing direction.
-        // We add a small bias to (hopefully) have non-zero thickness.
-        surfaceData.thickness *= saturate(dot(interpolatedVertexNormal, V) + 0.01);
-    }
-
     // Caution: surfaceData must be fully initialize before calling GetBuiltinData
     GetBuiltinData(input, surfaceData, alpha, depthOffset, builtinData);
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawSssProfile.shader

                 float3 S = _ShapeParameter.rgb;
                 float3 M = S * (exp(-r * S) + exp(-r * S * (1.0 / 3.0))) / (8 * PI * r);
 
-                // Apply gamma for visualization only. It is not present in the actual formula!
+                // Apply gamma for visualization only.
                 return float4(pow(M * _SurfaceAlbedo.rgb, 1.0 / 3.0), 1);
             }
             ENDHLSL

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawTransmittanceGraph.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "../../ShaderLibrary/Common.hlsl"
-            #include "../../ShaderLibrary/Color.hlsl"
-            #include "../ShaderVariables.hlsl"
+            #include "../../../ShaderLibrary/Common.hlsl"
+            #include "../../../ShaderLibrary/Color.hlsl"
+            #include "../../ShaderVariables.hlsl"
-            #include "../Material/Material.hlsl"
+            #include "../../Material/Material.hlsl"
 
             //-------------------------------------------------------------------------------------
             // Inputs & outputs
                 float  d = (_ThicknessRemap.x + input.texcoord.x * (_ThicknessRemap.y - _ThicknessRemap.x));
                 float3 T = ComputeTransmittance(_ShapeParameter.rgb, _VolumeAlbedo.rgb, d, 1);
 
-                return float4(T, 1);
+                // Apply gamma for visualization only.
+                return float4(pow(T, 1.0 / 3), 1);
             }
             ENDHLSL
         }

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/DrawGaussianProfile.shader.meta

-fileFormatVersion: 2
-guid: 2e8a76823cb2af944b4b45169f2649f9
-timeCreated: 1487181006
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/DrawGaussianProfile.shader

-Shader "Hidden/HDRenderPipeline/DrawGaussianProfile"
-{
-    Properties
-    {
-        [HideInInspector] _StdDev1("", Color) = (0, 0, 0)
-        [HideInInspector] _StdDev2("", Color) = (0, 0, 0)
-        [HideInInspector] _LerpWeight("", Float) = 0
-    }
-
-    SubShader
-    {
-        Pass
-        {
-            Cull   Off
-            ZTest  Off
-            ZWrite Off
-            Blend  Off
-
-            HLSLPROGRAM
-            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
-
-            #pragma vertex Vert
-            #pragma fragment Frag
-
-            //-------------------------------------------------------------------------------------
-            // Include
-            //-------------------------------------------------------------------------------------
-
-            #include "../../ShaderLibrary/Common.hlsl"
-            #include "../../ShaderLibrary/Color.hlsl"
-            #include "../ShaderVariables.hlsl"
-
-            //-------------------------------------------------------------------------------------
-            // Inputs & outputs
-            //-------------------------------------------------------------------------------------
-
-            float4 _StdDev1, _StdDev2; float _LerpWeight; // See 'SubsurfaceScatteringParameters'
-
-            //-------------------------------------------------------------------------------------
-            // Implementation
-            //-------------------------------------------------------------------------------------
-
-            struct Attributes
-            {
-                float3 vertex   : POSITION;
-                float2 texcoord : TEXCOORD0;
-            };
-
-            struct Varyings
-            {
-                float4 vertex   : SV_POSITION;
-                float2 texcoord : TEXCOORD0;
-            };
-
-            Varyings Vert(Attributes input)
-            {
-                Varyings output;
-                output.vertex   = TransformWorldToHClip(input.vertex);
-                output.texcoord = input.texcoord.xy;
-                return output;
-            }
-
-            float4 Frag(Varyings input) : SV_Target
-            {
-                float  dist = length(input.texcoord - 0.5);
-
-                float3 var1 = _StdDev1.rgb * _StdDev1.rgb;
-                float3 var2 = _StdDev2.rgb * _StdDev2.rgb;
-
-                // Evaluate the linear combination of two 2D Gaussians instead of
-                // product of a linear combination of two normalized 1D Gaussians
-                // since we do not want to bother artists with the lack of radial symmetry.
-
-                float3 magnitude = lerp(exp(-dist * dist / (2 * var1)) / (TWO_PI * var1),
-                                        exp(-dist * dist / (2 * var2)) / (TWO_PI * var2), _LerpWeight);
-
-                return float4(magnitude, 1);
-            }
-            ENDHLSL
-        }
-    }
-    Fallback Off
-}