HDREnderLoop: Fix cluster lighting + rename base layer to main layer

- Cluster opaque is working but cluster transparent is not working
- Change name base layer to Main layer influence
- Clean some unused code

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             public static float VIEWPORT_SCALE_Z = 1.0f;
 
             // enable unity's original left-hand shader camera space (right-hand internally in unity).
-            public static int USE_LEFTHAND_CAMERASPACE = 0;
+            public static int USE_LEFTHAND_CAMERASPACE = 1;
 
             // flags
             public static int IS_CIRCULAR_SPOT_SHAPE = 1;
 
                     SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
                     SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
-                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-
 
                     // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
                     if (bUseClusteredForDeferred)
 
                     if (disableTileAndCluster)
                     {
+                        // This is a debug brute force renderer to debug tile/cluster which render all the lights
                         Utilities.SetupMaterialHDCamera(hdCamera, m_SingleDeferredMaterial);
                         m_SingleDeferredMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                         m_SingleDeferredMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
 
             public override void RenderForward(Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
             {
-                // Note: if we use render opaque with deferred tiling we need to render a opque depth pass for these opaque objects
+                // Note: if we use render opaque with deferred tiling we need to render a opaque depth pass for these opaque objects
                 bool useFptl = renderOpaque && usingFptl;
 
                 var cmd = new CommandBuffer();
                     cmd.name = useFptl ? "Forward Tiled pass" : "Forward Clustered pass";
                     cmd.EnableShaderKeyword("LIGHTLOOP_TILE_PASS");
                     cmd.DisableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
-                    cmd.SetGlobalFloat("g_isOpaquesOnlyEnabled", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
+                    cmd.SetGlobalFloat("_UseTileLightList", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
                     cmd.SetGlobalBuffer("g_vLightListGlobal", useFptl ? s_LightList : s_PerVoxelLightLists);
                 }
 

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

 #define MAX_NR_LIGHTS_PER_CAMERA (1024)
 #define MAX_NR_BIGTILE_LIGHTS_PLUSONE (512)
 #define VIEWPORT_SCALE_Z (1)
-#define USE_LEFTHAND_CAMERASPACE (0)
+#define USE_LEFTHAND_CAMERASPACE (1)
 #define IS_CIRCULAR_SPOT_SHAPE (1)
 #define HAS_COOKIE_TEXTURE (2)
 #define IS_BOX_PROJECTED (4)

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/Editor/LayeredLitUI.cs

             public readonly GUIContent layerTexWorldScaleText = new GUIContent("Tiling", "Tiling factor applied to Planar/Trilinear mapping");
             public readonly GUIContent UVBaseText = new GUIContent("Base UV Mapping", "Base UV Mapping mode of the layer.");
             public readonly GUIContent UVDetailText = new GUIContent("Detail UV Mapping", "Detail UV Mapping mode of the layer.");
-            public readonly GUIContent BaseInfluenceText = new GUIContent("Base influence", "Base influence.");
+            public readonly GUIContent MainLayerInfluenceText = new GUIContent("Main layer influence", "Main layer influence.");
-            public readonly GUIContent useBaseLayerModeText = new GUIContent("Main Layer Influence", "Switch between regular layers mode and base/layers mode");            
+            public readonly GUIContent useMainLayerInfluenceModeText = new GUIContent("Main Layer Influence", "Switch between regular layers mode and base/layers mode");            
-            public readonly GUIContent inheritBaseLayerText = new GUIContent("Inherit Base Layer Normal", "Inherit the normal from the base layer.");
             public readonly GUIContent heightFactorText = new GUIContent("Height Multiplier", "Scale applied to the height of the layer.");
             public readonly GUIContent blendSizeText = new GUIContent("Blend Size", "Thickness over which the layer will be blended with the previous one.");
             public readonly GUIContent heightControlText = new GUIContent("Height control");
         MaterialProperty[] layerUVDetailsMappingMask = new MaterialProperty[kMaxLayerCount];
 
 
-        const string kkUseBaseLayerMode = "_UseBaseLayerMode";
-        MaterialProperty useBaseLayerMode = null;
+        const string kkUseMainLayerInfluence = "_UseMainLayerInfluence";
+        MaterialProperty useMainLayerInfluence = null;
         const string kUseHeightBasedBlend = "_UseHeightBasedBlend";
         MaterialProperty useHeightBasedBlend = null;
         const string kUseHeightBasedBlendV2 = "_UseHeightBasedBlendV2";
         const string kHeightOffset = "_HeightOffset";
         MaterialProperty[] heightOffset = new MaterialProperty[kMaxLayerCount-1];
-        const string kInheritBaseLayer = "_InheritBaseLayer";
-        MaterialProperty[] inheritBaseLayer = new MaterialProperty[kMaxLayerCount - 1];
         const string kHeightFactor = "_HeightFactor";
         MaterialProperty[] heightFactor = new MaterialProperty[kMaxLayerCount-1];
         const string kHeightCenterOffset = "_HeightCenterOffset";
             layerCount = FindProperty(kLayerCount, props);
             vertexColorMode = FindProperty(kVertexColorMode, props);
 
-            useBaseLayerMode = FindProperty(kkUseBaseLayerMode, props);
+            useMainLayerInfluence = FindProperty(kkUseMainLayerInfluence, props);
             useHeightBasedBlend = FindProperty(kUseHeightBasedBlend, props);
             useHeightBasedBlendV2 = FindProperty(kUseHeightBasedBlendV2, props);
             
 
                 if(i != 0)
                 {
-                    inheritBaseLayer[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseLayer, i), props);
                     heightOffset[i-1] = FindProperty(string.Format("{0}{1}", kHeightOffset, i), props);
                     heightFactor[i-1] = FindProperty(string.Format("{0}{1}", kHeightFactor, i), props);
                     blendSize[i-1] = FindProperty(string.Format("{0}{1}", kBlendSize, i), props);
 
             Material material = m_MaterialEditor.target as Material;
 
-            bool baseLayerModeEnable = useBaseLayerMode.floatValue > 0.0f;
+            bool baseLayerModeEnable = useMainLayerInfluence.floatValue > 0.0f;
 
             EditorGUILayout.LabelField(styles.layerLabels[layerIndex], styles.layerLabelColors[layerIndex]);
 
  
                 int paramIndex = layerIndex - 1;
 
-                EditorGUILayout.LabelField(styles.DensityOpacityInfluenceText, EditorStyles.label);
+                EditorGUILayout.LabelField(styles.DensityOpacityInfluenceText, EditorStyles.boldLabel);
 
                 EditorGUI.indentLevel++;
 
 
                 if (baseLayerModeEnable)
                 {
-                    EditorGUILayout.LabelField(styles.BaseInfluenceText, EditorStyles.label);
+                    EditorGUILayout.LabelField(styles.MainLayerInfluenceText, EditorStyles.boldLabel);
 
                     EditorGUI.indentLevel++;
 
                     EditorGUI.indentLevel--;
                     m_MaterialEditor.ShaderProperty(inheritBaseNormal[paramIndex], styles.inheritBaseNormalText);
-
-                    if (heightBasedBlendEnable)
-                    {
-                        m_MaterialEditor.ShaderProperty(inheritBaseHeight[paramIndex], styles.inheritBaseHeightText);
-                    }
+                    // Main height influence is only available if the shader use the heightmap for displacement (per vertex or per level)
+                    // We always display it as it can be tricky to know when per pixel displacement is enabled or not
+                    m_MaterialEditor.ShaderProperty(inheritBaseHeight[paramIndex], styles.inheritBaseHeightText);
 
                     EditorGUI.indentLevel--;
                 }
-                    EditorGUILayout.LabelField(styles.heightControlText, EditorStyles.label);
+                    EditorGUILayout.LabelField(styles.heightControlText, EditorStyles.boldLabel);
 
                     EditorGUI.indentLevel++;
                     m_MaterialEditor.ShaderProperty(heightFactor[paramIndex], styles.heightFactorText);
-                        //m_MaterialEditor.ShaderProperty(inheritBaseLayer[heightParamIndex], styles.inheritBaseLayerText);
                         m_MaterialEditor.ShaderProperty(heightOffset[paramIndex], styles.heightOffsetText);
                         m_MaterialEditor.ShaderProperty(blendSize[paramIndex], styles.blendSizeText);
                     }
             m_MaterialEditor.TexturePropertySingleLine(styles.layerMapMaskText, layerMaskMap);
 
             EditorGUI.BeginChangeCheck();
-            EditorGUI.showMixedValue = useBaseLayerMode.hasMixedValue;
-            bool enabledBaseMode = EditorGUILayout.Toggle(styles.useBaseLayerModeText, useBaseLayerMode.floatValue > 0.0f);
+            EditorGUI.showMixedValue = useMainLayerInfluence.hasMixedValue;
+            bool mainLayerModeInfluenceEnable = EditorGUILayout.Toggle(styles.useMainLayerInfluenceModeText, useMainLayerInfluence.floatValue > 0.0f);
-                useBaseLayerMode.floatValue = enabledBaseMode ? 1.0f : 0.0f;
+                useMainLayerInfluence.floatValue = mainLayerModeInfluenceEnable ? 1.0f : 0.0f;
             }
 
             m_MaterialEditor.ShaderProperty(vertexColorMode, styles.vertexColorModeText);
 
             SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap));
 
