HDRenderPipeline: Move material flags to Lit.hlsl as they are related to the defered material

Remove FeatureFlags file and move them to Lit.hlsl as they are related
to the material, so each deferred material can define its own
"optimization" with material classification. also the material know the
cost of light features. + simplify code of gettings material features

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

         [GenerateHLSL]
         public enum LightFeatureFlags
         {
-            Punctual    = 1 << 0,
-            Area        = 1 << 1,
-            Directional = 1 << 2,
-            Env         = 1 << 3,
-            Sky         = 1 << 4
+            // Light bit mask must match LightDefinitions.s_LightFeatureMaskFlags value
+            Punctual    = 1 << 8,
+            Area        = 1 << 9,
+            Directional = 1 << 10,
+            Env         = 1 << 11,
+            Sky         = 1 << 12  // If adding more light be sure to not overflow LightDefinitions.s_LightFeatureMaskFlags
         }
 
         [GenerateHLSL]
             // feature variants
             public static int s_NumFeatureVariants = 16;
 
-            public static uint LIGHTFEATUREFLAGS_MASK = 0xFFF;
-            public static uint MATERIALFEATUREFLAGS_MASK = 0xF000;   // don't use all bits just to be safe from signed and/or float conversions :/
+            // Following define the maximum number of bits use in each feature category.
+            public static uint s_LightFeatureMaskFlags = 0xFF00;
+            public static uint s_MaterialFeatureMaskFlags = 0x00FF;   // don't use all bits just to be safe from signed and/or float conversions :/
         }
 
         [GenerateHLSL]
                         }
                         if (!m_TileSettings.enableComputeMaterialVariants)
                         {
-                            baseFeatureFlags |= LightDefinitions.MATERIALFEATUREFLAGS_MASK;
+                            baseFeatureFlags |= LightDefinitions.s_MaterialFeatureMaskFlags;
                         }
                         cmd.SetComputeIntParam(buildPerTileLightListShader, "g_BaseFeatureFlags", (int)baseFeatureFlags);
                         cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_TileFeatureFlags", s_TileFeatureFlags);
                         if (!m_TileSettings.enableComputeLightVariants)
                         {
                             buildMaterialFlagsKernel = s_BuildMaterialFlagsWriteKernel;
-                            baseFeatureFlags |= LightDefinitions.LIGHTFEATUREFLAGS_MASK;
+                            baseFeatureFlags |= LightDefinitions.s_LightFeatureMaskFlags;
                         }
 
                         cmd.SetComputeIntParam(buildMaterialFlagsShader, "g_BaseFeatureFlags", (int)baseFeatureFlags);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightFeatureFlags:  static fields
 //
-#define LIGHTFEATUREFLAGS_PUNCTUAL (1)
-#define LIGHTFEATUREFLAGS_AREA (2)
-#define LIGHTFEATUREFLAGS_DIRECTIONAL (4)
-#define LIGHTFEATUREFLAGS_ENV (8)
-#define LIGHTFEATUREFLAGS_SKY (16)
+#define LIGHTFEATUREFLAGS_PUNCTUAL (256)
+#define LIGHTFEATUREFLAGS_AREA (512)
+#define LIGHTFEATUREFLAGS_DIRECTIONAL (1024)
+#define LIGHTFEATUREFLAGS_ENV (2048)
+#define LIGHTFEATUREFLAGS_SKY (4096)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightDefinitions:  static fields
 #define TILE_SIZE_FPTL (16)
 #define TILE_SIZE_CLUSTERED (32)
 #define NUM_FEATURE_VARIANTS (16)
-#define LIGHTFEATUREFLAGS_MASK (4095)
-#define MATERIALFEATUREFLAGS_MASK (61440)
+#define LIGHT_FEATURE_MASK_FLAGS (65280)
+#define MATERIAL_FEATURE_MASK_FLAGS (255)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.TilePass.SFiniteLightBound
 // PackingRules = Exact

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/builddispatchindirect.compute

 #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
 #include "../../Material/Material.hlsl" // This includes Material.hlsl
 
-#include "FeatureFlags.hlsl"
-
 RWBuffer<uint> g_DispatchIndirectBuffer : register( u0 );	// Indirect arguments have to be in a _buffer_, not a structured buffer
 RWStructuredBuffer<uint> g_TileList;
 StructuredBuffer<uint> g_TileFeatureFlags;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/materialflags.compute

 
 #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
 #include "../../Material/Material.hlsl" // This includes Material.hlsl
-#include "FeatureFlags.hlsl"
 
 #define USE_MATERIAL_FEATURE_FLAGS
 #define NR_THREADS	64

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/shadeopaque.compute

 #include "../../ShaderConfig.cs.hlsl"
 #include "../../ShaderVariables.hlsl"
 #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
