Multiply transmittance by the surface albedo

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);
 
             renderContext.ExecuteCommandBuffer(cmd);
             cmd.Dispose();

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

 uint   _TransmissionFlags;                  // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
 float  _ThicknessRemaps[SSS_N_PROFILES][2]; // Remap: 0 = start, 1 = end - start
 float4 _ShapeParameters[SSS_N_PROFILES];    // RGB = S = 1 / D; A = filter radius
+float4 _SurfaceAlbedos[SSS_N_PROFILES];     // RGB = color, A = unused
 
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
 // Computes the fraction of light passing through the object.
 // N.b.: it is not just zero scattering (light traveling in a straight path)!
 // Ref: Approximate Reflectance Profiles for Efficient Subsurface Scattering by Pixar (BSSRDF only).
-float3 ComputeTransmittance(float3 S, float thickness, float radiusScale)
+float3 ComputeTransmittance(float3 S, float3 surfaceAlbedo, float thickness, float radiusScale)
 {
     // Thickness and SSS radius are decoupled for artists.
     // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
 
-    return 0.5 * (expOneThird + expOneThird * expOneThird * expOneThird);
+    return 0.5 * (expOneThird + expOneThird * expOneThird * expOneThird) * surfaceAlbedo;
 }
 
 void FillMaterialIdStandardData(float3 baseColor, float specular, float metallic, float roughness, float3 normalWS, float3 tangentWS, float anisotropy, inout BSDFData bsdfData)
 
     if (bsdfData.enableTransmission)
     {
-        bsdfData.transmittance = ComputeTransmittance(_ShapeParameters[subsurfaceProfile].rgb, bsdfData.thickness, bsdfData.subsurfaceRadius);
+        bsdfData.transmittance = ComputeTransmittance(_ShapeParameters[subsurfaceProfile].rgb,
+                                                      _SurfaceAlbedos[subsurfaceProfile].rgb,
+                                                      bsdfData.thickness, bsdfData.subsurfaceRadius);
     }
 
     bool performPostScatterTexturing = IsBitSet(_TexturingModeFlags, subsurfaceProfile);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/CombineSubsurfaceScattering.shader

             //-------------------------------------------------------------------------------------
 
             // Computes the value of the integrand over a disk: (2 * PI * r) * KernelVal().
-            // N.b.: the returned value is multiplied by 4.
+            // N.b.: the returned value is multiplied by 4. It is irrelevant due to weight renormalization.
-                // We can skip the multiplication by 0.25 due to weight renormalization.
                 return /* 0.25 * */ S * (expOneThird + expOneThird * expOneThird * expOneThird);
             }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

         [NonSerialized] public uint          transmissionFlags;         // 2 bit/profile; 0 = None, 1 = ThinObject, 2 = ThickObject
         [NonSerialized] public float[]       thicknessRemaps;           // Remap: 0 = start, 1 = end - start
         [NonSerialized] public Vector4[]     shapeParameters;           // RGB = S = 1 / D, A = filter radius
+        [NonSerialized] public Vector4[]     surfaceAlbedos;            // RGB = color, A = unused
         [NonSerialized] public float[]       filterKernelsNearField;    // 0 = radius, 1 = reciprocal of the PDF
         [NonSerialized] public float[]       filterKernelsFarField;     // 0 = radius, 1 = reciprocal of the PDF
 
                 shapeParameters = new Vector4[shapeParametersLen];
             }
 
+            const int surfaceAlbedosLen = SssConstants.SSS_N_PROFILES;
+            if (surfaceAlbedos == null || surfaceAlbedos.Length != surfaceAlbedosLen)
+            {
+                surfaceAlbedos = new Vector4[surfaceAlbedosLen];
+            }
+
             const int filterKernelsNearFieldLen = 2 * SssConstants.SSS_N_PROFILES * SssConstants.SSS_N_SAMPLES_NEAR_FIELD;
             if (filterKernelsNearField == null || filterKernelsNearField.Length != filterKernelsNearFieldLen)
             {
                 thicknessRemaps[2 * i + 1] = profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x;
                 shapeParameters[i]         = profiles[i].shapeParameter;
                 shapeParameters[i].w       = profiles[i].scatteringDistance;
+                surfaceAlbedos[i]          = profiles[i].surfaceAlbedo;
 
                 for (int j = 0, n = SssConstants.SSS_N_SAMPLES_NEAR_FIELD; j < n; j++)
                 {
                 int i = SssConstants.SSS_NEUTRAL_PROFILE_ID;
 
                 shapeParameters[i] = Vector4.zero;
+                surfaceAlbedos[i]  = Vector4.zero;
 
                 for (int j = 0, n = SssConstants.SSS_N_SAMPLES_NEAR_FIELD; j < n; j++)
                 {

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

                 float3 S = _ShapeParameter.rgb;
                 float3 T = 0.5 * exp(-d * S) + 0.5 * exp(-d * S * (1.0 / 3.0));
 
-                // N.b.: we multiply by the surface albedo of the actual geometry during shading.
                 return float4(T * _SurfaceAlbedo.rgb, 1);
             }
             ENDHLSL