-            SetKeyword(material, "_BASE_LAYER_MODE", material.GetFloat(kkUseBaseLayerMode) != 0.0f);
+            SetKeyword(material, "_MAIN_LAYER_INFLUENCE_MODE", material.GetFloat(kkUseMainLayerInfluence) != 0.0f);
 
             VertexColorMode VCMode = (VertexColorMode)vertexColorMode.floatValue;
             if (VCMode == VertexColorMode.Multiply)

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

         [ToggleOff] _UseHeightBasedBlend("UseHeightBasedBlend", Float) = 0.0
         // Layer blending options V2
         [ToggleOff] _UseHeightBasedBlendV2("Use Height Blend V2", Float) = 0.0
-        [ToggleOff] _UseBaseLayerMode("UseBaseLayerMode", Float) = 0.0
+        [ToggleOff] _UseMainLayerInfluence("UseMainLayerInfluence", Float) = 0.0
 
         _HeightOffset1("_HeightOffset1", Range(-0.3, 0.3)) = 0.0
         _HeightOffset2("_HeightOffset2", Range(-0.3, 0.3)) = 0.0
         _BlendSize1("_BlendSize1", Range(0, 0.30)) = 0.0
         _BlendSize2("_BlendSize2", Range(0, 0.30)) = 0.0
         _BlendSize3("_BlendSize3", Range(0, 0.30)) = 0.0