-#include "../../Lighting/TilePass/FeatureFlags.hlsl"
+
 //-------------------------------------------------------------------------------------
 // variable declaration
 //-------------------------------------------------------------------------------------

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

             LitSpecular = 5, // Should be the last as it is not setup by the users but generated based on anisotropy property and specular
         };
 
+        // If change, be sure it match what is done in Lit.hlsl: MaterialFeatureFlagsFromGBuffer
+        // Material bit mask must match LightDefinitions.s_MaterialFeatureMaskFlags value
-            LitSSS      = 1 << 12,
-            LitStandard = 1 << 13,
-            LitAniso    = 1 << 14,
-            LitSpecular = 1 << 15
-        }
+            LitSSS      = 1 << MaterialId.LitSSS,
+            LitStandard = 1 << MaterialId.LitStandard,
+            LitUnused0  = 1 << MaterialId.LitUnused0,
+            LitUnused1  = 1 << MaterialId.LitUnused1,
+            LitAniso    = 1 << MaterialId.LitAniso,
+            LitSpecular = 1 << MaterialId.LitSpecular,
+        };
 
         [GenerateHLSL]
         public enum SpecularValue

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

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+MaterialFeatureFlags:  static fields
 //
-#define MATERIALFEATUREFLAGS_LIT_SSS (4096)
-#define MATERIALFEATUREFLAGS_LIT_STANDARD (8192)
-#define MATERIALFEATUREFLAGS_LIT_ANISO (16384)
-#define MATERIALFEATUREFLAGS_LIT_SPECULAR (32768)
+#define MATERIALFEATUREFLAGS_LIT_SSS (1)
+#define MATERIALFEATUREFLAGS_LIT_STANDARD (2)
+#define MATERIALFEATUREFLAGS_LIT_UNUSED0 (4)
+#define MATERIALFEATUREFLAGS_LIT_UNUSED1 (8)
+#define MATERIALFEATUREFLAGS_LIT_ANISO (16)
+#define MATERIALFEATUREFLAGS_LIT_SPECULAR (32)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+SpecularValue:  static fields

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

 CBUFFER_END
 
 //-----------------------------------------------------------------------------
