- Added new Global and Frame settings to start refactoring them.

- Removed Specular/Diffuse global dimmer from serialized global setting and put them in per frame lightingSettings instead.

ScriptableRenderPipeline/Core/TextureCache.cs

             {
                 var format = TextureFormat.RGBAHalf;
 
-//                var probeFormat = TextureFormat.BC6H;
+                var probeFormat = TextureFormat.BC6H;
-////#if UNITY_2017_2_OR_NEWER
-//                if (SystemInfo.SupportsTextureFormat(probeFormat) && !UnityEngine.Rendering.GraphicsSettings.HasShaderDefine(UnityEngine.Rendering.BuiltinShaderDefine.UNITY_NO_DXT5nm))
+//#if UNITY_2017_2_OR_NEWER
+                if (SystemInfo.SupportsTextureFormat(probeFormat) && !UnityEngine.Rendering.GraphicsSettings.HasShaderDefine(UnityEngine.Rendering.BuiltinShaderDefine.UNITY_NO_DXT5nm))
+                    format = probeFormat;
+//#else
+//                if (SystemInfo.SupportsTextureFormat(probeFormat) && !TextureCache.isMobileBuildTarget)
-////#else
-////                if (SystemInfo.SupportsTextureFormat(probeFormat) && !TextureCache.isMobileBuildTarget)
-////                    format = probeFormat;
-////#endif
+//#endif
 
                 return format;
             }

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.Styles.cs

             public readonly GUIContent spotCookieSize = new GUIContent("Spot Cookie Size");
             public readonly GUIContent pointCookieSize = new GUIContent("Point Cookie Size");
             public readonly GUIContent reflectionCubemapSize = new GUIContent("Reflection Cubemap Size");
+            public readonly GUIContent reflectionCacheCompressed = new GUIContent("Compress Reflection Probe Cache");
 
             public readonly GUIContent sssSettings = new GUIContent("Subsurface Scattering Settings");
 

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

         SerializedProperty m_SpotCookieSize;
         SerializedProperty m_PointCookieSize;
         SerializedProperty m_ReflectionCubemapSize;
+        SerializedProperty m_ReflectionCacheCompressed;
 
         void InitializeProperties()
         {
             m_ShadowAtlasHeight = properties.Find(x => x.shadowInitParams.shadowAtlasHeight);
 
             // Texture settings
-            m_SpotCookieSize = properties.Find(x => x.textureSettings.spotCookieSize);
-            m_PointCookieSize = properties.Find(x => x.textureSettings.pointCookieSize);
-            m_ReflectionCubemapSize = properties.Find(x => x.textureSettings.reflectionCubemapSize);
+            m_SpotCookieSize = properties.Find(x => x.globalTextureSettings.spotCookieSize);
+            m_PointCookieSize = properties.Find(x => x.globalTextureSettings.pointCookieSize);
+            m_ReflectionCubemapSize = properties.Find(x => x.globalTextureSettings.reflectionCubemapSize);
+            m_ReflectionCacheCompressed = properties.Find(x => x.globalTextureSettings.reflectionCacheCompressed);
-            m_RenderingUseForwardOnly = properties.Find(x => x.renderingSettings.useForwardRenderingOnly);
-            m_RenderingUseDepthPrepass = properties.Find(x => x.renderingSettings.useDepthPrepassWithDeferredRendering);
-            m_RenderingUseDepthPrepassAlphaTestOnly = properties.Find(x => x.renderingSettings.renderAlphaTestOnlyInDeferredPrepass);
+            m_RenderingUseForwardOnly = properties.Find(x => x.globalRenderingSettings.useForwardRenderingOnly);
+            m_RenderingUseDepthPrepass = properties.Find(x => x.globalRenderingSettings.useDepthPrepassWithDeferredRendering);
+            m_RenderingUseDepthPrepassAlphaTestOnly = properties.Find(x => x.globalRenderingSettings.renderAlphaTestOnlyInDeferredPrepass);
 
             // Subsurface Scattering Settings
             m_SubsurfaceScatteringSettings = properties.Find(x => x.sssSettings);
             EditorGUILayout.PropertyField(m_SpotCookieSize, s_Styles.spotCookieSize);
             EditorGUILayout.PropertyField(m_PointCookieSize, s_Styles.pointCookieSize);
             EditorGUILayout.PropertyField(m_ReflectionCubemapSize, s_Styles.reflectionCubemapSize);
+            
+            // Commented ou until we have proper realtime BC6H compression
+            //EditorGUILayout.PropertyField(m_ReflectionCacheCompressed, s_Styles.reflectionCacheCompressed);
 
             if (EditorGUI.EndChangeCheck())
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-    [Serializable]
-    public class RenderingSettings
-    {
-        public bool useForwardRenderingOnly; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
-        public bool useDepthPrepassWithDeferredRendering;
-        public bool renderAlphaTestOnlyInDeferredPrepass;
-
-        // We have to fall back to forward-only rendering when scene view is using wireframe rendering mode --
-        // as rendering everything in wireframe + deferred do not play well together
-        public bool ShouldUseForwardRenderingOnly()
-        {
-            return useForwardRenderingOnly || GL.wireframe;
-        }
-    }
-
     public class GBufferManager
     {
         public const int k_MaxGbuffer = 8;
 
             m_IBLFilterGGX = new IBLFilterGGX(asset.renderPipelineResources);
 
-            m_LightLoop.Build(asset.renderPipelineResources, asset.tileSettings, asset.textureSettings, asset.shadowInitParams, m_ShadowSettings, m_IBLFilterGGX);
+            m_LightLoop.Build(asset.renderPipelineResources, asset.tileSettings, asset.globalTextureSettings, asset.shadowInitParams, m_ShadowSettings, m_IBLFilterGGX);
 
             m_SkyManager.Build(asset.renderPipelineResources, m_IBLFilterGGX);
             m_SkyManager.skySettings = skySettingsToUse;
         void RegisterDebug()
         {
             // These need to be Runtime Only because those values are held by the HDRenderPipeline asset so if user change them through the editor debug menu they might change the value in the asset without noticing it.
-            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Forward Only", () => m_Asset.renderingSettings.useForwardRenderingOnly, (value) => m_Asset.renderingSettings.useForwardRenderingOnly = (bool)value, DebugItemFlag.RuntimeOnly);
-            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Deferred Depth Prepass", () => m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering, (value) => m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering = (bool)value, DebugItemFlag.RuntimeOnly);
-            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Deferred Depth Prepass ATest Only", () => m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass, (value) => m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Forward Only", () => m_Asset.globalRenderingSettings.useForwardRenderingOnly, (value) => m_Asset.globalRenderingSettings.useForwardRenderingOnly = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Deferred Depth Prepass", () => m_Asset.globalRenderingSettings.useDepthPrepassWithDeferredRendering, (value) => m_Asset.globalRenderingSettings.useDepthPrepassWithDeferredRendering = (bool)value, DebugItemFlag.RuntimeOnly);
+            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Deferred Depth Prepass ATest Only", () => m_Asset.globalRenderingSettings.renderAlphaTestOnlyInDeferredPrepass, (value) => m_Asset.globalRenderingSettings.renderAlphaTestOnlyInDeferredPrepass = (bool)value, DebugItemFlag.RuntimeOnly);
 
             DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Tile/Cluster", () => m_Asset.tileSettings.enableTileAndCluster, (value) => m_Asset.tileSettings.enableTileAndCluster = (bool)value, DebugItemFlag.RuntimeOnly);
             DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Big Tile", () => m_Asset.tileSettings.enableBigTilePrepass, (value) => m_Asset.tileSettings.enableBigTilePrepass = (bool)value, DebugItemFlag.RuntimeOnly);
             // It must also have a "DepthForwardOnly" and no "DepthOnly" pass as forward material (either deferred or forward only rendering) have always a depth pass.
 
             // In case of forward only rendering we have a depth prepass. In case of deferred renderer, it is optional
-            bool addFullDepthPrepass = m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() || m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering;
-            bool addAlphaTestedOnly = !m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering && m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass;
+            bool addFullDepthPrepass = m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly() || m_Asset.globalRenderingSettings.useDepthPrepassWithDeferredRendering;
+            bool addAlphaTestedOnly = !m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly() && m_Asset.globalRenderingSettings.useDepthPrepassWithDeferredRendering && m_Asset.globalRenderingSettings.renderAlphaTestOnlyInDeferredPrepass;
 
             using (new ProfilingSample(cmd, addAlphaTestedOnly ? "Depth Prepass alpha test" : "Depth Prepass", GetSampler(CustomSamplerId.DepthPrepass)))
             {
         // during Gbuffer pass. This is handled in the shader and the depth test (equal and no depth write) is done here.
         void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
-            if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+            if (m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly())
                 return;
 
             using (new ProfilingSample(cmd, m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() ? "GBufferDebugDisplay" : "GBuffer", GetSampler(CustomSamplerId.GBuffer)))
                 }
                 else
                 {
-                    if (m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering)
+                    if (m_Asset.globalRenderingSettings.useDepthPrepassWithDeferredRendering)
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_Asset.globalRenderingSettings.renderAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
                         // but for opaque alpha tested object we use a depth equal and no depth write. And we rely on the shader pass GbufferWithDepthPrepass
                         RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferWithPrepassName, m_currentRendererConfigurationBakedLighting, rangeOpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
                     }
         {
             using (new ProfilingSample(cmd, "DisplayDebug ViewMaterial", GetSampler(CustomSamplerId.DisplayDebugViewMaterial)))
             {
-                if (m_CurrentDebugDisplaySettings.materialDebugSettings.IsDebugGBufferEnabled() && !m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+                if (m_CurrentDebugDisplaySettings.materialDebugSettings.IsDebugGBufferEnabled() && !m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly())
                 {
                     using (new ProfilingSample(cmd, "DebugViewMaterialGBuffer", GetSampler(CustomSamplerId.DebugViewMaterialGBuffer)))
                     {
 
         void RenderDeferredLighting(HDCamera hdCamera, CommandBuffer cmd)
         {
-            if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+            if (m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly())
                 return;
 
             m_MRTCache2[0] = m_CameraColorBufferRT;
         void SubsurfaceScatteringPass(HDCamera hdCamera, CommandBuffer cmd, SubsurfaceScatteringSettings sssParameters)
         {
             // Currently, forward-rendered objects do not output split lighting required for the SSS pass.
-            if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+            if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly())
                 return;
 
             using (new ProfilingSample(cmd, "Subsurface Scattering", GetSampler(CustomSamplerId.SubsurfaceScattering)))
 
                 if (pass == ForwardPass.Opaque)
                 {
-                    var passNames = m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() ? m_ForwardAndForwardOnlyPassNames : m_ForwardOnlyPassNames;
+                    var passNames = m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly() ? m_ForwardAndForwardOnlyPassNames : m_ForwardOnlyPassNames;
                     // Forward opaque material always have a prepass (whether or not we use deferred, whether or not there is option like alpha test only) so we pass the right depth state here.
                     RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, passNames, m_currentRendererConfigurationBakedLighting, null, m_DepthStateOpaqueWithPrepass);
                 }
                     cmd.GetTemporaryRT(m_DepthPyramidBuffer, m_DepthPyramidBufferDesc, FilterMode.Trilinear);
                     // End
 
-                    if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+                    if (!m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly())
                         m_GbufferManager.InitGBuffers(w, h, m_DeferredMaterial, enableBakeShadowMask, cmd);
 
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Depth);
                 }
 
                 // Clear GBuffers
-                if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+                if (!m_Asset.globalRenderingSettings.ShouldUseForwardRenderingOnly())
                 {
                     using (new ProfilingSample(cmd, "Clear GBuffer", GetSampler(CustomSamplerId.ClearGBuffer)))
                     {

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

   m_EditorClassIdentifier: 
   m_RenderPipelineResources: {fileID: 11400000, guid: 42086e81f4f0c724f96f7f09cc995354,
     type: 2}
-  renderingSettings:
+  globalRenderingSettings:
+  globalTextureSettings:
+    spotCookieSize: 128
+    pointCookieSize: 512
+    reflectionCubemapSize: 128
+    reflectionCacheCompressed: 1
   sssSettings: {fileID: 11400000, guid: 873499ce7a6f749408981f512a9683f7, type: 2}
   tileSettings:
     enableTileAndCluster: 1
     enableClustered: 1
     enableFptlForOpaqueWhenClustered: 1
     enableBigTilePrepass: 1
-    diffuseGlobalDimmer: 1
-    specularGlobalDimmer: 1
-  textureSettings:
-    spotCookieSize: 128
-    pointCookieSize: 512
-    reflectionCubemapSize: 128
   m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
     type: 2}
   m_DefaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset.meta

 fileFormatVersion: 2
 guid: 449281dd2b4fbee49b8397de0541ea3c
-timeCreated: 1496931629
-licenseType: Pro
+  externalObjects: {}
   mainObjectFileID: 11400000
   userData: 
   assetBundleName: 

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.cs

         // NOTE: All those properties are public because of how HDRenderPipelineInspector retrieves those properties via serialization/reflection
         // Doing it this way allows to change parameters name and still retrieve correct serialized values
 
-        // Renderer Settings
-        public RenderingSettings renderingSettings = new RenderingSettings();
+        // Global Renderer Settings
+        public GlobalRenderingSettings globalRenderingSettings = new GlobalRenderingSettings();
+        public GlobalTextureSettings globalTextureSettings = new GlobalTextureSettings();
         public SubsurfaceScatteringSettings sssSettings;
         public TileSettings tileSettings = new TileSettings();
 
-        // Texture Settings
-        public TextureSettings textureSettings = new TextureSettings();
-
-
         [SerializeField]
         Material m_DefaultDiffuseMaterial;
         [SerializeField]

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             public bool enableFptlForOpaqueWhenClustered; // still useful on opaques. Should be true by default to force tile on opaque.
             public bool enableBigTilePrepass;
 
-            [Range(0.0f, 1.0f)]
-            public float diffuseGlobalDimmer = 1.0f;
-            [Range(0.0f, 1.0f)]
-            public float specularGlobalDimmer = 1.0f;
-
             public enum TileDebug : int
             {
                 None = 0, Punctual = 1, Area = 2, AreaAndPunctual = 3, Environment = 4, EnvironmentAndPunctual = 5, EnvironmentAndArea = 6, EnvironmentAndAreaAndPunctual = 7,
                 enableClustered = true;
                 enableFptlForOpaqueWhenClustered = true;
                 enableBigTilePrepass = true;
-
-                diffuseGlobalDimmer = 1.0f;
-                specularGlobalDimmer = 1.0f;
             }
         }
 
             int m_CookieTexArraySize = 16;
             TextureCacheCubemap m_CubeCookieTexArray;
             int m_CubeCookieTexArraySize = 16;
+
+            LightingSettings m_LightingSettings = new LightingSettings();
 
             public class LightList
             {
             public LightLoop()
             {}
 
-            public void Build(RenderPipelineResources renderPipelineResources, TileSettings tileSettings, TextureSettings textureSettings, ShadowInitParameters shadowInit, ShadowSettings shadowSettings, IBLFilterGGX iblFilterGGX)
+            public void Build(RenderPipelineResources renderPipelineResources, TileSettings tileSettings, GlobalTextureSettings textureSettings, ShadowInitParameters shadowInit, ShadowSettings shadowSettings, IBLFilterGGX iblFilterGGX)
             {
                 m_Resources = renderPipelineResources;
                 m_TileSettings = tileSettings;
                 m_CubeCookieTexArray = new TextureCacheCubemap();
                 m_CubeCookieTexArray.AllocTextureArray(m_CubeCookieTexArraySize, textureSettings.pointCookieSize, TextureFormat.RGBA32, true);
 
-                m_ReflectionProbeCache = new ReflectionProbeCache(iblFilterGGX, m_ReflectionProbeCacheSize, textureSettings.reflectionCubemapSize, TextureCache.GetPreferredHDRCompressedTextureFormat, true);
+                TextureFormat probeCacheFormat = textureSettings.reflectionCacheCompressed ? TextureFormat.BC6H : TextureFormat.RGBAHalf;
+                m_ReflectionProbeCache = new ReflectionProbeCache(iblFilterGGX, m_ReflectionProbeCacheSize, textureSettings.reflectionCubemapSize, probeCacheFormat, true);
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
 
             {
                 var directionalLightData = new DirectionalLightData();
 
-                float diffuseDimmer = m_TileSettings.diffuseGlobalDimmer * additionalData.lightDimmer;
-                float specularDimmer = m_TileSettings.specularGlobalDimmer * additionalData.lightDimmer;
+                float diffuseDimmer = m_LightingSettings.diffuseGlobalDimmer * additionalData.lightDimmer;
+                float specularDimmer = m_LightingSettings.specularGlobalDimmer * additionalData.lightDimmer;
                 if (diffuseDimmer  <= 0.0f && specularDimmer <= 0.0f)
                     return false;
 
                 float distanceFade = ComputeLinearDistanceFade(distanceToCamera, additionalLightData.fadeDistance);
                 float lightScale = additionalLightData.lightDimmer * distanceFade;
 
-                lightData.diffuseScale = additionalLightData.affectDiffuse ? lightScale * m_TileSettings.diffuseGlobalDimmer : 0.0f;
-                lightData.specularScale = additionalLightData.affectSpecular ? lightScale * m_TileSettings.specularGlobalDimmer : 0.0f;
+                lightData.diffuseScale = additionalLightData.affectDiffuse ? lightScale * m_LightingSettings.diffuseGlobalDimmer : 0.0f;
+                lightData.specularScale = additionalLightData.affectSpecular ? lightScale * m_LightingSettings.specularGlobalDimmer : 0.0f;
 
                 if (lightData.diffuseScale <= 0.0f && lightData.specularScale <= 0.0f)
                     return false;
                         }
                     }
 
-                    float oldSpecularGlobalDimmer = m_TileSettings.specularGlobalDimmer;
+                    float oldSpecularGlobalDimmer = m_LightingSettings.specularGlobalDimmer;
-                        m_TileSettings.specularGlobalDimmer = 0.0f;
+                        m_LightingSettings.specularGlobalDimmer = 0.0f;
                     }
 
                     // 1. Count the number of lights and sort all lights by category, type and volume - This is required for the fptl/cluster shader code
                     }
 
                     // Restore values after "special rendering"
-                    m_TileSettings.specularGlobalDimmer = oldSpecularGlobalDimmer;
+                    m_LightingSettings.specularGlobalDimmer = oldSpecularGlobalDimmer;
                 }
 
                 m_lightCount = m_lightList.lights.Count + m_lightList.envLights.Count;

ScriptableRenderPipeline/HDRenderPipeline/FrameSettings.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    // The settings here are per frame settings. They can be changed by the renderer based on its need each frame.
+    public class LightingSettings
+    {
+        public float diffuseGlobalDimmer = 1.0f;
+        public float specularGlobalDimmer = 1.0f;
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/FrameSettings.cs.meta

+fileFormatVersion: 2
+guid: 2fc90a1ac27c42f40bf2c56b45b4d374
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/GlobalSettings.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    // All the structures here represent global engine settings.
+    // It means that they are supposed to be setup once and not changed during the game.
+    // All of these will be serialized in the HDRenderPipelineInstance used for the project.
+    [Serializable]
+    public class GlobalTextureSettings
+    {
+        public const int kHDDefaultSpotCookieSize = 128;
+        public const int kHDDefaultPointCookieSize = 512;
+        public const int kHDDefaultReflectionCubemapSize = 128;
+
+        public int spotCookieSize = kHDDefaultSpotCookieSize;
+        public int pointCookieSize = kHDDefaultPointCookieSize;
+        public int reflectionCubemapSize = kHDDefaultReflectionCubemapSize;
+        public bool reflectionCacheCompressed = false;
+    }
+
+    [Serializable]
+    public class GlobalRenderingSettings
+    {
+        public bool useForwardRenderingOnly; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
+        public bool useDepthPrepassWithDeferredRendering;
+        public bool renderAlphaTestOnlyInDeferredPrepass;
+
+        // We have to fall back to forward-only rendering when scene view is using wireframe rendering mode --
+        // as rendering everything in wireframe + deferred do not play well together
+        public bool ShouldUseForwardRenderingOnly()
+        {
+            return useForwardRenderingOnly || GL.wireframe;
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/GlobalSettings.cs.meta

+fileFormatVersion: 2
+guid: 0e59d5f3fb6a6744dbb195534816c029
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: