Add the world scale to the SSS pass

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             Shader.SetGlobalInt(     "_TexturingModeFlags", (int)sssParameters.texturingModeFlags);
             Shader.SetGlobalInt(     "_TransmissionFlags",  (int)sssParameters.transmissionFlags);
             cmd.SetGlobalFloatArray( "_ThicknessRemaps",         sssParameters.thicknessRemaps);
+            cmd.SetGlobalFloatArray( "_WorldScales",             sssParameters.worldScales);
             cmd.SetGlobalVectorArray("_ShapeParameters",         sssParameters.shapeParameters);
             cmd.SetGlobalVectorArray("_SurfaceAlbedos",          sssParameters.surfaceAlbedos);
 

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

 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
+float  _WorldScales[SSS_N_PROFILES];        // Size of the world unit in meters
 
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material

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

             #pragma fragment Frag
 
             #define SSS_PASS
-            #define METERS_TO_MILLIMETERS 1000
+            #define MILLIMETERS_PER_METER 1000
 
             //-------------------------------------------------------------------------------------
             // Include
             }
 
             // Computes F(x)/P(x), s.t. x = sqrt(r^2 + z^2).
-            float3 ComputeBilateralWeight(float3 S, float r, float z, float distScale, float rcpPdf)
+            float3 ComputeBilateralWeight(float3 S, float r, float z, float rcpDistScale, float rcpPdf)
-                float3 valX = KernelValCircle(sqrt(r * r + z * z) * rcp(distScale), S);
+                float3 valX = KernelValCircle(sqrt(r * r + z * z) * rcpDistScale, S);
 
                 // The reciprocal of the PDF could be reinterpreted as a 'dx' term in Int{F(x)dx}.
                 // As we shift the location of the value on the curve during integration,
                 float3 cornerPosVS = ComputeViewSpacePosition(cornerPosSS,         rawDepth, _InvProjMatrix);
 
                 // Compute the view-space dimensions of the pixel as a quad projected onto geometry.
-                float2 metersPerPixel = 2 * (cornerPosVS.xy - centerPosVS.xy);
-                float2 scaledPixPerMm = distScale * rcp(METERS_TO_MILLIMETERS * metersPerPixel);
+                float2 unitsPerPixel  = 2 * (cornerPosVS.xy - centerPosVS.xy);
+                float  metersPerUnit  = _WorldScales[profileID];
+                float  millimPerUnit  = MILLIMETERS_PER_METER * metersPerUnit;
+                float2 scaledPixPerMm = distScale * rcp(millimPerUnit * unitsPerPixel);
 
                 // Take the first (central) sample.
                 float2 samplePosition   = posInput.unPositionSS;
 
                         // Apply bilateral weighting.
                         float sampleZ = LinearEyeDepth(rawDepth, _ZBufferParams);
-                        float z       = METERS_TO_MILLIMETERS * sampleZ - (METERS_TO_MILLIMETERS * centerPosVS.z);
-                        sampleWeight  = ComputeBilateralWeight(shapeParam, r, z, distScale, sampleRcpPdf);
+                        float z       = millimPerUnit * sampleZ - (millimPerUnit * centerPosVS.z);
+                        sampleWeight  = ComputeBilateralWeight(shapeParam, r, z, rcp(distScale), sampleRcpPdf);
 
                         totalIrradiance += sampleWeight * sampleIrradiance;
                         totalWeight     += sampleWeight;

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

         public TexturingMode    texturingMode;
         public TransmissionMode transmissionMode;
         public Vector2          thicknessRemap;             // X = min, Y = max (in millimeters)
+        public float            worldScale;                 // Size of the world unit in meters
-        public int              settingsIndex;              // For SubsurfaceScatteringSettings.profiles
+        public int              settingsIndex;              // SubsurfaceScatteringSettings.profiles[i]
         [SerializeField]
         Vector3                 m_S;                        // RGB = shape parameter: S = 1 / D
         [SerializeField]
             texturingMode      = TexturingMode.PreAndPostScatter;
             transmissionMode   = TransmissionMode.None;
             thicknessRemap     = new Vector2(0.0f, 5.0f);
+            worldScale         = 1.0f;
             settingsIndex      = SssConstants.SSS_NEUTRAL_PROFILE_ID; // Updated by SubsurfaceScatteringSettings.OnValidate() once assigned
 
             BuildKernel();
         public SubsurfaceScatteringProfile[] profiles;
         // Below are the cached values.
         [NonSerialized] public uint          texturingModeFlags;        // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-        [NonSerialized] public uint          transmissionFlags;         // 2 bit/profile; 0 = None, 1 = ThinObject, 2 = ThickObject
