Rename "transmittance" to "transmission" where applicable

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             }
 
             // Broadcast SSS parameters to all shaders.
-            Shader.SetGlobalInt("_TransmittanceFlags", sssParameters.transmittanceFlags);
+            Shader.SetGlobalInt("_TransmissionFlags", sssParameters.transmissionFlags);
             Shader.SetGlobalFloatArray("_ThicknessScales", sssParameters.thicknessScales);
             Shader.SetGlobalVectorArray("_HalfRcpVariancesAndLerpWeights", sssParameters.halfRcpVariancesAndLerpWeights);
 

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

             public float   subsurfaceRadius;
             public float   thickness;
             public int     subsurfaceProfile;
-            public bool    enableTransmittance;
+            public bool    enableTransmission;
             public Vector3 transmittance;
 
             // Clearcoat

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

 	float subsurfaceRadius;
 	float thickness;
 	int subsurfaceProfile;
-	bool enableTransmittance;
+	bool enableTransmission;
 	float3 transmittance;
 	float3 coatNormalWS;
 	float coatRoughness;

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

 
 // SSS parameters
 #define N_PROFILES 8
-uint   _TransmittanceFlags;                            // One bit per profile; 1 = enabled
+uint   _TransmissionFlags;                             // One bit per profile; 1 = enabled
 float  _ThicknessScales[N_PROFILES];
 float4 _HalfRcpVariancesAndLerpWeights[N_PROFILES][2]; // 2x Gaussians per color channel, A is the the associated interpolation weight
 
         bsdfData.subsurfaceProfile = surfaceData.subsurfaceProfile;
         bsdfData.subsurfaceRadius  = surfaceData.subsurfaceRadius * 0.01;
         bsdfData.thickness         = surfaceData.thickness * 0.01 * _ThicknessScales[bsdfData.subsurfaceProfile];