+// Ligth and material classification for the deferred rendering path
+// Configure what kind of combination is supported
+//-----------------------------------------------------------------------------
+
+// Only include material classification code if it it requested. Just check LIGHTFEATUREFLAGS_MASK define for this
+#ifdef LIGHTFEATUREFLAGS_MASK
+
+// Combination need to be define in increasing "comlexity" order as define by FeatureFlagsToTileVariant
+static const uint kFeatureVariantFlags[NUM_FEATURE_VARIANTS] =
+{
+    // Standard
+    /*  0 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_STANDARD
+    /*  1 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_STANDARD
+    /*  2 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD
+    /*  3 */ LIGHTFEATUREFLAGS_MASK | MATERIALFEATUREFLAGS_LIT_STANDARD
+
+    // SSS
+    /*  4 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_SSS
+    /*  5 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_SSS
+    /*  6 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS
+    /*  7 */ LIGHTFEATUREFLAGS_MASK | MATERIALFEATUREFLAGS_LIT_SSS
+
+    // Specular/Aniso
+    /*  8 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_ANISO | MATERIALFEATUREFLAGS_LIT_SPECULAR
+    /*  9 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_ANISO | MATERIALFEATUREFLAGS_LIT_SPECULAR
+    /*  10 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_ANISO | MATERIALFEATUREFLAGS_LIT_SPECULAR
+    /*  11 */ LIGHTFEATUREFLAGS_MASK | MATERIALFEATUREFLAGS_LIT_ANISO | MATERIALFEATUREFLAGS_LIT_SPECULAR
+
+    // Future usage
+    /*  12 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_UNUSED0
+    /*  13 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_UNUSED0
+    /*  14 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED0
+    ///*  15 */ LIGHTFEATUREFLAGS_MASK | MATERIALFEATUREFLAGS_LIT_UNUSED0
+    /* 15 */ 0xFFFFFFFF // LIGHTFEATUREFLAGS_MASK | MATERIALFEATUREFLAGS_MASK, // Catch all case, but should not be needed
+};
+
+uint FeatureFlagsToTileVariant(uint featureFlags)
+{
+    for (int i = 0; i < NUM_FEATURE_VARIANTS; i++)
+    {
+        if ((featureFlags & kFeatureVariantFlags[i]) == featureFlags)
+            return i;
+    }
+    return NUM_FEATURE_VARIANTS - 1;
+}
+
+// This function need to return a compile time value, else there is no optimization
+uint TileVariantToFeatureFlags(uint variant)
+{
+    return kFeatureVariantFlags[variant];
+}
+
+#endif // LIGHTFEATUREFLAGS_MASK
+
+//-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
 //-----------------------------------------------------------------------------
 
 #endif
 )
 {
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    float4 inGBuffer0, inGBuffer1, inGBuffer2, inGBuffer3;
-
-    inGBuffer0 = DecodeGBuffer0(inGBufferU0);
+    BSDFData bsdfData;
+    float3 unused;
-    uint packedGBuffer1 = inGBufferU0.z | inGBufferU0.w << 16;
-    inGBuffer1 = UnpackR10G10B10A2(packedGBuffer1);
-
-    inGBuffer2.x = UnpackUIntToFloat(inGBufferU1.x, 8, 0);
-    inGBuffer2.y = UnpackUIntToFloat(inGBufferU1.x, 8, 8);
-    inGBuffer2.z = UnpackUIntToFloat(inGBufferU1.y, 8, 0);
-    inGBuffer2.w = UnpackUIntToFloat(inGBufferU1.y, 8, 8);
-
-    uint packedGBuffer3 = inGBufferU1.z | inGBufferU1.w << 16;
-    inGBuffer3.xyz = UnpackR11G11B10f(packedGBuffer1);
-    inGBuffer3.w = 0.0;
+    DecodeFromGBuffer(
+#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
+        GBufferType0 inGBufferU0,
+        GBufferType1 inGBufferU1,
+#else
+        GBufferType0 inGBuffer0,
+        GBufferType1 inGBuffer1,
+        GBufferType2 inGBuffer2,
+        GBufferType3 inGBuffer3,
-
-    int materialId = UnpackMaterialId(inGBuffer1.a);
-
-    uint featureFlags = 0;
-    if (materialId == MATERIALID_LIT_STANDARD)
-    {
-        float metallic;
-        int specular;
-        UnpackFloatInt8bit(inGBuffer2.a, 4.0, metallic, specular);
-        float anisotropy = inGBuffer2.b;
-
-        if (specular == SPECULARVALUE_SPECULAR_COLOR)
-        {
-            featureFlags |= MATERIALFEATUREFLAGS_LIT_SPECULAR;
-        }
-        else if (anisotropy > 0.0)
-        {
-            featureFlags |= MATERIALFEATUREFLAGS_LIT_ANISO;
-        }
-        else
-        {
-            featureFlags |= MATERIALFEATUREFLAGS_LIT_STANDARD;
-        }
-    }
-    else if (materialId == MATERIALID_LIT_SSS)
-    {
-        featureFlags |= MATERIALFEATUREFLAGS_LIT_SSS;
-    }
+        0xFFFFFFFF,
+        bsdfData,
+        unused
+    );
-    return featureFlags;
+    return 1 << materialId; // This match all the MATERIALFEATUREFLAGS_LIT_XXX flag
 }
 
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/FeatureFlags.hlsl

-#ifndef __FEATURE_FLAGS_H__
-#define __FEATURE_FLAGS_H__
-
-static const uint FeatureVariantFlags[NUM_FEATURE_VARIANTS] =
-{
-/*  0 */ 0 | MATERIALFEATUREFLAGS_MASK, // TODO: ask Runes if this is really needed ? In case of material only, it mean debug and we don't care about performance
-/*  1 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | MATERIALFEATUREFLAGS_LIT_STANDARD,
-/*  2 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD,
-/*  3 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_STANDARD,
-/*  3 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD,
-/*  5 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_STANDARD,
-/*  6 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD,
-/*  7 */ LIGHTFEATUREFLAGS_MASK | MATERIALFEATUREFLAGS_LIT_STANDARD,
-/*  8 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | MATERIALFEATUREFLAGS_MASK,
-/*  9 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_MASK,
-/* 10 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_MASK,
-/* 11 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_MASK,
-/* 12 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_MASK,
-/* 13 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_MASK,
-/* 14 */ LIGHTFEATUREFLAGS_MASK | MATERIALFEATUREFLAGS_MASK,
-/* 15 */ 0xFFFFFFFF	// shouldn't be needed
-};
-
-uint FeatureFlagsToTileVariant(uint featureFlags)
-{
-    for(int i = 0; i < NUM_FEATURE_VARIANTS; i++)
-    {
-        if((featureFlags & FeatureVariantFlags[i]) == featureFlags)
-            return i;
-    }
-    return NUM_FEATURE_VARIANTS - 1;
-}
-
-uint TileVariantToFeatureFlags(uint variant)
-{
-    return FeatureVariantFlags[variant];
-}
-
-#endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/FeatureFlags.hlsl.meta

-fileFormatVersion: 2
-guid: 0ef495ee49d152b419e9fd62aa24523f
-timeCreated: 1489679489
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: