Merge pull request #402 from Unity-Technologies/Aniso-as-true-materialId

Aniso as MaterialId

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs.  Please don't edit by hand.
 //
 
 #ifndef LIGHTDEFINITION_CS_HLSL
 #define GPULIGHTTYPE_PROJECTOR_PYRAMID (4)
 #define GPULIGHTTYPE_LINE (5)
 #define GPULIGHTTYPE_RECTANGLE (6)
-#define GPULIGHTTYPE_SPHERE (7)
-#define GPULIGHTTYPE_DISK (8)
-#define GPULIGHTTYPE_HEMISPHERE (9)
-#define GPULIGHTTYPE_CYLINDER (10)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.EnvShapeType:  static fields

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Deferred.compute

 #pragma kernel Deferred_Indirect_Fptl_Variant23              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=23
 #pragma kernel Deferred_Indirect_Fptl_Variant24              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=24
 #pragma kernel Deferred_Indirect_Fptl_Variant25              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=25
-#pragma kernel Deferred_Indirect_Fptl_Variant26              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=26
-#pragma kernel Deferred_Indirect_Fptl_Variant27              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant27                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=27
-#pragma kernel Deferred_Indirect_Fptl_Variant28              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant28                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=28
-#pragma kernel Deferred_Indirect_Fptl_Variant29              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant29                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=29
-#pragma kernel Deferred_Indirect_Fptl_Variant30              SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant30                  USE_FPTL_LIGHTLIST          USE_INDIRECT    VARIANT=30
 
 /* Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
 #pragma kernel Deferred_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
 #pragma kernel Deferred_Indirect_Clustered_Variant23         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant23             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=23
 #pragma kernel Deferred_Indirect_Clustered_Variant24         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant24             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=24
 #pragma kernel Deferred_Indirect_Clustered_Variant25         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant25             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=25
-#pragma kernel Deferred_Indirect_Clustered_Variant26         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant26             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=26
-#pragma kernel Deferred_Indirect_Clustered_Variant27         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant27             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=27
-#pragma kernel Deferred_Indirect_Clustered_Variant28         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant28             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=28
-#pragma kernel Deferred_Indirect_Clustered_Variant29         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant29             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=29
-#pragma kernel Deferred_Indirect_Clustered_Variant30         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant30             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=30
 */
 
 #define LIGHTLOOP_TILE_PASS 1

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

-using UnityEngine.Rendering;
+using UnityEngine.Rendering;
 using System.Collections.Generic;
 using System;
 
             public static int s_TileSizeClustered = 32;
 
             // feature variants