-
-        _InheritBaseLayer1("_InheritBaseLayer1", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer2("_InheritBaseLayer2", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer3("_InheritBaseLayer3", Range(0, 1.0)) = 0.0
 
         _VertexColorHeightFactor("_VertexColorHeightFactor", Float) = 0.3
 
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
-    #pragma shader_feature _BASE_LAYER_MODE
+    #pragma shader_feature _MAIN_LAYER_INFLUENCE_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _HEIGHT_BASED_BLEND_V2
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

         [ToggleOff] _UseHeightBasedBlend("UseHeightBasedBlend", Float) = 0.0
         // Layer blending options V2
         [ToggleOff] _UseHeightBasedBlendV2("Use Height Blend V2", Float) = 0.0
-        [ToggleOff] _UseBaseLayerMode("UseBaseLayerMode", Float) = 0.0
+        [ToggleOff] _UseMainLayerInfluence("UseMainLayerInfluence", Float) = 0.0
 
         _HeightOffset1("_HeightOffset1", Range(-0.3, 0.3)) = 0.0
         _HeightOffset2("_HeightOffset2", Range(-0.3, 0.3)) = 0.0
         _BlendSize1("_BlendSize1", Range(0, 0.30)) = 0.0
         _BlendSize2("_BlendSize2", Range(0, 0.30)) = 0.0
         _BlendSize3("_BlendSize3", Range(0, 0.30)) = 0.0
-
-        _InheritBaseLayer1("_InheritBaseLayer1", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer2("_InheritBaseLayer2", Range(0, 1.0)) = 0.0
-        _InheritBaseLayer3("_InheritBaseLayer3", Range(0, 1.0)) = 0.0
 
         _VertexColorHeightFactor("_VertexColorHeightFactor", Float) = 0.3
 
     #pragma shader_feature _HEIGHTMAP
     #pragma shader_feature _DETAIL_MAP
     #pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD
-    #pragma shader_feature _BASE_LAYER_MODE
+    #pragma shader_feature _MAIN_LAYER_INFLUENCE_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _HEIGHT_BASED_BLEND_V2
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

         const string kDepthOffsetEnable = "_DepthOffsetEnable";
 
         // tessellation params
-        MaterialProperty tessellationMode = null;
+        protected MaterialProperty tessellationMode = null;
         const string kTessellationMode = "_TessellationMode";
         MaterialProperty tessellationFactor = null;
         const string kTessellationFactor = "_TessellationFactor";

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitData.hlsl

     float height3 = SampleHeightmapLod3(layerTexCoord, lod, _HeightCenterOffset3, _HeightFactor3);
     float heightResult = BlendLayeredScalar(height0, height1, height2, height3, weights);
 
-#if defined(_BASE_LAYER_MODE)
+#if defined(_MAIN_LAYER_INFLUENCE_MODE)
     // Think that inheritbasedheight will be 0 if height0 is fully visible in weights. So there is no double contribution of height0
     float inheritBaseHeight = BlendLayeredScalar(0.0, _InheritBaseHeight1, _InheritBaseHeight2, _InheritBaseHeight3, weights);
     return heightResult + height0 * inheritBaseHeight;
     // For layered shader, alpha of base color is used as either an opacity mask, a composition mask for inheritance parameters or a density mask.
     float alpha = PROP_BLEND_SCALAR(alpha, weights);
 
-#if defined(_BASE_LAYER_MODE)
+#if defined(_MAIN_LAYER_INFLUENCE_MODE)
     surfaceData.baseColor = ComputeInheritedColor(surfaceData0.baseColor, surfaceData1.baseColor, surfaceData2.baseColor, surfaceData3.baseColor, alpha, layerTexCoord, weights);
     float3 normalTS = ComputeInheritedNormalTS(input, normalTS0, normalTS1, normalTS2, normalTS3, layerTexCoord, weights);
 #else

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 float _BlendSize2;
 float _BlendSize3;
 float _VertexColorHeightFactor;
-float _InheritBaseLayer1;
-float _InheritBaseLayer2;
-float _InheritBaseLayer3;
 
 // Blend Properties V2
 float _UseHeightBasedBlendV2;

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Unlit/Unlit.shader

 
             ENDHLSL
         }
-        
-        // ------------------------------------------------------------------
-        //  forward opaque pass
-        // Material opaque that are always forward (i.e can't render in deferred) need to implement ForwardOnlyOpaque pass
-        // (Code is exactly the same as "Forward", it simply allow our system to filter objects correctly
-        // TODO: can we do this another way ? Like relying on QueueIndex ? But it will be require anyway for material with two forward pass like hair
-        Pass
-        {
-            Name "ForwardUnlit"
-            Tags { "LightMode" = "ForwardOnlyOpaque" }
-
-            Blend [_SrcBlend] [_DstBlend]
-            ZWrite [_ZWrite]
-            Cull [_CullMode]
-
-            HLSLPROGRAM
-
-            #define SHADERPASS SHADERPASS_FORWARD_UNLIT
-            #include "../../Material/Material.hlsl"            
-            #include "ShaderPass/UnlitSharePass.hlsl"
-            #include "UnlitData.hlsl"
-            #include "../../ShaderPass/ShaderPassForwardUnlit.hlsl"
-
-            ENDHLSL
-        }
 
         // ------------------------------------------------------------------
         //  forward pass