-        bsdfData.enableTransmittance = (1 << bsdfData.subsurfaceProfile) & _TransmittanceFlags;
-        if (bsdfData.enableTransmittance)
+        bsdfData.enableTransmission = (1 << bsdfData.subsurfaceProfile) & _TransmissionFlags;
+        if (bsdfData.enableTransmission)
         {
             bsdfData.transmittance = ComputeTransmittance(_HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].xyz,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
         bsdfData.subsurfaceProfile = inGBuffer2.a * 8.0;
         bsdfData.subsurfaceRadius  = inGBuffer2.r * 0.01;
         bsdfData.thickness         = inGBuffer2.g * 0.01 * _ThicknessScales[bsdfData.subsurfaceProfile];
-        bsdfData.enableTransmittance = (1 << bsdfData.subsurfaceProfile) & _TransmittanceFlags;
-        if (bsdfData.enableTransmittance)
+        bsdfData.enableTransmission = (1 << bsdfData.subsurfaceProfile) & _TransmissionFlags;
+        if (bsdfData.enableTransmission)
         {
             bsdfData.transmittance = ComputeTransmittance(_HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].xyz,
                                                           _HalfRcpVariancesAndLerpWeights[bsdfData.subsurfaceProfile][0].w,
         specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
     }
 
-    [branch] if (bsdfData.enableTransmittance)
+    [branch] if (bsdfData.enableTransmission)
     {
         // Reverse the normal.
         illuminance = saturate(dot(-bsdfData.normalWS, L));
         specularLighting *= (cookie.rgb * lightData.color) * (illuminance * lightData.specularScale);
     }
 
-    [branch] if (bsdfData.enableTransmittance)
+    [branch] if (bsdfData.enableTransmission)
     {
         // Reverse the normal.
         illuminance = saturate(dot(-bsdfData.normalWS, L)) * attenuation;

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/SubsurfaceScatteringParameters.cs

         [SerializeField]
         public float lerpWeight;
         [SerializeField]
-        public bool  enableTransmittance;
+        public bool  enableTransmission;
         [SerializeField]
         public float thicknessScale;
         [SerializeField] [HideInInspector]
 
         public SubsurfaceScatteringProfile()
         {
-            stdDev1             = new Color(0.3f, 0.3f, 0.3f, 0.0f);
-            stdDev2             = new Color(0.6f, 0.6f, 0.6f, 0.0f);
-            lerpWeight          = 0.5f;
-            enableTransmittance = false;
-            thicknessScale      = 3.0f;
+            stdDev1            = new Color(0.3f, 0.3f, 0.3f, 0.0f);
+            stdDev2            = new Color(0.6f, 0.6f, 0.6f, 0.0f);
+            lerpWeight         = 0.5f;
+            enableTransmission = false;
+            thicknessScale     = 3.0f;
 
             UpdateKernelAndVarianceData();
         }
         [SerializeField]
         int                           m_NumProfiles;
         [SerializeField]
-        int                           m_TransmittanceFlags;
+        int                           m_TransmissionFlags;
         [SerializeField]
         SubsurfaceScatteringProfile[] m_Profiles;
         [SerializeField]
         }
 
         // Returns a bit mask s.t. the i-th bit indicates whether the i-th profile requires transmittance evaluation.
-        // Supplies '_TransmittanceFlags' to Lit.hlsl.
-        public int transmittanceFlags {
+        // Supplies '_TransmissionFlags' to Lit.hlsl.
+        public int transmissionFlags {
-            get { return m_TransmittanceFlags; }
+            get { return m_TransmissionFlags; }
         }
 
         // Supplies '_ThicknessScales' to Lit.hlsl.
             }
 
             m_NumProfiles        = m_Profiles.Length;
-            m_TransmittanceFlags = 0;
+            m_TransmissionFlags = 0;
 
             if (m_ThicknessScales == null)
             {
 
             for (int i = 0; i < m_NumProfiles; i++)
             {
-                m_TransmittanceFlags |= (m_Profiles[i].enableTransmittance ? 1 : 0) << i;
+                m_TransmissionFlags |= (m_Profiles[i].enableTransmission ? 1 : 0) << i;
 
                 c.r = Mathf.Clamp(m_Profiles[i].stdDev1.r, 0.05f, 2.0f);
                 c.g = Mathf.Clamp(m_Profiles[i].stdDev1.g, 0.05f, 2.0f);
             public readonly GUIContent profileStdDev1        = new GUIContent("Standard deviation #1", "Determines the shape of the 1st Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
             public readonly GUIContent profileStdDev2        = new GUIContent("Standard deviation #2", "Determines the shape of the 2nd Gaussian filter. Increases the strength and the radius of the blur of the corresponding color channel.");
             public readonly GUIContent profileLerpWeight     = new GUIContent("Filter interpolation",  "Controls linear interpolation between the two Gaussian filters.");
-            public readonly GUIContent profileTransmittance  = new GUIContent("Enable transmittance",  "Toggles simulation of light passing through thin objects. Depends on the thickness of the material.");
+            public readonly GUIContent profileTransmission   = new GUIContent("Enable transmission",   "Toggles simulation of light passing through thin objects. Depends on the thickness of the material.");
             public readonly GUIContent profileThicknessScale = new GUIContent("Thickness scale",       "Linearly scales the object thickness which affects the amount of transmitted lighting.");
         }
 
                         SerializedProperty profileStdDev1        = profile.FindPropertyRelative("stdDev1");
                         SerializedProperty profileStdDev2        = profile.FindPropertyRelative("stdDev2");
                         SerializedProperty profileLerpWeight     = profile.FindPropertyRelative("lerpWeight");
-                        SerializedProperty profileTransmittance  = profile.FindPropertyRelative("enableTransmittance");
+                        SerializedProperty profileTransmission   = profile.FindPropertyRelative("enableTransmission");
-                        EditorGUILayout.PropertyField(profileTransmittance,  styles.profileTransmittance);
+                        EditorGUILayout.PropertyField(profileTransmission,   styles.profileTransmission);
                         EditorGUILayout.PropertyField(profileThicknessScale, styles.profileThicknessScale);
 
                         EditorGUILayout.Space();