Rename SubsurfaceProfile to DiffusionProfile and SubsurfaceRadius to SubsurfaceMask

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineMenuItems.cs

                         if (fvalue == 0.0) // SSS
                         {
                             CheckOutFile(VSCEnabled, mat);
-                            int ivalue = mat.GetInt("_SubsurfaceProfile");
+                            int ivalue = mat.GetInt("_DiffusionProfile");
-                                mat.SetInt("_SubsurfaceProfile", 0);
+                                mat.SetInt("_DiffusionProfile", 0);
-                                mat.SetInt("_SubsurfaceProfile", ivalue + 1);
+                                mat.SetInt("_DiffusionProfile", ivalue + 1);
                             }
 
                             EditorUtility.SetDirty(mat);
 
                             for (int x = 0; x < numLayer; ++x)
                             {
-                                int ivalue = mat.GetInt("_SubsurfaceProfile" + x);
+                                int ivalue = mat.GetInt("_DiffusionProfile" + x);
-                                    mat.SetInt("_SubsurfaceProfile" + x, 0);
+                                    mat.SetInt("_DiffusionProfile" + x, 0);
-                                    mat.SetInt("_SubsurfaceProfile" + x, ivalue + 1);
+                                    mat.SetInt("_DiffusionProfile" + x, ivalue + 1);
                                 }
                             }
                             EditorUtility.SetDirty(mat);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/LayeredLit/LayeredLitUI.cs

 
                 CoreUtils.SetKeyword(material, "_HEIGHTMAP" + i, material.GetTexture(kHeightMap + i));
 
-                CoreUtils.SetKeyword(material, "_SUBSURFACE_RADIUS_MAP" + i, material.GetTexture(kSubsurfaceRadiusMap + i));
+                CoreUtils.SetKeyword(material, "_SUBSURFACE_MASK_MAP" + i, material.GetTexture(kSubsurfaceMaskMap + i));
                 CoreUtils.SetKeyword(material, "_THICKNESSMAP" + i, material.GetTexture(kThicknessMap + i));
             }
 

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

             public static GUIContent linkDetailsWithBaseText = new GUIContent("Lock to Base Tiling/Offset", "Lock details Tiling/Offset to Base Tiling/Offset");
 
             // Subsurface