+        [NonSerialized] public uint          transmissionFlags;         // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
+        [NonSerialized] public float[]       worldScales;               // Size of the world unit in meters
         [NonSerialized] public float[]       filterKernelsNearField;    // 0 = radius, 1 = reciprocal of the PDF
         [NonSerialized] public float[]       filterKernelsFarField;     // 0 = radius, 1 = reciprocal of the PDF
 
 
                 profiles[i].thicknessRemap.y = Mathf.Max(profiles[i].thicknessRemap.y, 0);
                 profiles[i].thicknessRemap.x = Mathf.Clamp(profiles[i].thicknessRemap.x, 0, profiles[i].thicknessRemap.y);
+                profiles[i].worldScale       = Mathf.Max(profiles[i].worldScale, 0.001f);
 
                 profiles[i].BuildKernel();
             }
 
         public void UpdateCache()
         {
-            
             texturingModeFlags = transmissionFlags = 0;
 
             const int thicknessRemapsLen = SssConstants.SSS_N_PROFILES * 2;
             }
 
+            const int worldScalesLen = SssConstants.SSS_N_PROFILES;
+            if (worldScales == null || worldScales.Length != worldScalesLen)
+            {
+                worldScales = new float[worldScalesLen];
+            }
+
             const int shapeParametersLen = SssConstants.SSS_N_PROFILES;
             if (shapeParameters == null || shapeParameters.Length != shapeParametersLen)
             {
 
                 thicknessRemaps[2 * i]     = profiles[i].thicknessRemap.x;
                 thicknessRemaps[2 * i + 1] = profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x;
+                worldScales[i]             = profiles[i].worldScale;
                 shapeParameters[i]         = profiles[i].shapeParameter;
                 shapeParameters[i].w       = profiles[i].scatteringDistance;
                 surfaceAlbedos[i]          = profiles[i].surfaceAlbedo;
 
                 shapeParameters[i] = Vector4.zero;
                 surfaceAlbedos[i]  = Vector4.zero;
+                worldScales[i]     = 1.0f;
 
                 for (int j = 0, n = SssConstants.SSS_N_SAMPLES_NEAR_FIELD; j < n; j++)
                 {
             };
             public readonly GUIContent   sssProfileMinMaxThickness = new GUIContent("Min-Max Thickness", "Shows the values of the thickness remap below (in millimeters).");
             public readonly GUIContent   sssProfileThicknessRemap  = new GUIContent("Thickness Remap", "Remaps the thickness parameter from [0, 1] to the desired range (in millimeters).");
+            public readonly GUIContent   sssProfileWorldScale      = new GUIContent("World Scale", "Size of the world unit in meters.");
 
             public readonly GUIStyle     centeredMiniBoldLabel     = new GUIStyle(GUI.skin.label);
 
         private RenderTexture      m_ProfileImage, m_TransmittanceImage;
         private Material           m_ProfileMaterial, m_TransmittanceMaterial;
         private SerializedProperty m_LenVolMeanFreePath, m_ScatteringDistance, m_SurfaceAlbedo, m_S,
-                                   m_TexturingMode, m_TransmissionMode, m_ThicknessRemap;
+                                   m_TexturingMode, m_TransmissionMode, m_ThicknessRemap, m_WorldScale;
 
         void OnEnable()
         {
             m_TexturingMode         = serializedObject.FindProperty("texturingMode");
             m_TransmissionMode      = serializedObject.FindProperty("transmissionMode");
             m_ThicknessRemap        = serializedObject.FindProperty("thicknessRemap");
+            m_WorldScale            = serializedObject.FindProperty("worldScale");
 
             m_ProfileMaterial       = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawSssProfile");
             m_TransmittanceMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawTransmittanceGraph");
                 Vector2 thicknessRemap = m_ThicknessRemap.vector2Value;
                 EditorGUILayout.MinMaxSlider(styles.sssProfileThicknessRemap, ref thicknessRemap.x, ref thicknessRemap.y, 0.0f, 50.0f);
                 m_ThicknessRemap.vector2Value = thicknessRemap;
+                EditorGUILayout.PropertyField(m_WorldScale, styles.sssProfileWorldScale);
 
                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField(styles.sssProfilePreview0, styles.centeredMiniBoldLabel);