Remove transmission mode, now there is only two (and no none mode)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/DiffusionProfile/DiffusionProfileSettingsEditor.cs

             var S = obj.shapeParam;
             var T = (Vector4)profile.transmissionTint.colorValue;
             var R = profile.thicknessRemap.vector2Value;
-            bool transmissionEnabled = profile.transmissionMode.intValue != (int)DiffusionProfile.TransmissionMode.None;
 
             m_ProfileMaterial.SetFloat(HDShaderIDs._MaxRadius, r);
             m_ProfileMaterial.SetVector(HDShaderIDs._ShapeParam, S);
             // <<< Old SSS Model
 
             m_TransmittanceMaterial.SetVector(HDShaderIDs._ShapeParam, S);
-            m_TransmittanceMaterial.SetVector(HDShaderIDs._TransmissionTint, transmissionEnabled ? T : Vector4.zero);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._TransmissionTint, T);
             m_TransmittanceMaterial.SetVector(HDShaderIDs._ThicknessRemap, R);
 
             // Draw the transmittance graph.

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

             CoreUtils.SetKeyword(material, "_DENSITY_MODE", useDensityModeEnable);
 
             BaseLitGUI.MaterialId materialId = (BaseLitGUI.MaterialId)material.GetFloat(kMaterialID);
+            BaseLitGUI.SSSAndTransmissionType sssAndTransmissionType = (BaseLitGUI.SSSAndTransmissionType)material.GetFloat(kSSSAndTransmissionType);
-            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission);
-            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission);
+            if (materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission)
+            {
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSOnly);
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitTransmissionOnly);
+            }
+            else
+            {
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", false);
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", false);
+            }
         }
 
         public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)

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

             public static GUIContent enableMotionVectorForVertexAnimationText = new GUIContent("Enable MotionVector For Vertex Animation", "This will enable an object motion vector pass for this material. Useful if wind animation is enabled or if displacement map is animated");
 
             // Material ID
-            public static GUIContent materialIDText = new GUIContent("Material type", "Subsurface Scattering: enable for translucent materials such as skin, vegetation, fruit, marble, wax and milk.");
+            public static GUIContent materialIDText = new GUIContent("Material type", "Select a material feature to enable on top of regular material");
+            public static GUIContent SSSAndTransmissionTypeText = new GUIContent("SSS and Transmission type", "Subsurface Scattering for translucent materials such as skin, vegetation, fruit, marble, wax and milk., Transmission for back lighting");
 
             // Per pixel displacement
             public static GUIContent ppdMinSamplesText = new GUIContent("Minimum steps", "Minimum steps (texture sample) to use with per pixel displacement mapping");
             LitSpecular = 4
         };
 
+        public enum SSSAndTransmissionType
+        {
+            LitSSSAndTransmission = 0,
+            LitSSSOnly = 1,
+            LitTransmissionOnly = 2,
+        };
+
         public enum HeightmapParametrization
         {
             MinMax = 0,
         // Properties
         // Material ID
         protected MaterialProperty materialID  = null;
-        protected const string     kMaterialID = "_MaterialID";
+        protected const string kMaterialID = "_MaterialID";
+        protected MaterialProperty sssAndTransmissionType = null;
+        protected const string kSSSAndTransmissionType = "_SSSAndTransmissionType";        
 
         protected const string kStencilRef = "_StencilRef";
         protected const string kStencilWriteMask = "_StencilWriteMask";
 
             // MaterialID
             materialID = FindProperty(kMaterialID, props);
+            sssAndTransmissionType = FindProperty(kSSSAndTransmissionType, props);      
 
             displacementMode = FindProperty(kDisplacementMode, props);
             displacementLockObjectScale = FindProperty(kDisplacementLockObjectScale, props);
             }
 
             m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
+
+            if ((int)materialID.floatValue == (int)BaseLitGUI.MaterialId.LitSSSAndTransmission)
+            {
+                m_MaterialEditor.ShaderProperty(sssAndTransmissionType, StylesBaseLit.SSSAndTransmissionTypeText);                
+            }                
 
             m_MaterialEditor.ShaderProperty(supportDBuffer, StylesBaseLit.supportDBufferText);
 
             int stencilRef = (int)StencilLightingUsage.RegularLighting;
             if ((int)material.GetFloat(kMaterialID) == (int)BaseLitGUI.MaterialId.LitSSSAndTransmission)
             {
-                stencilRef = (int)StencilLightingUsage.SplitLighting;
+                if ((int)material.GetFloat(kSSSAndTransmissionType) == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission ||
+                    (int)material.GetFloat(kSSSAndTransmissionType) == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSOnly)
+                {
+                    stencilRef = (int)StencilLightingUsage.SplitLighting;
+                }
             }
             // As we tag both during velocity pass and Gbuffer pass we need a separate state and we need to use the write mask
             material.SetInt(kStencilRef, stencilRef);

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

             EditorGUI.indentLevel--;
         }
 
-        protected void ShaderSSSInputGUI(Material material, int layerIndex)
+        protected void ShaderSSSAndTransmissionInputGUI(Material material, int layerIndex)
         {
             var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
             var diffusionProfileSettings = hdPipeline.diffusionProfileSettings;
                     diffusionProfileID[layerIndex].floatValue = profileID;
             }
 
-            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)
+            if ((int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || (int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSOnly)
+            {
+                m_MaterialEditor.ShaderProperty(subsurfaceMask[layerIndex], Styles.subsurfaceMaskText);
+                m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceMaskMapText, subsurfaceMaskMap[layerIndex]);
+            }
+
+            if ((int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || (int)sssAndTransmissionType.floatValue == (int)BaseLitGUI.SSSAndTransmissionType.LitTransmissionOnly)
-                // Display the remap of texture values.
-                Vector2 remap = thicknessRemap[layerIndex].vectorValue;
-                EditorGUI.BeginChangeCheck();
-                EditorGUILayout.MinMaxSlider(Styles.thicknessRemapText, ref remap.x, ref remap.y, 0.0f, 1.0f);
-                if (EditorGUI.EndChangeCheck())
+                m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap[layerIndex]);
+                if (thicknessMap[layerIndex].textureValue != null)
+                {
+                    // Display the remap of texture values.
+                    Vector2 remap = thicknessRemap[layerIndex].vectorValue;
+                    EditorGUI.BeginChangeCheck();
+                    EditorGUILayout.MinMaxSlider(Styles.thicknessRemapText, ref remap.x, ref remap.y, 0.0f, 1.0f);
+                    if (EditorGUI.EndChangeCheck())
+                    {
+                        thicknessRemap[layerIndex].vectorValue = remap;
+                    }
+                }
+                else
-                    thicknessRemap[layerIndex].vectorValue = remap;
+                    // Allow the user to set the constant value of thickness if no thickness map is provided.
+                    m_MaterialEditor.ShaderProperty(thickness[layerIndex], Styles.thicknessText);
-            }
-            else
-            {
-                // Allow the user to set the constant value of thickness if no thickness map is provided.
-                m_MaterialEditor.ShaderProperty(thickness[layerIndex], Styles.thicknessText);
             }
         }
 
             switch ((BaseLitGUI.MaterialId)materialID.floatValue)
             {
                 case BaseLitGUI.MaterialId.LitSSSAndTransmission:
-                    ShaderSSSInputGUI(material, layerIndex);
+                    ShaderSSSAndTransmissionInputGUI(material, layerIndex);
                     break;
                 case BaseLitGUI.MaterialId.LitStandard:
                     // Nothing
             }
 
             BaseLitGUI.MaterialId materialId = (BaseLitGUI.MaterialId)material.GetFloat(kMaterialID);
+            BaseLitGUI.SSSAndTransmissionType sssAndTransmissionType = (BaseLitGUI.SSSAndTransmissionType)material.GetFloat(kSSSAndTransmissionType);
-            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission);
-            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission);
+            if (materialId == BaseLitGUI.MaterialId.LitSSSAndTransmission)
+            {
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSOnly);
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitSSSAndTransmission || sssAndTransmissionType == BaseLitGUI.SSSAndTransmissionType.LitTransmissionOnly);
+            }
+            else
+            {
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", false);
+                CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", false);
+            }
+
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_ANISOTROPY", materialId == BaseLitGUI.MaterialId.LitAniso);
             // No material Id for clear coat, just test the attribute
             CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_CLEAR_COAT", material.GetFloat(kCoatMask) > 0.0 || material.GetTexture(kCoatMaskMap));

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/DiffusionProfile/DiffusionProfileSettings.cs

         public const int SSS_N_SAMPLES_NEAR_FIELD       = 55; // Used for extreme close ups; must be a Fibonacci number
         public const int SSS_N_SAMPLES_FAR_FIELD        = 21; // Used at a regular distance; must be a Fibonacci number
         public const int SSS_LOD_THRESHOLD              = 4;  // The LoD threshold of the near-field kernel (in pixels)
-        public const int TRANSMISSION_MODE_NONE         = 0;
-        public const int TRANSMISSION_MODE_THIN         = 1;
         // Old SSS Model >>>
         public const int SSS_BASIC_N_SAMPLES      = 11; // Must be an odd number
         public const int SSS_BASIC_DISTANCE_SCALE = 3;  // SSS distance units per centimeter
 
         public enum TransmissionMode : uint
         {
-            None = DiffusionProfileConstants.TRANSMISSION_MODE_NONE,
-            ThinObject = DiffusionProfileConstants.TRANSMISSION_MODE_THIN,
-            Regular
+            Regular = 0,
+            ThinObject = 1
         }
 
         public string name;
             scatteringDistance = Color.grey;
             transmissionTint   = Color.white;
             texturingMode      = TexturingMode.PreAndPostScatter;
-            transmissionMode   = TransmissionMode.None;
+            transmissionMode   = TransmissionMode.ThinObject;
             thicknessRemap     = new Vector2(0f, 5f);
             worldScale         = 1f;
             ior                = 1.4f; // TYpical value for skin specular reflectance
             // Erase previous value (This need to be done here individually as in the SSS editor we edit individual component)
             uint mask = 1u << i;
             texturingModeFlags &= ~mask;
-            mask = 3u << i * 2;
+            mask = 1u << i;
-            transmissionFlags  |= (uint)profiles[p].transmissionMode << i * 2;
+            transmissionFlags  |= (uint)profiles[p].transmissionMode << i;
 
             thicknessRemaps[i]   = new Vector4(profiles[p].thicknessRemap.x, profiles[p].thicknessRemap.y - profiles[p].thicknessRemap.x, 0f, 0f);
             worldScales[i]       = new Vector4(profiles[p].worldScale, 1.0f / profiles[p].worldScale, 0f, 0f);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/DiffusionProfile/DiffusionProfileSettings.cs.hlsl

 #define SSS_N_SAMPLES_NEAR_FIELD (55)
 #define SSS_N_SAMPLES_FAR_FIELD (21)
 #define SSS_LOD_THRESHOLD (4)
-#define TRANSMISSION_MODE_NONE (0)
-#define TRANSMISSION_MODE_THIN (1)
 #define SSS_BASIC_N_SAMPLES (11)
 #define SSS_BASIC_DISTANCE_SCALE (3)
 

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

 
         // For layering, due to combinatorial explosion, we only support SSS/Transmission and Standard. We let other case for the shader graph
         [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
+        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
 
         [Enum(None, 0, Vertex displacement, 1, Pixel displacement, 2)] _DisplacementMode("DisplacementMode", Int) = 0
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0

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

     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
 #endif
 #ifdef _MATERIAL_FEATURE_TRANSMISSION
-    // TEMP: The UI must control if we have transmission or not.
-    // Currently until we update the UI, this is control in the diffusion profile
-    uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u * surfaceData.diffusionProfile, 2u);
-    // Caution: Because of this dynamic test we don't know anymore statically if we have transmission, which mess with performance.
-    // in deferred case as we still have both sss and transmission until we update the UI it should be the same perf
-    if (transmissionMode != TRANSMISSION_MODE_NONE)
-    {
-        surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
-    }
+    surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
 #endif
 
     // Init other parameters

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

 
         // For layering, due to combinatorial explosion, we only support SSS/Transmission and Standard. We let other case for the shader graph
         [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
+        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
 
         [Enum(None, 0, Tessellation displacement, 3)] _DisplacementMode("DisplacementMode", Int) = 3
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0

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

     bsdfData.fresnel0 = _TransmissionTintsAndFresnel0[diffusionProfile].a;
 
     bsdfData.thickness = _ThicknessRemaps[diffusionProfile].x + _ThicknessRemaps[diffusionProfile].y * thickness;
-    uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u * diffusionProfile, 2u);
-
+ 
 #if SHADEROPTIONS_USE_DISNEY_SSS
     bsdfData.transmittance = ComputeTransmittanceDisney(    _ShapeParams[diffusionProfile].rgb,
                                                             _TransmissionTintsAndFresnel0[diffusionProfile].rgb,
                                                             bsdfData.thickness);
 #endif
 
-    // Apply the transmission mode. Only the thick object mode performs the thickness displacement.
-    bsdfData.useThickObjectMode = transmissionMode != TRANSMISSION_MODE_THIN;
+    bsdfData.useThickObjectMode = !IsBitSet(asuint(_TransmissionFlags), diffusionProfile);
 
     if (bsdfData.useThickObjectMode)
     {

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

         // so we use this enum as "material ID" which can be interpreted as preset of bitfield of material feature
         // The only material feature flag that can be added in all cases is clear coat
         [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1, Anisotropy, 2, Iridescence, 3, Specular Color, 4)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
+        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
 
         [Enum(None, 0, Vertex displacement, 1, Pixel displacement, 2)] _DisplacementMode("DisplacementMode", Int) = 0
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0

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

     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
 #endif
 #ifdef _MATERIAL_FEATURE_TRANSMISSION
-    // TEMP: The UI must control if we have transmission or not.
-    // Currently until we update the UI, this is control in the diffusion profile
-    uint transmissionMode = BitFieldExtract(asuint(_TransmissionFlags), 2u * surfaceData.diffusionProfile, 2u);
-    // Caution: Because of this dynamic test we don't know anymore statically if we have transmission, which mess with performance.
-    // in deferred case as we still have both sss and transmission until we update the UI it should be the same perf
-    if (transmissionMode != TRANSMISSION_MODE_NONE)
-    {
-        surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
-    }
+    surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
 #endif
 #ifdef _MATERIAL_FEATURE_ANISOTROPY
     surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;

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

         // so we use this enum as "material ID" which can be interpreted as preset of bitfield of material feature
         // The only material feature flag that can be added in all cases is clear coat
         [Enum(Subsurface Scattering and Transmissison, 0, Standard, 1, Anisotropy, 2, Iridescence, 3, Specular Color, 4)] _MaterialID("MaterialId", Int) = 1 // MaterialId.Standard
-
+        [Enum(Both, 0, SSS only, 1, Transmission only, 2)] _SSSAndTransmissionType("SSSandTransmissionType", Int) = 0 // SSSandTransmissionType.Both
 
         [Enum(None, 0, Tessellation displacement, 3)] _DisplacementMode("DisplacementMode", Int) = 3
         [ToggleUI] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0