-            public static GUIContent subsurfaceProfileText = new GUIContent("Subsurface profile", "A profile determines the shape of the blur filter.");
-            public static GUIContent subsurfaceRadiusText = new GUIContent("Subsurface radius", "Determines the range of the blur.");
-            public static GUIContent subsurfaceRadiusMapText = new GUIContent("Subsurface radius map (R)", "Determines the range of the blur.");
+            public static GUIContent diffusionProfileText = new GUIContent("Diffusion profile", "A profile determines the shape of the blur/transmission filter.");
+            public static GUIContent subsurfaceMaskText = new GUIContent("Subsurface radius", "Determines the range of the blur.");
+            public static GUIContent subsurfaceMaskMapText = new GUIContent("Subsurface radius map (R)", "Determines the range of the blur.");
             public static GUIContent thicknessText = new GUIContent("Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
             public static GUIContent thicknessMapText = new GUIContent("Thickness map (R)", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.");
             public static GUIContent thicknessRemapText = new GUIContent("Thickness Remap", "Remaps values of the thickness map from [0, 1] to the specified range.");
         protected MaterialProperty[] heightMax = new MaterialProperty[kMaxLayerCount];
         protected const string kHeightMax = "_HeightMax";
 
-        protected MaterialProperty[] subsurfaceProfileID = new MaterialProperty[kMaxLayerCount];
-        protected const string kSubsurfaceProfileID = "_SubsurfaceProfile";
-        protected MaterialProperty[] subsurfaceRadius = new MaterialProperty[kMaxLayerCount];
-        protected const string kSubsurfaceRadius = "_SubsurfaceRadius";
-        protected MaterialProperty[] subsurfaceRadiusMap = new MaterialProperty[kMaxLayerCount];
-        protected const string kSubsurfaceRadiusMap = "_SubsurfaceRadiusMap";
+        protected MaterialProperty[] diffusionProfileID = new MaterialProperty[kMaxLayerCount];
+        protected const string kDiffusionProfileID = "_DiffusionProfile";
+        protected MaterialProperty[] subsurfaceMask = new MaterialProperty[kMaxLayerCount];
+        protected const string kSubsurfaceMask = "_SubsurfaceMask";
+        protected MaterialProperty[] subsurfaceMaskMap = new MaterialProperty[kMaxLayerCount];
+        protected const string kSubsurfaceMaskMap = "_SubsurfaceMaskMap";
         protected MaterialProperty[] thickness = new MaterialProperty[kMaxLayerCount];
         protected const string kThickness = "_Thickness";
         protected MaterialProperty[] thicknessMap = new MaterialProperty[kMaxLayerCount];
                 heightCenter[i] = FindProperty(string.Format("{0}{1}", kHeightCenter, m_PropertySuffixes[i]), props);
 
                 // Sub surface
-                subsurfaceProfileID[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceProfileID, m_PropertySuffixes[i]), props);
-                subsurfaceRadius[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceRadius, m_PropertySuffixes[i]), props);
-                subsurfaceRadiusMap[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceRadiusMap, m_PropertySuffixes[i]), props);
+                diffusionProfileID[i] = FindProperty(string.Format("{0}{1}", kDiffusionProfileID, m_PropertySuffixes[i]), props);
+                subsurfaceMask[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceMask, m_PropertySuffixes[i]), props);
+                subsurfaceMaskMap[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceMaskMap, m_PropertySuffixes[i]), props);
                 thickness[i] = FindProperty(string.Format("{0}{1}", kThickness, m_PropertySuffixes[i]), props);
                 thicknessMap[i] = FindProperty(string.Format("{0}{1}", kThicknessMap, m_PropertySuffixes[i]), props);
                 thicknessRemap[i] = FindProperty(string.Format("{0}{1}", kThicknessRemap, m_PropertySuffixes[i]), props);
 
             using (var scope = new EditorGUI.ChangeCheckScope())
             {
-                int profileID = (int)subsurfaceProfileID[layerIndex].floatValue;
+                int profileID = (int)diffusionProfileID[layerIndex].floatValue;
-                    EditorGUILayout.PrefixLabel(Styles.subsurfaceProfileText);
+                    EditorGUILayout.PrefixLabel(Styles.diffusionProfileText);
 
                     using (new EditorGUILayout.HorizontalScope())
                     {
                 }
 
                 if (scope.changed)
-                    subsurfaceProfileID[layerIndex].floatValue = profileID;
+                    diffusionProfileID[layerIndex].floatValue = profileID;
-            m_MaterialEditor.ShaderProperty(subsurfaceRadius[layerIndex], Styles.subsurfaceRadiusText);
-            m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceRadiusMapText, subsurfaceRadiusMap[layerIndex]);
+            m_MaterialEditor.ShaderProperty(subsurfaceMask[layerIndex], Styles.subsurfaceMaskText);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceMaskMapText, subsurfaceMaskMap[layerIndex]);
             m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap[layerIndex]);
             if (thicknessMap[layerIndex].textureValue != null)
             {
             CoreUtils.SetKeyword(material, "_HEIGHTMAP", material.GetTexture(kHeightMap));
             CoreUtils.SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap));
             CoreUtils.SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap));
-            CoreUtils.SetKeyword(material, "_SUBSURFACE_RADIUS_MAP", material.GetTexture(kSubsurfaceRadiusMap));
+            CoreUtils.SetKeyword(material, "_SUBSURFACE_MASK_MAP", material.GetTexture(kSubsurfaceMaskMap));
             CoreUtils.SetKeyword(material, "_THICKNESSMAP", material.GetTexture(kThicknessMap));
             CoreUtils.SetKeyword(material, "_SPECULARCOLORMAP", material.GetTexture(kSpecularColorMap));
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _InputCubemap = Shader.PropertyToID("_InputCubemap");
         public static readonly int _Mipmap = Shader.PropertyToID("_Mipmap");
 
-        public static readonly int _SubsurfaceProfile = Shader.PropertyToID("_SubsurfaceProfile");
+        public static readonly int _DiffusionProfile = Shader.PropertyToID("_DiffusionProfile");
         public static readonly int _MaxRadius = Shader.PropertyToID("_MaxRadius");
         public static readonly int _ShapeParam = Shader.PropertyToID("_ShapeParam");
         public static readonly int _StdDev1 = Shader.PropertyToID("_StdDev1");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLit.shader

         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace2("NormalMap space", Float) = 0
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace3("NormalMap space", Float) = 0
 
-        _SubsurfaceProfile0("Subsurface Profile0", Int) = 0
-        _SubsurfaceProfile1("Subsurface Profile1", Int) = 0
-        _SubsurfaceProfile2("Subsurface Profile2", Int) = 0
-        _SubsurfaceProfile3("Subsurface Profile3", Int) = 0
+        _DiffusionProfile0("Diffusion Profile0", Int) = 0
+        _DiffusionProfile1("Diffusion Profile1", Int) = 0
+        _DiffusionProfile2("Diffusion Profile2", Int) = 0
+        _DiffusionProfile3("Diffusion Profile3", Int) = 0
-        _SubsurfaceRadius0("Subsurface Radius0", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadius1("Subsurface Radius1", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadius2("Subsurface Radius2", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadius3("Subsurface Radius3", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask0("Subsurface Mask0", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask1("Subsurface Mask1", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask2("Subsurface Mask2", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask3("Subsurface Mask3", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadiusMap0("Subsurface Radius Map0", 2D) = "white" {}
-        _SubsurfaceRadiusMap1("Subsurface Radius Map1", 2D) = "white" {}
-        _SubsurfaceRadiusMap2("Subsurface Radius Map2", 2D) = "white" {}
-        _SubsurfaceRadiusMap3("Subsurface Radius Map3", 2D) = "white" {}
+        _SubsurfaceMaskMap0("Subsurface Mask Map0", 2D) = "white" {}
+        _SubsurfaceMaskMap1("Subsurface Mask Map1", 2D) = "white" {}
+        _SubsurfaceMaskMap2("Subsurface Mask Map2", 2D) = "white" {}
+        _SubsurfaceMaskMap3("Subsurface Mask Map3", 2D) = "white" {}
 
         _Thickness0("Thickness", Range(0.0, 1.0)) = 1.0
         _Thickness1("Thickness", Range(0.0, 1.0)) = 1.0
     #pragma shader_feature _HEIGHTMAP1
     #pragma shader_feature _HEIGHTMAP2
     #pragma shader_feature _HEIGHTMAP3
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP0
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP1
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP2
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP3
+    #pragma shader_feature _SUBSURFACE_MASK_MAP0
+    #pragma shader_feature _SUBSURFACE_MASK_MAP1
+    #pragma shader_feature _SUBSURFACE_MASK_MAP2
+    #pragma shader_feature _SUBSURFACE_MASK_MAP3
     #pragma shader_feature _THICKNESSMAP0
     #pragma shader_feature _THICKNESSMAP1
     #pragma shader_feature _THICKNESSMAP2

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitData.hlsl

 #define SAMPLER_HEIGHTMAP_IDX sampler_HeightMap3
 #endif
 
-#if defined(_SUBSURFACE_RADIUS_MAP0)
-#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap0
-#elif defined(_SUBSURFACE_RADIUS_MAP1)
-#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap1
-#elif defined(_SUBSURFACE_RADIUS_MAP2)
-#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap2
-#elif defined(_SUBSURFACE_RADIUS_MAP3)
-#define _SUBSURFACE_RADIUS_MAP_IDX sampler_SubsurfaceRadiusMap3
+#if defined(_SUBSURFACE_MASK_MAP0)
+#define _SUBSURFACE_MASK_MAP_IDX sampler_SubsurfaceMaskMap0
+#elif defined(_SUBSURFACE_MASK_MAP1)
+#define _SUBSURFACE_MASK_MAP_IDX sampler_SubsurfaceMaskMap1
+#elif defined(_SUBSURFACE_MASK_MAP2)
+#define _SUBSURFACE_MASK_MAP_IDX sampler_SubsurfaceMaskMap2
+#elif defined(_SUBSURFACE_MASK_MAP3)
+#define _SUBSURFACE_MASK_MAP_IDX sampler_SubsurfaceMaskMap3
 #endif
 
 #if defined(_THICKNESSMAP0)
 #ifdef _DETAIL_MAP0
 #define _DETAIL_MAP_IDX
 #endif
-#ifdef _SUBSURFACE_RADIUS_MAP0
-#define _SUBSURFACE_RADIUS_MAP_IDX
+#ifdef _SUBSURFACE_MASK_MAP0
+#define _SUBSURFACE_MASK_MAP_IDX
 #endif
 #ifdef _THICKNESSMAP0
 #define _THICKNESSMAP_IDX
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
-#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _SUBSURFACE_MASK_MAP_IDX
 #undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
 #ifdef _DETAIL_MAP1
 #define _DETAIL_MAP_IDX
 #endif
-#ifdef _SUBSURFACE_RADIUS_MAP1
-#define _SUBSURFACE_RADIUS_MAP_IDX
+#ifdef _SUBSURFACE_MASK_MAP1
+#define _SUBSURFACE_MASK_MAP_IDX
 #endif
 #ifdef _THICKNESSMAP1
 #define _THICKNESSMAP_IDX
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
-#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _SUBSURFACE_MASK_MAP_IDX
 #undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
 #ifdef _DETAIL_MAP2
 #define _DETAIL_MAP_IDX
 #endif
-#ifdef _SUBSURFACE_RADIUS_MAP2
-#define _SUBSURFACE_RADIUS_MAP_IDX
+#ifdef _SUBSURFACE_MASK_MAP2
+#define _SUBSURFACE_MASK_MAP_IDX
 #endif
 #ifdef _THICKNESSMAP2
 #define _THICKNESSMAP_IDX
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
-#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _SUBSURFACE_MASK_MAP_IDX
 #undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
 #ifdef _DETAIL_MAP3
 #define _DETAIL_MAP_IDX
 #endif
-#ifdef _SUBSURFACE_RADIUS_MAP3
-#define _SUBSURFACE_RADIUS_MAP_IDX
+#ifdef _SUBSURFACE_MASK_MAP3
+#define _SUBSURFACE_MASK_MAP_IDX
 #endif
 #ifdef _THICKNESSMAP3
 #define _THICKNESSMAP_IDX
 #undef _NORMALMAP_IDX
 #undef _NORMALMAP_TANGENT_SPACE_IDX
 #undef _DETAIL_MAP_IDX
-#undef _SUBSURFACE_RADIUS_MAP_IDX
+#undef _SUBSURFACE_MASK_MAP_IDX
 #undef _THICKNESSMAP_IDX
 #undef _MASKMAP_IDX
 #undef _BENTNORMALMAP_IDX
     surfaceData.ambientOcclusion = SURFACEDATA_BLEND_SCALAR(surfaceData, ambientOcclusion, weights);
     surfaceData.metallic = SURFACEDATA_BLEND_SCALAR(surfaceData, metallic, weights);
     surfaceData.tangentWS = normalize(input.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. Tag: SURFACE_GRADIENT
-    surfaceData.subsurfaceRadius = SURFACEDATA_BLEND_SCALAR(surfaceData, subsurfaceRadius, weights);
+    surfaceData.subsurfaceMask = SURFACEDATA_BLEND_SCALAR(surfaceData, subsurfaceMask, weights);
-    surfaceData.subsurfaceProfile = SURFACEDATA_BLEND_SSS_PROFILE(surfaceData, subsurfaceProfile, weights);
+    surfaceData.diffusionProfile = SURFACEDATA_BLEND_SSS_PROFILE(surfaceData, diffusionProfile, weights);
 
     // Layered shader support either SSS or standard (can't mix them)
 #ifdef _MATID_SSS

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace2("NormalMap space", Float) = 0
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace3("NormalMap space", Float) = 0
 
-        _SubsurfaceProfile0("Subsurface Profile0", Int) = 0
-        _SubsurfaceProfile1("Subsurface Profile1", Int) = 0
-        _SubsurfaceProfile2("Subsurface Profile2", Int) = 0
-        _SubsurfaceProfile3("Subsurface Profile3", Int) = 0
+        _DiffusionProfile0("Diffusion Profile0", Int) = 0
+        _DiffusionProfile1("Diffusion Profile1", Int) = 0
+        _DiffusionProfile2("Diffusion Profile2", Int) = 0
+        _DiffusionProfile3("Diffusion Profile3", Int) = 0
-        _SubsurfaceRadius0("Subsurface Radius0", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadius1("Subsurface Radius1", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadius2("Subsurface Radius2", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadius3("Subsurface Radius3", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask0("Subsurface Mask0", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask1("Subsurface Mask1", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask2("Subsurface Mask2", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMask3("Subsurface Mask3", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadiusMap0("Subsurface Radius Map0", 2D) = "white" {}
-        _SubsurfaceRadiusMap1("Subsurface Radius Map1", 2D) = "white" {}
-        _SubsurfaceRadiusMap2("Subsurface Radius Map2", 2D) = "white" {}
-        _SubsurfaceRadiusMap3("Subsurface Radius Map3", 2D) = "white" {}
+        _SubsurfaceMaskMap0("Subsurface Mask Map0", 2D) = "white" {}
+        _SubsurfaceMaskMap1("Subsurface Mask Map1", 2D) = "white" {}
+        _SubsurfaceMaskMap2("Subsurface Mask Map2", 2D) = "white" {}
+        _SubsurfaceMaskMap3("Subsurface Mask Map3", 2D) = "white" {}
 
         _Thickness0("Thickness", Range(0.0, 1.0)) = 1.0
         _Thickness1("Thickness", Range(0.0, 1.0)) = 1.0
     #pragma shader_feature _HEIGHTMAP1
     #pragma shader_feature _HEIGHTMAP2
     #pragma shader_feature _HEIGHTMAP3
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP0
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP1
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP2
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP3
+    #pragma shader_feature _SUBSURFACE_MASK_MAP0
+    #pragma shader_feature _SUBSURFACE_MASK_MAP1
+    #pragma shader_feature _SUBSURFACE_MASK_MAP2
+    #pragma shader_feature _SUBSURFACE_MASK_MAP3
     #pragma shader_feature _THICKNESSMAP0
     #pragma shader_feature _THICKNESSMAP1
     #pragma shader_feature _THICKNESSMAP2

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

 
             // SSS
             [SurfaceDataAttributes("Subsurface Radius")]
-            public float subsurfaceRadius;
+            public float subsurfaceMask;
-            public int subsurfaceProfile;
+            public int diffusionProfile;
 
             // SpecColor
             [SurfaceDataAttributes("Specular Color", false, true)]
             // fold into fresnel0
 
             // SSS
-            public float   subsurfaceRadius;
+            public float   subsurfaceMask;
-            public int     subsurfaceProfile;
+            public int     diffusionProfile;
             public bool    enableTransmission; // Read from the SSS profile
             public bool    useThickObjectMode; // Read from the SSS profile
             public Vector3 transmittance;

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

 #define DEBUGVIEW_LIT_SURFACEDATA_TANGENT_WS (1006)
 #define DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY (1007)
 #define DEBUGVIEW_LIT_SURFACEDATA_METALLIC (1008)
-#define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS (1009)
+#define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_MASK (1009)
-#define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE (1011)
+#define DEBUGVIEW_LIT_SURFACEDATA_DIFFUSION_PROFILE (1011)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1012)
 #define DEBUGVIEW_LIT_SURFACEDATA_COAT_MASK (1013)
 #define DEBUGVIEW_LIT_SURFACEDATA_IOR (1014)
 #define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T (1038)
 #define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B (1039)
 #define DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY (1040)
-#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS (1041)
+#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_MASK (1041)
-#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE (1043)
+#define DEBUGVIEW_LIT_BSDFDATA_DIFFUSION_PROFILE (1043)
 #define DEBUGVIEW_LIT_BSDFDATA_ENABLE_TRANSMISSION (1044)
 #define DEBUGVIEW_LIT_BSDFDATA_USE_THICK_OBJECT_MODE (1045)
 #define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE (1046)
     float3 tangentWS;
     float anisotropy;
     float metallic;
-    float subsurfaceRadius;
+    float subsurfaceMask;
-    int subsurfaceProfile;
+    int diffusionProfile;
     float3 specularColor;
     float coatMask;
     float ior;
     float roughnessT;
     float roughnessB;
     float anisotropy;
-    float subsurfaceRadius;
+    float subsurfaceMask;
-    int subsurfaceProfile;
+    int diffusionProfile;
     bool enableTransmission;
     bool useThickObjectMode;
     float3 transmittance;
         case DEBUGVIEW_LIT_SURFACEDATA_METALLIC:
             result = surfacedata.metallic.xxx;
             break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
-            result = surfacedata.subsurfaceRadius.xxx;
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_MASK:
+            result = surfacedata.subsurfaceMask.xxx;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
-            result = GetIndexColor(surfacedata.subsurfaceProfile);
+        case DEBUGVIEW_LIT_SURFACEDATA_DIFFUSION_PROFILE:
+            result = GetIndexColor(surfacedata.diffusionProfile);
             break;
         case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR:
             result = surfacedata.specularColor;
         case DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY:
             result = bsdfdata.anisotropy.xxx;
             break;
-        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS:
-            result = bsdfdata.subsurfaceRadius.xxx;
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_MASK:
+            result = bsdfdata.subsurfaceMask.xxx;
-        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE:
-            result = GetIndexColor(bsdfdata.subsurfaceProfile);
+        case DEBUGVIEW_LIT_BSDFDATA_DIFFUSION_PROFILE:
+            result = GetIndexColor(bsdfdata.diffusionProfile);
             break;
         case DEBUGVIEW_LIT_BSDFDATA_ENABLE_TRANSMISSION:
             result = (bsdfdata.enableTransmission) ? float3(1.0, 1.0, 1.0) : float3(0.0, 0.0, 0.0);

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

 }
 
 // Fills the data which may be accessed if MATERIALFEATUREFLAGS_LIT_SSS is set.
-void FillMaterialIdSssData(int subsurfaceProfile, float radius, float thickness, uint transmissionMode,
+void FillMaterialIdSssData(int diffusionProfile, float radius, float thickness, uint transmissionMode,
-    bsdfData.subsurfaceProfile  = subsurfaceProfile;
-    bsdfData.subsurfaceRadius   = radius;
+    bsdfData.diffusionProfile  = diffusionProfile;
+    bsdfData.subsurfaceMask   = radius;
-        bsdfData.thickness = _ThicknessRemaps[subsurfaceProfile].x + _ThicknessRemaps[subsurfaceProfile].y * thickness;
+        bsdfData.thickness = _ThicknessRemaps[diffusionProfile].x + _ThicknessRemaps[diffusionProfile].y * thickness;
-            bsdfData.transmittance = ComputeTransmittanceDisney(_ShapeParams[subsurfaceProfile].rgb,
-                                                                _TransmissionTintsAndFresnel0[subsurfaceProfile].rgb,
-                                                                bsdfData.thickness, bsdfData.subsurfaceRadius);
+            bsdfData.transmittance = ComputeTransmittanceDisney(_ShapeParams[diffusionProfile].rgb,
+                                                                _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
+                                                                bsdfData.thickness, bsdfData.subsurfaceMask);
-            bsdfData.transmittance = ComputeTransmittanceJimenez(_HalfRcpVariancesAndWeights[subsurfaceProfile][0].rgb,
-                                                                 _HalfRcpVariancesAndWeights[subsurfaceProfile][0].a,
-                                                                 _HalfRcpVariancesAndWeights[subsurfaceProfile][1].rgb,
-                                                                 _HalfRcpVariancesAndWeights[subsurfaceProfile][1].a,
-                                                                 _TransmissionTintsAndFresnel0[subsurfaceProfile].rgb,
-                                                                 bsdfData.thickness, bsdfData.subsurfaceRadius);
+            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);
 #endif
     }
 }
     SSSData sssData;
 
     sssData.diffuseColor = surfaceData.baseColor;
-    sssData.subsurfaceRadius = surfaceData.subsurfaceRadius;
-    sssData.subsurfaceProfile = surfaceData.subsurfaceProfile;
+    sssData.subsurfaceMask = surfaceData.subsurfaceMask;
+    sssData.diffusionProfile = surfaceData.diffusionProfile;
 
     return sssData;
 }
     else if (bsdfData.materialId == MATERIALID_LIT_SSS)
     {
         bsdfData.diffuseColor = surfaceData.baseColor;
-        bsdfData.fresnel0     = _TransmissionTintsAndFresnel0[surfaceData.subsurfaceProfile].a;
-        uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u * surfaceData.subsurfaceProfile, 2u);
+        bsdfData.fresnel0     = _TransmissionTintsAndFresnel0[surfaceData.diffusionProfile].a;
+        uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u * surfaceData.diffusionProfile, 2u);
-        FillMaterialIdSssData(surfaceData.subsurfaceProfile,
-                              surfaceData.subsurfaceRadius,
+        FillMaterialIdSssData(surfaceData.diffusionProfile,
+                              surfaceData.subsurfaceMask,
                               surfaceData.thickness,
                               transmissionMode, bsdfData);
     }
 
     if (HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_SSS))
     {
-        int   subsurfaceProfile = SSS_NEUTRAL_PROFILE_ID;
+        int   diffusionProfile = SSS_NEUTRAL_PROFILE_ID;
         uint  transmissionMode  = SSS_TRSM_MODE_NONE;
         float radius            = 0;
         float thickness         = 0;
-            // Reminder: when using SSS we exchange specular occlusion and subsurfaceRadius/profileID
+            // Reminder: when using SSS we exchange specular occlusion and subsurfaceMask/profileID
-            subsurfaceProfile = sssData.subsurfaceProfile;
-            transmissionMode  = BitFieldExtract(asuint(_TransmissionFlags), 2u * subsurfaceProfile, 2u);
-            radius            = sssData.subsurfaceRadius;
+            diffusionProfile = sssData.diffusionProfile;
+            transmissionMode  = BitFieldExtract(asuint(_TransmissionFlags), 2u * diffusionProfile, 2u);
+            radius            = sssData.subsurfaceMask;
-            dielectricF0      = _TransmissionTintsAndFresnel0[subsurfaceProfile].a;
+            dielectricF0      = _TransmissionTintsAndFresnel0[diffusionProfile].a;
-        FillMaterialIdSssData(subsurfaceProfile, radius, thickness, transmissionMode, bsdfData);
+        FillMaterialIdSssData(diffusionProfile, radius, thickness, transmissionMode, bsdfData);
     }
 
     float coatMask = 0.0;
 {
     if (bsdfData.materialId == MATERIALID_LIT_SSS)
     {
-        bsdfData.diffuseColor = ApplyDiffuseTexturingMode(bsdfData.diffuseColor, bsdfData.subsurfaceProfile);
+        bsdfData.diffuseColor = ApplyDiffuseTexturingMode(bsdfData.diffuseColor, bsdfData.diffusionProfile);
     }
 
     // Premultiply bake diffuse lighting information with DisneyDiffuse pre-integration
     {
         // Compute the thickness in world units along the normal.
         float thicknessInMeters = bsdfData.thickness * METERS_PER_MILLIMETER;
-        float thicknessInUnits  = thicknessInMeters * _WorldScales[bsdfData.subsurfaceProfile].y;
+        float thicknessInUnits  = thicknessInMeters * _WorldScales[bsdfData.diffusionProfile].y;
 
         // Compute the thickness in world units along the light vector.
         displacement = thicknessInUnits / -NdotL;
 
     float3 modifiedDiffuseColor;
     if (bsdfData.materialId == MATERIALID_LIT_SSS)
-        modifiedDiffuseColor = ApplyDiffuseTexturingMode(bsdfData.diffuseColor, bsdfData.subsurfaceProfile);
+        modifiedDiffuseColor = ApplyDiffuseTexturingMode(bsdfData.diffuseColor, bsdfData.diffusionProfile);
     else
         modifiedDiffuseColor = bsdfData.diffuseColor;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

         _Anisotropy("Anisotropy", Range(-1.0, 1.0)) = 0
         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
-        _SubsurfaceProfile("Subsurface Profile", Int) = 0
-        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadiusMap("Subsurface Radius Map", 2D) = "white" {}
+        _DiffusionProfile("Diffusion Profile", Int) = 0
+        _SubsurfaceMask("Subsurface Radius", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMaskMap("Subsurface Radius Map", 2D) = "white" {}
         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
         _ThicknessRemap("Thickness Remap", Vector) = (0, 1, 0, 0)
     #pragma shader_feature _TANGENTMAP
     #pragma shader_feature _ANISOTROPYMAP
     #pragma shader_feature _DETAIL_MAP
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP
+    #pragma shader_feature _SUBSURFACE_MASK_MAP
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _TRANSMITTANCECOLORMAP

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

 #define SAMPLER_MASKMAP_IDX sampler_MaskMap
 #define SAMPLER_HEIGHTMAP_IDX sampler_HeightMap
 
-#define SAMPLER_SUBSURFACE_RADIUSMAP_IDX sampler_SubsurfaceRadiusMap
+#define SAMPLER_SUBSURFACE_MASKMAP_IDX sampler_SubsurfaceMaskMap
 #define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap
 
 // include LitDataIndividualLayer to define GetSurfaceData
 #ifdef _DETAIL_MAP
 #define _DETAIL_MAP_IDX
 #endif
-#ifdef _SUBSURFACE_RADIUS_MAP
-#define _SUBSURFACE_RADIUS_MAP_IDX
+#ifdef _SUBSURFACE_MASK_MAP
+#define _SUBSURFACE_MASK_MAP_IDX
 #endif
 #ifdef _THICKNESSMAP
 #define _THICKNESSMAP_IDX

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

 #endif
     surfaceData.metallic *= ADD_IDX(_Metallic);
 
-    surfaceData.subsurfaceProfile = ADD_IDX(_SubsurfaceProfile);
-    surfaceData.subsurfaceRadius = ADD_IDX(_SubsurfaceRadius);
+    surfaceData.diffusionProfile = ADD_IDX(_DiffusionProfile);
+    surfaceData.subsurfaceMask = ADD_IDX(_SubsurfaceMask);
-#ifdef _SUBSURFACE_RADIUS_MAP_IDX
-    surfaceData.subsurfaceRadius *= SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_SubsurfaceRadiusMap), SAMPLER_SUBSURFACE_RADIUSMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
+#ifdef _SUBSURFACE_MASK_MAP_IDX
+    surfaceData.subsurfaceMask *= SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_SubsurfaceMaskMap), SAMPLER_SUBSURFACE_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).r;
 #endif
 
 #ifdef _THICKNESSMAP_IDX

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

 TEXTURE2D(_AnisotropyMap);
 SAMPLER(sampler_AnisotropyMap);
 
-TEXTURE2D(_SubsurfaceRadiusMap);
-SAMPLER(sampler_SubsurfaceRadiusMap);
+TEXTURE2D(_SubsurfaceMaskMap);
+SAMPLER(sampler_SubsurfaceMaskMap);
 TEXTURE2D(_ThicknessMap);
 SAMPLER(sampler_ThicknessMap);
 
 PROP_DECL_TEX2D(_DetailMap);
 PROP_DECL_TEX2D(_HeightMap);
 
-PROP_DECL_TEX2D(_SubsurfaceRadiusMap);
+PROP_DECL_TEX2D(_SubsurfaceMaskMap);
 PROP_DECL_TEX2D(_ThicknessMap);
 
 TEXTURE2D(_LayerMaskMap);
 
 float _Anisotropy;
 
-int   _SubsurfaceProfile;
-float _SubsurfaceRadius;
+int   _DiffusionProfile;
+float _SubsurfaceMask;
 float _Thickness;
 float4 _ThicknessRemap;
 
 PROP_DECL(float, _HeightAmplitude);
 PROP_DECL(float, _HeightCenter);
 
-PROP_DECL(int, _SubsurfaceProfile);
-PROP_DECL(float, _SubsurfaceRadius);
+PROP_DECL(int, _DiffusionProfile);
+PROP_DECL(float, _SubsurfaceMask);
 PROP_DECL(float, _Thickness);
 PROP_DECL(float4, _ThicknessRemap);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

         _Anisotropy("Anisotropy", Range(-1.0, 1.0)) = 0
         _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
 
-        _SubsurfaceProfile("Subsurface Profile", Int) = 0
-        _SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 1.0
-        _SubsurfaceRadiusMap("Subsurface Radius Map", 2D) = "white" {}
+        _DiffusionProfile("Diffusion Profile", Int) = 0
+        _SubsurfaceMask("Subsurface Radius", Range(0.0, 1.0)) = 1.0
+        _SubsurfaceMaskMap("Subsurface Radius Map", 2D) = "white" {}
         _Thickness("Thickness", Range(0.0, 1.0)) = 1.0
         _ThicknessMap("Thickness Map", 2D) = "white" {}
         _ThicknessRemap("Thickness Remap", Vector) = (0, 1, 0, 0)
     #pragma shader_feature _TANGENTMAP
     #pragma shader_feature _ANISOTROPYMAP
     #pragma shader_feature _DETAIL_MAP
-    #pragma shader_feature _SUBSURFACE_RADIUS_MAP
+    #pragma shader_feature _SUBSURFACE_MASK_MAP
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _TRANSMITTANCECOLORMAP

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.compute

     SSSData sssData;
     DECODE_FROM_SSSBUFFER(posInput.positionSS, sssData);
 
-    int    profileID   = sssData.subsurfaceProfile;
-    float  distScale   = sssData.subsurfaceRadius;
+    int    profileID   = sssData.diffusionProfile;
+    float  distScale   = sssData.subsurfaceMask;
     float3 shapeParam  = _ShapeParams[profileID].rgb;
     float  maxDistance = _ShapeParams[profileID].a;
 

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

 
 // Returns the modified albedo (diffuse color) for materials with subsurface scattering.
 // Ref: Advanced Techniques for Realistic Real-Time Skin Rendering.
-float3 ApplyDiffuseTexturingMode(float3 color, int subsurfaceProfile)
+float3 ApplyDiffuseTexturingMode(float3 color, int diffusionProfile)
 {
 #if defined(SHADERPASS) && (SHADERPASS == SHADERPASS_SUBSURFACE_SCATTERING)
     // If the SSS pass is executed, we know we have SSS enabled.
 
     if (enableSssAndTransmission)
     {
-        bool performPostScatterTexturing = IsBitSet(asuint(_TexturingModeFlags), subsurfaceProfile);
+        bool performPostScatterTexturing = IsBitSet(asuint(_TexturingModeFlags), diffusionProfile);
 
         if (performPostScatterTexturing)
         {
 struct SSSData
 {
     float3 diffuseColor;
-    float  subsurfaceRadius;
-    int    subsurfaceProfile;
+    float  subsurfaceMask;
+    int    diffusionProfile;
 };
 
 #define SSSBufferType0 float4
 // Note: The SSS buffer used here is sRGB
 void EncodeIntoSSSBuffer(SSSData sssData, uint2 positionSS, out SSSBufferType0 outSSSBuffer0)
 {
-    outSSSBuffer0 = float4(sssData.diffuseColor, PackFloatInt8bit(sssData.subsurfaceRadius, sssData.subsurfaceProfile, 16.0));
+    outSSSBuffer0 = float4(sssData.diffuseColor, PackFloatInt8bit(sssData.subsurfaceMask, sssData.diffusionProfile, 16.0));
 }
 
 // Note: The SSS buffer used here is sRGB
-    UnpackFloatInt8bit(sssBuffer.a, 16.0, sssData.subsurfaceRadius, sssData.subsurfaceProfile);
+    UnpackFloatInt8bit(sssBuffer.a, 16.0, sssData.subsurfaceMask, sssData.diffusionProfile);
 }
 
 void DecodeFromSSSBuffer(uint2 positionSS, out SSSData sssData)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.shader

                 SSSData sssData;
                 DECODE_FROM_SSSBUFFER(posInput.positionSS, sssData);
 
-                int    profileID   = sssData.subsurfaceProfile;
-                float  distScale   = sssData.subsurfaceRadius;
+                int    profileID   = sssData.diffusionProfile;
+                float  distScale   = sssData.subsurfaceMask;
                 float  maxDistance = _FilterKernelsBasic[profileID][SSS_BASIC_N_SAMPLES - 1].a;
 
                 // Take the first (central) sample.