Material Feature flags are now also used to statically remove code that is not needed in case there are 2 or more different materials in the same tile (thus preventing us from statically knowing the materialID)

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 // If a user do a lighting architecture without material classification, this can be remove
 #include "../../Lighting/TilePass/TilePass.cs.hlsl"
 
+static int g_FeatureFlags = 0xFFFFFFFF;
+
+// This method allows us to know at compile time what shader features should be removed from the code when the materialID cannot be known on the whole tile (any combination of 2 or more differnet materials in the same tile)
+bool HasMaterialFeatureFlag(int flag)
+{
+    return ((g_FeatureFlags & flag) != 0);
+}
+
 // Combination need to be define in increasing "comlexity" order as define by FeatureFlagsToTileVariant
 static const uint kFeatureVariantFlags[NUM_FEATURE_VARIANTS] =
 {
         bsdfData.diffuseColor = surfaceData.baseColor;
         bsdfData.fresnel0 = surfaceData.specularColor;
     }
-    else if (bsdfData.materialId == MATERIALID_LIT_SSS)
+    else if (bsdfData.materialId == MATERIALID_LIT_SSS && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_SSS))
-    else if (bsdfData.materialId == MATERIALID_LIT_ANISO)
+    else if (bsdfData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
-    else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
+    else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         // When using clear coat we assume that bottom layer is regular
         FillMaterialIdStandardData(surfaceData.baseColor, surfaceData.metallic, bsdfData);
         outGBuffer1.a = PackMaterialId(MATERIALID_LIT_STANDARD); // Encode MATERIALID_LIT_SPECULAR as MATERIALID_LIT_STANDARD + GBUFFER_LIT_STANDARD_SPECULAR_COLOR_ID value in GBuffer2
         outGBuffer2 = float4(surfaceData.specularColor, PackFloatInt8bit(0.0, GBUFFER_LIT_STANDARD_SPECULAR_COLOR_ID, 4.0));
     }
-    else if (surfaceData.materialId == MATERIALID_LIT_SSS)
+    else if (surfaceData.materialId == MATERIALID_LIT_SSS && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_SSS))
-    else if (surfaceData.materialId == MATERIALID_LIT_ANISO)
+    else if (surfaceData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
-    else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT)
+    else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         // In the cae of clear coat, we want more precision for the coat normal than for the bottom normal (as it is expected to be smooth). So swap the normal encoding storage in Gbuffer.
         // It also allow to use clear coat normal for SSR
 {
     ZERO_INITIALIZE(BSDFData, bsdfData);
 
+    g_FeatureFlags = featureFlags;
+
 #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
     float4 inGBuffer0, inGBuffer1, inGBuffer2, inGBuffer3;
 
     // The material features system for material classification must allow compile time optimization (i.e everything should be static)
     // Note that as we store materialId for Aniso based on content of RT2 we need to add few extra condition.
     // The code is also call from MaterialFeatureFlagsFromGBuffer, so must work fully dynamic if featureFlags is 0xFFFFFFFF
-    int supportsStandard = (featureFlags & MATERIALFEATUREFLAGS_LIT_STANDARD) != 0;
-    int supportsSSS = (featureFlags & MATERIALFEATUREFLAGS_LIT_SSS) != 0;
-    int supportsAniso = (featureFlags & MATERIALFEATUREFLAGS_LIT_ANISO) != 0;
-    int supportClearCoat = (featureFlags & MATERIALFEATUREFLAGS_LIT_CLEAR_COAT) != 0;
+    int supportsStandard = (g_FeatureFlags & MATERIALFEATUREFLAGS_LIT_STANDARD) != 0;
+    int supportsSSS = (g_FeatureFlags & MATERIALFEATUREFLAGS_LIT_SSS) != 0;
+    int supportsAniso = (g_FeatureFlags & MATERIALFEATUREFLAGS_LIT_ANISO) != 0;
+    int supportClearCoat = (g_FeatureFlags & MATERIALFEATUREFLAGS_LIT_CLEAR_COAT) != 0;
 
     if (supportsStandard + supportsSSS + supportsAniso + supportClearCoat > 1)
     {
             FillMaterialIdStandardData(baseColor, metallic, bsdfData);
         }
     }
-    else if (bsdfData.materialId == MATERIALID_LIT_SSS)
+    else if (bsdfData.materialId == MATERIALID_LIT_SSS && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_SSS))
     {
         float subsurfaceRadius  = inGBuffer2.x;
         float thickness         = inGBuffer2.y;
     }
-    else if (bsdfData.materialId == MATERIALID_LIT_ANISO)
+    else if (bsdfData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
     {
         float metallic;
         int unused;
         float anisotropy = inGBuffer2.b;
         FillMaterialIdAnisoData(bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
     }
-    else //if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
+    else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         // We have swap the encoding of the normal to have more precision for coat normal as it is more smooth
         float3 coatNormalWS = bsdfData.normalWS;
     // GGX aniso
     preLightData.TdotV = 0.0;
     preLightData.BdotV = 0.0;
-    if (bsdfData.materialId == MATERIALID_LIT_ANISO)
+    if (bsdfData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
     {
         preLightData.TdotV = dot(bsdfData.tangentWS, V);
         preLightData.BdotV = dot(bsdfData.bitangentWS, V);
     // IBL
     GetPreIntegratedFGD(NdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
 
-    if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
+    if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         // Update the roughness and the IBL miplevel
         // Bottom layer is affected by upper layer BRDF, result can't be more sharp than input (it is to mimic what a path tracer will do)
     float Vis;
     float D;
 
-    if (bsdfData.materialId == MATERIALID_LIT_ANISO)
+    if (bsdfData.materialId == MATERIALID_LIT_ANISO && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO))
     {
         float3 H = (L + V) * invLenLV;
         // For anisotropy we must not saturate these values