-            public static int s_NumFeatureVariants = 31;
+            public static int s_NumFeatureVariants = 26;
 
             // Following define the maximum number of bits use in each feature category.
             public static uint s_LightFeatureMaskFlags = 0xFF00;
                 if (enableFeatureVariants)
                 {
                     // material classification
-                    if(m_TileSettings.enableComputeMaterialVariants)
+                    if (m_TileSettings.enableComputeMaterialVariants)
                     {
                         int buildMaterialFlagsKernel = s_BuildMaterialFlagsOrKernel;
 

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

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs.  Please don't edit by hand.
 //
 
 #ifndef TILEPASS_CS_HLSL
 #define USE_LEFT_HAND_CAMERA_SPACE (1)
 #define TILE_SIZE_FPTL (16)
 #define TILE_SIZE_CLUSTERED (32)
-#define NUM_FEATURE_VARIANTS (31)
+#define NUM_FEATURE_VARIANTS (26)
 #define LIGHT_FEATURE_MASK_FLAGS (65280)
 #define MATERIAL_FEATURE_MASK_FLAGS (255)
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

         {
             LitSSS          = 0,
             LitStandard     = 1,
-            LitClearCoat    = 2,
-            LitUnused       = 3,
-            // We don't store any materialId for aniso but instead deduce it from LitStandard + value of specular + anisotropy parameters
-            // Consequence is that when querying materialId alone, it will read 2 RT and not only one. This may be a performance hit when only materialId is desired (like in material classification pass)
-            // Alternative is to use a materialId slot, if any are available.
-            LitAniso        = 4,
+            LitAniso        = 2,
+            LitClearCoat    = 3,
-            LitSpecular     = 5,
+            LitSpecular     = 4,
         };
 
         // If change, be sure it match what is done in Lit.hlsl: MaterialFeatureFlagsFromGBuffer
         {
             LitSSS          = 1 << MaterialId.LitSSS,
             LitStandard     = 1 << MaterialId.LitStandard,
+            LitAniso        = 1 << MaterialId.LitAniso,
-            LitUnused       = 1 << MaterialId.LitUnused,
-            LitAniso        = 1 << MaterialId.LitAniso,
         };
 
         [GenerateHLSL]
             public static int s_GBufferLitStandardSpecularColorId = 1;
-            public static int s_GBufferLitStandardAnisotropicId = 2;
 
             public static float s_DefaultSpecularValue = 0.04f;
             public static float s_SkinSpecularValue = 0.028f;

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

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs.  Please don't edit by hand.
 //
 
 #ifndef LIT_CS_HLSL
 //
 #define MATERIALID_LIT_SSS (0)
 #define MATERIALID_LIT_STANDARD (1)
-#define MATERIALID_LIT_CLEAR_COAT (2)
-#define MATERIALID_LIT_UNUSED (3)
-#define MATERIALID_LIT_ANISO (4)
-#define MATERIALID_LIT_SPECULAR (5)
+#define MATERIALID_LIT_ANISO (2)
+#define MATERIALID_LIT_CLEAR_COAT (3)
+#define MATERIALID_LIT_SPECULAR (4)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+MaterialFeatureFlags:  static fields
-#define MATERIALFEATUREFLAGS_LIT_CLEAR_COAT (4)
-#define MATERIALFEATUREFLAGS_LIT_UNUSED (8)
-#define MATERIALFEATUREFLAGS_LIT_ANISO (16)
+#define MATERIALFEATUREFLAGS_LIT_ANISO (4)
+#define MATERIALFEATUREFLAGS_LIT_CLEAR_COAT (8)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+StandardDefinitions:  static fields
-#define GBUFFER_LIT_STANDARD_ANISOTROPIC_ID (2)
 #define DEFAULT_SPECULAR_VALUE (0.04)
 #define SKIN_SPECULAR_VALUE (0.028)
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 // Combination need to be define in increasing "comlexity" order as define by FeatureFlagsToTileVariant
 static const uint kFeatureVariantFlags[NUM_FEATURE_VARIANTS] =
 {
-    // Standard
+    // Standard>Specular
     /*  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,
     /*  8 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_SSS,
     /*  9 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_SSS,
 
-    // Specular/Aniso
+    // Aniso
     /* 10 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_ANISO,
     /* 11 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_ANISO,
     /* 12 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_ANISO,
-    // SSS is a superset of material standard. With foliage or crowd SSS and standard can overlap a lot, better to have a dedicated combination
+    // With foliage or crowd with SSS and standard can overlap a lot, better to have a dedicated combination
-    /* 19 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_SSS,
+    /* 19 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_STANDARD,
 
     // ClearCoat
     /* 20 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_CLEAR_COAT,
     /* 24 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_CLEAR_COAT,
 
-    // Future usage
-    /* 25 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_UNUSED,
-    /* 26 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_UNUSED,
-    /* 27 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED,
-    /* 28 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_UNUSED,
-    /* 29 */ LIGHT_FEATURE_MASK_FLAGS | MATERIALFEATUREFLAGS_LIT_UNUSED,
-
-    /* 30 */ LIGHT_FEATURE_MASK_FLAGS | MATERIAL_FEATURE_MASK_FLAGS, // Catch all case with MATERIAL_FEATURE_MASK_FLAGS is needed in case we disable material classification
+    /* 25 */ LIGHT_FEATURE_MASK_FLAGS | MATERIAL_FEATURE_MASK_FLAGS, // Catch all case with MATERIAL_FEATURE_MASK_FLAGS is needed in case we disable material classification
 };
 
 uint FeatureFlagsToTileVariant(uint featureFlags)
         bsdfData.diffuseColor = surfaceData.baseColor;
         bsdfData.fresnel0 = surfaceData.specularColor;
     }
+    else if (bsdfData.materialId == MATERIALID_LIT_SSS)
+    {
+        FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData);
+    }
-    }
-    else if (bsdfData.materialId == MATERIALID_LIT_SSS)
-    {
-        FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData);
     }
     else if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
         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)
+    {
+        outGBuffer2 = float4(surfaceData.subsurfaceRadius, surfaceData.thickness, 0.0, PackByte(surfaceData.subsurfaceProfile));
+    }
-        outGBuffer1.a = PackMaterialId(MATERIALID_LIT_STANDARD); // Encode MATERIALID_LIT_SPECULAR as MATERIALID_LIT_STANDARD + GBUFFER_LIT_STANDARD_ANISOTROPIC_ID value in GBuffer2
-        outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, PackFloatInt8bit(surfaceData.metallic, GBUFFER_LIT_STANDARD_ANISOTROPIC_ID, 4.0));
-    }
-    else if (surfaceData.materialId == MATERIALID_LIT_SSS)
-    {
-        outGBuffer2 = float4(surfaceData.subsurfaceRadius, surfaceData.thickness, 0.0, PackByte(surfaceData.subsurfaceProfile));
+            outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, PackFloatInt8bit(surfaceData.metallic, 0.0, 4.0));
     }
     else if (surfaceData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {
     // 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 | MATERIALFEATUREFLAGS_LIT_ANISO)) != 0;
-    int supportsSSS = (featureFlags & (MATERIALFEATUREFLAGS_LIT_SSS)) != 0;
-    int supportClearCoat = (featureFlags & (MATERIALFEATUREFLAGS_LIT_CLEAR_COAT)) != 0;
+    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;
-    if (supportsStandard + supportsSSS + supportClearCoat > 1)
+    if (supportsStandard + supportsSSS + supportsAniso + supportClearCoat > 1)
     {
         // only fetch materialid if it is not statically known from feature flags
         bsdfData.materialId = UnpackMaterialId(inGBuffer1.a);
             bsdfData.materialId = MATERIALID_LIT_STANDARD;
         else if (supportsSSS)
             bsdfData.materialId = MATERIALID_LIT_SSS;
+        else if (supportsAniso)
+            bsdfData.materialId = MATERIALID_LIT_ANISO;
         else
             bsdfData.materialId = MATERIALID_LIT_CLEAR_COAT;
     }
         float metallic;
         int materialIdExtent;
         UnpackFloatInt8bit(inGBuffer2.a, 4.0, metallic, materialIdExtent);
-        float anisotropy = inGBuffer2.b;
-        if (featureFlags & (MATERIAL_FEATURE_MASK_FLAGS) == MATERIALFEATUREFLAGS_LIT_STANDARD)
+        if (materialIdExtent == GBUFFER_LIT_STANDARD_SPECULAR_COLOR_ID)
-            if (materialIdExtent == GBUFFER_LIT_STANDARD_SPECULAR_COLOR_ID)
-            {
-                // Note: Specular is not a material id but just a way to parameterize the standard materialid, thus we reset materialId to MATERIALID_LIT_STANDARD
-                // For material classification it will be consider as Standard as well, thus no need to create special case
-                bsdfData.diffuseColor = baseColor;
-                bsdfData.fresnel0 = inGBuffer2.rgb;
-            }
-            else
-            {
-                FillMaterialIdStandardData(baseColor, metallic, bsdfData);
-            }
+            // Note: Specular is not a material id but just a way to parameterize the standard materialid, thus we reset materialId to MATERIALID_LIT_STANDARD
+            // For material classification it will be consider as Standard as well, thus no need to create special case
+            bsdfData.diffuseColor = baseColor;
+            bsdfData.fresnel0 = inGBuffer2.rgb;
-        else if (featureFlags & (MATERIAL_FEATURE_MASK_FLAGS) == MATERIALFEATUREFLAGS_LIT_ANISO)
+        else // GBUFFER_LIT_STANDARD_REGULAR_ID
-            bsdfData.materialId = MATERIALID_LIT_ANISO;
-            float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
-            FillMaterialIdAnisoData(bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
-        }
-        else // either MATERIAL_FEATURE_MASK_FLAGS or MATERIALFEATUREFLAGS_LIT_STANDARD | MATERIALFEATUREFLAGS_LIT_ANISO
-        {
-            if (materialIdExtent == GBUFFER_LIT_STANDARD_SPECULAR_COLOR_ID)
-            {
-                // Note: Specular is not a material id but just a way to parameterize the standard materialid, thus we reset materialId to MATERIALID_LIT_STANDARD
-                // For material classification it will be consider as Standard as well, thus no need to create special case
-                bsdfData.diffuseColor = baseColor;
-                bsdfData.fresnel0 = inGBuffer2.rgb;
-            }
-            else if (materialIdExtent == GBUFFER_LIT_STANDARD_ANISOTROPIC_ID)
-            {
-                bsdfData.materialId = MATERIALID_LIT_ANISO;
-                FillMaterialIdStandardData(baseColor, metallic, bsdfData);
-                float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
-                FillMaterialIdAnisoData(bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
-            }
-            else // GBUFFER_LIT_STANDARD_REGULAR_ID
-            {
-                FillMaterialIdStandardData(baseColor, metallic, bsdfData);
-            }
         }
     }
     else if (bsdfData.materialId == MATERIALID_LIT_SSS)
         int   subsurfaceProfile = UnpackByte(inGBuffer2.w);
 
         FillMaterialIdSSSData(baseColor, subsurfaceProfile, subsurfaceRadius, thickness, bsdfData);
+    }
+    else if (bsdfData.materialId == MATERIALID_LIT_ANISO)
+    {
+        float metallic;
+        int unused;
+        UnpackFloatInt8bit(inGBuffer2.a, 4.0, metallic, unused);
+        FillMaterialIdStandardData(baseColor, metallic, bsdfData);
+
+        float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
+        float anisotropy = inGBuffer2.b;
+        FillMaterialIdAnisoData(bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
     }
     else //if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT)
     {

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        // Note: 2 and 3 are currently unused
-        [Enum(Subsurface Scattering, 0, Standard, 1, ClearCoat, 2, Anisotropy, 4, Specular Color, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
+        [Enum(Subsurface Scattering, 0, Standard, 1, Anisotropy, 2, ClearCoat, 3, Specular Color, 4)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitReference.hlsl

 
         switch (lightData.lightType)
         {
-            case GPULIGHTTYPE_SPHERE:
-                SampleSphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-                break;
-            case GPULIGHTTYPE_HEMISPHERE:
-                SampleHemisphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-                break;
-            case GPULIGHTTYPE_CYLINDER:
-                SampleCylinder(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
-                break;
+            //case GPULIGHTTYPE_SPHERE:
+            //    SampleSphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+            //    break;
+            //case GPULIGHTTYPE_HEMISPHERE:
+            //    SampleHemisphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+            //    break;
+            //case GPULIGHTTYPE_CYLINDER:
+            //    SampleCylinder(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
+            //    break;
-            case GPULIGHTTYPE_DISK:
-                SampleDisk(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-                break;
+            //case GPULIGHTTYPE_DISK:
+            //    SampleDisk(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+            //   break;
             // case GPULIGHTTYPE_LINE: handled by a separate function.
         }
 
     }
 
     return acc / sampleCount;
-}
+}

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        // Note: 2 and 3 are currently unused
-        [Enum(Subsurface Scattering, 0, Standard, 1, ClearCoat, 2, Anisotropy, 4, Specular Color, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
+        [Enum(Subsurface Scattering, 0, Standard, 1, Anisotropy, 2, ClearCoat, 3, Specular Color, 4)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5