Merge branch 'master' into feature/ReflectionProbeEditor

SampleScenes/LightweightPipeline/DebuggingScenes/PBR_testing/LWpipeMats/LW_PlanksMat.mat

   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
   m_ShaderKeywords: _METALLICSPECGLOSSMAP _NORMALMAP _OCCLUSIONMAP _SPECGLOSSMAP _SPECULAR_SETUP
   m_LightmapFlags: 4
-  m_EnableInstancingVariants: 0
+  m_EnableInstancingVariants: 1
   m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}

TestbedPipelines/Fptl/LightingTemplate.hlsl

 #define CUBEMAPFACE_NEGATIVE_Z 5
 
 #if defined(SHADER_API_D3D11)
-#	include "ShaderLibrary/API/D3D11.hlsl"
+#	include "CoreRP/ShaderLibrary/API/D3D11.hlsl"
-#	include "ShaderLibrary/API/PSSL.hlsl"
+#	include "CoreRP/ShaderLibrary/API/PSSL.hlsl"
-#	include "ShaderLibrary/API/D3D11.hlsl"
-#	include "ShaderLibrary/API/D3D11_1.hlsl"
+#	include "CoreRP/ShaderLibrary/API/D3D11.hlsl"
+#	include "CoreRP/ShaderLibrary/API/D3D11_1.hlsl"
-#	include "ShaderLibrary/API/Metal.hlsl"
+#	include "CoreRP/ShaderLibrary/API/Metal.hlsl"
-#include "ShaderLibrary/API/Validate.hlsl"
+#include "CoreRP/ShaderLibrary/API/Validate.hlsl"
 
 #include "Shadow.hlsl"
 

TestbedPipelines/Fptl/ShadowContext.hlsl

 #define SHADOWCONTEXT_MAX_SAMPLER      0
 #define SHADOWCONTEXT_MAX_COMPSAMPLER  1
 
-#include "ShaderLibrary/Shadow/Shadow.hlsl"
+#include "CoreRP/ShaderLibrary/Shadow/Shadow.hlsl"
 
 TEXTURE2D_ARRAY(_ShadowmapExp_PCF);
 SAMPLER2D_SHADOW(sampler_ShadowmapExp_PCF);

TestbedPipelines/OnTileDeferredPipeline/Shaders/LightingTemplate.hlsl

 #define DIRECTIONAL_LIGHT (3)
 
 #if defined(SHADER_API_D3D11)
-#	include "ShaderLibrary/API/D3D11.hlsl"
+#	include "CoreRP/ShaderLibrary/API/D3D11.hlsl"
-#	include "ShaderLibrary/API/PSSL.hlsl"
+#	include "CoreRP/ShaderLibrary/API/PSSL.hlsl"
-#	include "ShaderLibrary/API/D3D11.hlsl"
-#	include "ShaderLibrary/API/D3D11_1.hlsl"
+#	include "CoreRP/ShaderLibrary/API/D3D11.hlsl"
+#	include "CoreRP/ShaderLibrary/API/D3D11_1.hlsl"
-#	include "ShaderLibrary/API/Metal.hlsl"
+#	include "CoreRP/ShaderLibrary/API/Metal.hlsl"
-#include "ShaderLibrary/API/Validate.hlsl"
+#include "CoreRP/ShaderLibrary/API/Validate.hlsl"
 #include "../../Fptl/Shadow.hlsl"
 
 UNITY_DECLARE_DEPTH_TEXTURE(_CameraGBufferZ);

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_ShadowAtlasResolution: 2048
   m_ShadowNearPlaneOffset: 2
   m_ShadowDistance: 50
-  m_ShadowCascades: 4
+  m_ShadowCascades: 0
-  m_DefaultMaterial: {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
-  m_DefaultParticleMaterial: {fileID: 2100000, guid: e823cd5b5d27c0f4b8256e7c12ee3e6d,
-    type: 2}
-  m_DefaultTerrainMaterial: {fileID: 2100000, guid: 594ea882c5a793440b60ff72d896021e,
-    type: 2}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/026_Shader_PBRscene/Substances/Hole_mesh.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Hole_mesh
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _ALPHATEST_ON _METALLICGLOSSMAP _METALLICSPECGLOSSMAP _METALLIC_SETUP
-    _NORMALMAP
+  m_ShaderKeywords: _ALPHATEST_ON _METALLICGLOSSMAP _METALLICSPECGLOSSMAP _NORMALMAP
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/028_PostProcessing_Custom.unity

 --- !u!104 &2
 RenderSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 8
+  serializedVersion: 9
   m_Fog: 0
   m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
   m_FogMode: 3
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
   m_IndirectSpecularColor: {r: 0.18297595, g: 0.22866462, b: 0.30681777, a: 1}
+  m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_EnableBakedLightmaps: 1
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
-    serializedVersion: 9
+    serializedVersion: 10
-    m_TextureWidth: 1024
-    m_TextureHeight: 1024
+    m_AtlasSize: 1024
     m_AO: 0
     m_AOMaxDistance: 1
     m_CompAOExponent: 1
     m_PVRFilteringAtrousPositionSigmaDirect: 0.5
     m_PVRFilteringAtrousPositionSigmaIndirect: 2
     m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
   m_LightingDataAsset: {fileID: 112000002, guid: 416f90dbdc63d468294664a687466f7c,
     type: 2}
   m_UseShadowmask: 0
   m_TargetDisplay: 0
   m_TargetEye: 3
   m_HDR: 0
-  m_AllowMSAA: 0
+  m_AllowMSAA: 1
   m_AllowDynamicResolution: 0
   m_ForceIntoRT: 1
   m_OcclusionCulling: 1
       colorBlindnessStrength: 1
   m_Resources: {fileID: 11400000, guid: d82512f9c8e5d4a4d938b575d47f88d4, type: 2}
   m_ShowToolkit: 0
-  m_ShowCustomSorter: 1
+  m_ShowCustomSorter: 0
   breakBeforeColorGrading: 0
   m_BeforeTransparentBundles:
   - assemblyQualifiedName: InvertOpaque, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: b74809b6df3aa43d7956d404db53f23e, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: b74809b6df3aa43d7956d404db53f23e, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 43e17d832791f421e868559e8db0283a, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 43e17d832791f421e868559e8db0283a, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: b74809b6df3aa43d7956d404db53f23e, type: 2}
   m_StaticBatchInfo:

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/028_PostProcessing_Custom/Scripts/InvertOpaque.shader

         {
         	
             float4 color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoord);
-            return 1-color;
+            return float4(1-color.rgb, color.a);
         }
 
     ENDHLSL

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/032_Shader_GlossyEnvironmentColor.unity

 --- !u!104 &2
 RenderSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 8
+  serializedVersion: 9
   m_Fog: 0
   m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
   m_FogMode: 3
   m_AmbientEquatorColor: {r: 0.7058823, g: 0.8761609, b: 1, a: 1}
   m_AmbientGroundColor: {r: 1, g: 0.73039234, b: 0.19117647, a: 1}
   m_AmbientIntensity: 0
-  m_AmbientMode: 1
+  m_AmbientMode: 3
   m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
   m_SkyboxMaterial: {fileID: 2100000, guid: ce77733c08cfa4b49b650c1ace29f0e9, type: 2}
   m_HaloStrength: 0.5
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
   m_IndirectSpecularColor: {r: 0.5423716, g: 0.4884358, b: 0.49541453, a: 1}
+  m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_EnableBakedLightmaps: 0
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
-    serializedVersion: 9
+    serializedVersion: 10
-    m_TextureWidth: 1024
-    m_TextureHeight: 1024
+    m_AtlasSize: 1024
     m_AO: 0
     m_AOMaxDistance: 1
     m_CompAOExponent: 1
     m_PVRFilteringAtrousPositionSigmaDirect: 0.5
     m_PVRFilteringAtrousPositionSigmaIndirect: 2
     m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
   m_LightingDataAsset: {fileID: 112000002, guid: b963f66ea5430454684b1a7a5770a2fc,
     type: 2}
   m_UseShadowmask: 0
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 9acf8eda25c6e46419cdde0827388bd9, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 6602e4dc96b9e49e4b91b974a55eaaf0, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: ca1f754b1599664458d307a4f7806750, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 8b19d583097348e4b9bfc4bd24c213fd, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 35fb1fa78d82163468e423826eca94ef, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: d2227d87c9e2dfa4e8bfc9cec6a79dde, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 6dfc1ad7348e02845849cd5c1ecc7a6d, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 5b461f0df538a06478d749ced2fd5ca2, type: 2}
   m_StaticBatchInfo:
   m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
+  m_Version: 1
   m_InnerSpotPercent: 0
   lightDimmer: 1
   fadeDistance: 10000
   spotLightShape: 0
   shapeLength: 0.5
   shapeWidth: 0.5
+  aspectRatio: 1
   shapeRadius: 0
   maxSmoothness: 1
   applyRangeAttenuation: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 6e889e08cb1ea5149a0dd83cb1b721a3, type: 2}
   m_StaticBatchInfo:

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/032_Shader_GlossyEnvironmentColor/LightingData.asset.meta

 fileFormatVersion: 2
 guid: b963f66ea5430454684b1a7a5770a2fc
-timeCreated: 1509379082
-licenseType: Pro
 NativeFormatImporter:
   externalObjects: {}
   mainObjectFileID: 25800000

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/033_Shader_HighlightsEnvironmentGradientSH/LightingData.asset.meta

 fileFormatVersion: 2
 guid: 4b8770423f3cd41d88a12f7bfc8e2dc3
-timeCreated: 1509379112
-licenseType: Pro
 NativeFormatImporter:
   externalObjects: {}
   mainObjectFileID: 25800000

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders.unity

 --- !u!104 &2
 RenderSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 8
+  serializedVersion: 9
   m_Fog: 0
   m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
   m_FogMode: 3
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
   m_IndirectSpecularColor: {r: 0.14995675, g: 0.16868491, b: 0.17473538, a: 1}
+  m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_EnableBakedLightmaps: 1
     m_EnableRealtimeLightmaps: 1
   m_LightmapEditorSettings:
-    serializedVersion: 9
+    serializedVersion: 10
-    m_TextureWidth: 1024
-    m_TextureHeight: 1024
+    m_AtlasSize: 1024
     m_AO: 0
     m_AOMaxDistance: 1
     m_CompAOExponent: 1
     m_PVRFilteringAtrousPositionSigmaDirect: 0.5
     m_PVRFilteringAtrousPositionSigmaIndirect: 2
     m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
   m_LightingDataAsset: {fileID: 112000002, guid: 7932049343d2440b5906dd159645b31c,
     type: 2}
   m_UseShadowmask: 1
   m_Script: {fileID: 11500000, guid: c20dfc007a9a74ad8a2bfd0d59abe398, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  renderPipeline: {fileID: 0}
+  renderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26, type: 2}
   cameraToUse: {fileID: 1368807769}
   hdr: 0
   msaaSamples: 1

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile Materials/Billboard.mat

         m_Offset: {x: 0, y: 0}
     m_Floats:
     - _Cutoff: 0.33
-    - _Shininess: 0.125
-    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile Materials/LOD0/Branches_0.mat

     m_Floats:
     - _Cull: 2
     - _Cutoff: 0.33
-    - _Shininess: 0.125
-    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile Materials/LOD0/Leaves_1.mat

   m_ShaderKeywords: EFFECT_BUMP EFFECT_HUE_VARIATION GEOM_TYPE_LEAF
   m_LightmapFlags: 5
   m_EnableInstancingVariants: 1
-  m_DoubleSidedGI: 0
+  m_DoubleSidedGI: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []
     m_Floats:
     - _Cull: 0
     - _Cutoff: 0.33
-    - _Shininess: 0.125
-    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile Materials/LOD1/Branches_0.mat

     m_Floats:
     - _Cull: 2
     - _Cutoff: 0.33
-    - _Shininess: 0.125
-    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile Materials/LOD1/Leaves_1.mat

   m_ShaderKeywords: EFFECT_BUMP EFFECT_HUE_VARIATION GEOM_TYPE_LEAF
   m_LightmapFlags: 5
   m_EnableInstancingVariants: 1
-  m_DoubleSidedGI: 0
+  m_DoubleSidedGI: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []
     m_Floats:
     - _Cull: 0
     - _Cutoff: 0.33
-    - _Shininess: 0.125
-    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile Materials/LOD2/Branches_0.mat

     m_Floats:
     - _Cull: 2
     - _Cutoff: 0.33
-    - _Shininess: 0.125
-    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile Materials/LOD2/Leaves_1.mat

   m_ShaderKeywords: EFFECT_BUMP EFFECT_HUE_VARIATION GEOM_TYPE_LEAF
   m_LightmapFlags: 5
   m_EnableInstancingVariants: 1
-  m_DoubleSidedGI: 0
+  m_DoubleSidedGI: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []
     m_Floats:
     - _Cull: 0
     - _Cutoff: 0.33
-    - _Shininess: 0.125
-    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/035_Shader_TerrainShaders/Free_SpeedTrees/Broadleaf_Mobile.spm.meta

 fileFormatVersion: 2
 guid: 1e84b98fc4c200c4aa16e1ec38895673
-timeCreated: 1452616713
-licenseType: Store
+  externalObjects: {}
-  specColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}
-  shininess: 0.125
   alphaTestRef: 0.33
   bestWindQuality: 4
   hasBillboard: 1
   billboardTransitionCrossFadeWidth: 0.25
   fadeOutWidth: 0.25
   scaleFactor: 0.3048
-  materialVersion: 2
+  materialVersion: 3
   userData: 
   assetBundleName: 
   assetBundleVariant: 

ScriptableRenderPipeline/Core/CoreRP/Resources/EncodeBC6H.compute

-#include "ShaderLibrary/Common.hlsl"
-#include "ShaderLibrary/BC6H.hlsl"
-#include "ShaderLibrary/Sampling/Sampling.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/BC6H.hlsl"
+#include "CoreRP/ShaderLibrary/Sampling/Sampling.hlsl"
 
 TextureCube<float4> _Source;
 RWTexture2DArray<uint4> _Target;

ScriptableRenderPipeline/Core/CoreRP/Resources/BlitCubeTextureFace.shader

             Cull Off
 
             HLSLPROGRAM
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
 
             #pragma vertex vert
             #pragma fragment frag

ScriptableRenderPipeline/Core/CoreRP/Shadow/Resources/DebugDisplayShadowMap.shader

         #pragma target 4.5
         #pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
-        #include "ShaderLibrary/Common.hlsl"
+        #include "CoreRP/ShaderLibrary/Common.hlsl"
 
         float4 _TextureScaleBias;
         float _TextureSlice;

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Shadow/Shadow.hlsl

     #define SHADOW_OPTIMIZE_REGISTER_USAGE   0
 #endif
 
-#include "Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
+#include "CoreRP/Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
 #include "ShadowTexFetch.hlsl"						// Resource sampling definitions (don't modify)
 
 struct ShadowContext

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Random.hlsl

 #ifndef UNITY_NOISE_INCLUDED
 #define UNITY_NOISE_INCLUDED
 
+#if !defined(SHADER_API_GLES)
+
 // A single iteration of Bob Jenkins' One-At-A-Time hashing algorithm.
 uint JenkinsHash(uint x)
 {
 {
     return ConstructFloat(JenkinsHash(v));
 }
+
+#endif // SHADER_API_GLES
 
 #endif // UNITY_NOISE_INCLUDED

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Packing.hlsl

 // return float between [-1, 1]
 float2 PackNormalOctEncode(float3 n)
 {
-    float l1norm    = dot(abs(n), 1.0);
-    float2 res0     = n.xy * (1.0 / l1norm);
+    //float l1norm    = dot(abs(n), 1.0);
+    //float2 res0     = n.xy * (1.0 / l1norm);
+
+    //float2 val      = 1.0 - abs(res0.yx);
+    //return (n.zz < float2(0.0, 0.0) ? (res0 >= 0.0 ? val : -val) : res0);
-    float2 val      = 1.0 - abs(res0.yx);
-    return (n.zz < float2(0.0, 0.0) ? (res0 >= 0.0 ? val : -val) : res0);
+    // Optimized version of above code:
+    n *= rcp(dot(abs(n), 1.0));
+    float t = saturate(-n.z);
+    return n.xy + (n.xy >= 0.0 ? t : -t);
 }
 
 float3 UnpackNormalOctEncode(float2 f)
 }
 
 // Unpack from normal map
-float3 UnpackNormalRGB(float4 packedNormal, float scale = 1.0)
+half3 UnpackNormalRGB(half4 packedNormal, half scale = 1.0)
-    float3 normal;
+    half3 normal;
-float3 UnpackNormalAG(float4 packedNormal, float scale = 1.0)
+half3 UnpackNormalAG(half4 packedNormal, half scale = 1.0)
-    float3 normal;
+    half3 normal;
     normal.xy = packedNormal.wy * 2.0 - 1.0;
     normal.xy *= scale;
     normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
 // Unpack normal as DXT5nm (1, y, 0, x) or BC5 (x, y, 0, 1)
-float3 UnpackNormalmapRGorAG(float4 packedNormal, float scale = 1.0)
+half3 UnpackNormalmapRGorAG(half4 packedNormal, half scale = 1.0)
 {
     // This do the trick
     packedNormal.w *= packedNormal.x;
 // HDR packing
 //-----------------------------------------------------------------------------
 
+// HDR Packing not defined in GLES2
+#if !defined(SHADER_API_GLES)
+
 // Ref: http://realtimecollisiondetection.net/blog/?p=15
 float4 PackToLogLuv(float3 vRGB)
 {
     float b = f16tof32((rgb << 5) & 0x7FE0);
     return float3(r, g, b);
 }
+
+#endif // SHADER_API_GLES
 
 //-----------------------------------------------------------------------------
 // Quaternion packing
 
     return quat;
 }
+
+// Integer and Float packing not defined in GLES2
+#if !defined(SHADER_API_GLES)
 
 //-----------------------------------------------------------------------------
 // Integer packing
     uint cb = (hi << 8) + lo;
     return PackShort(cb);
 }
+
+#endif // SHADER_API_GLES
 
 #endif // UNITY_PACKING_INCLUDED

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Macros.hlsl

 float3 FunctionName(float3 Parameter1) { FunctionBody; } \
 float4 FunctionName(float4 Parameter1) { FunctionBody; }
 
-#define TEMPLATE_1_INT(FunctionName, Parameter1, FunctionBody) \
-int    FunctionName(int    Parameter1) { FunctionBody; } \
-int2   FunctionName(int2   Parameter1) { FunctionBody; } \
-int3   FunctionName(int3   Parameter1) { FunctionBody; } \
-int4   FunctionName(int4   Parameter1) { FunctionBody; } \
-uint   FunctionName(uint   Parameter1) { FunctionBody; } \
-uint2  FunctionName(uint2  Parameter1) { FunctionBody; } \
-uint3  FunctionName(uint3  Parameter1) { FunctionBody; } \
-uint4  FunctionName(uint4  Parameter1) { FunctionBody; }
+#ifdef SHADER_API_GLES
+    #define TEMPLATE_1_INT(FunctionName, Parameter1, FunctionBody) \
+    int    FunctionName(int    Parameter1) { FunctionBody; } \
+    int2   FunctionName(int2   Parameter1) { FunctionBody; } \
+    int3   FunctionName(int3   Parameter1) { FunctionBody; } \
+    int4   FunctionName(int4   Parameter1) { FunctionBody; }
+#else
+    #define TEMPLATE_1_INT(FunctionName, Parameter1, FunctionBody) \
+    int    FunctionName(int    Parameter1) { FunctionBody; } \
+    int2   FunctionName(int2   Parameter1) { FunctionBody; } \
+    int3   FunctionName(int3   Parameter1) { FunctionBody; } \
+    int4   FunctionName(int4   Parameter1) { FunctionBody; } \
+    uint   FunctionName(uint   Parameter1) { FunctionBody; } \
+    uint2  FunctionName(uint2  Parameter1) { FunctionBody; } \
+    uint3  FunctionName(uint3  Parameter1) { FunctionBody; } \
+    uint4  FunctionName(uint4  Parameter1) { FunctionBody; }
+#endif
 
 #define TEMPLATE_2_FLT(FunctionName, Parameter1, Parameter2, FunctionBody) \
 float  FunctionName(float  Parameter1, float  Parameter2) { FunctionBody; } \
 
-#define TEMPLATE_2_INT(FunctionName, Parameter1, Parameter2, FunctionBody) \
-int    FunctionName(int    Parameter1, int    Parameter2) { FunctionBody; } \
-int2   FunctionName(int2   Parameter1, int2   Parameter2) { FunctionBody; } \
-int3   FunctionName(int3   Parameter1, int3   Parameter2) { FunctionBody; } \
-int4   FunctionName(int4   Parameter1, int4   Parameter2) { FunctionBody; } \
-uint   FunctionName(uint   Parameter1, uint   Parameter2) { FunctionBody; } \
-uint2  FunctionName(uint2  Parameter1, uint2  Parameter2) { FunctionBody; } \
-uint3  FunctionName(uint3  Parameter1, uint3  Parameter2) { FunctionBody; } \
-uint4  FunctionName(uint4  Parameter1, uint4  Parameter2) { FunctionBody; }
+
+#ifdef SHADER_API_GLES
+    #define TEMPLATE_2_INT(FunctionName, Parameter1, Parameter2, FunctionBody) \
+    int    FunctionName(int    Parameter1, int    Parameter2) { FunctionBody; } \
+    int2   FunctionName(int2   Parameter1, int2   Parameter2) { FunctionBody; } \
+    int3   FunctionName(int3   Parameter1, int3   Parameter2) { FunctionBody; } \
+    int4   FunctionName(int4   Parameter1, int4   Parameter2) { FunctionBody; }
+#else
+    #define TEMPLATE_2_INT(FunctionName, Parameter1, Parameter2, FunctionBody) \
+    int    FunctionName(int    Parameter1, int    Parameter2) { FunctionBody; } \
+    int2   FunctionName(int2   Parameter1, int2   Parameter2) { FunctionBody; } \
+    int3   FunctionName(int3   Parameter1, int3   Parameter2) { FunctionBody; } \
+    int4   FunctionName(int4   Parameter1, int4   Parameter2) { FunctionBody; } \
+    uint   FunctionName(uint   Parameter1, uint   Parameter2) { FunctionBody; } \
+    uint2  FunctionName(uint2  Parameter1, uint2  Parameter2) { FunctionBody; } \
+    uint3  FunctionName(uint3  Parameter1, uint3  Parameter2) { FunctionBody; } \
+    uint4  FunctionName(uint4  Parameter1, uint4  Parameter2) { FunctionBody; }
+#endif
 
 #define TEMPLATE_3_FLT(FunctionName, Parameter1, Parameter2, Parameter3, FunctionBody) \
 float  FunctionName(float  Parameter1, float  Parameter2, float  Parameter3) { FunctionBody; } \
 
-#define TEMPLATE_3_INT(FunctionName, Parameter1, Parameter2, Parameter3, FunctionBody) \
-int    FunctionName(int    Parameter1, int    Parameter2, int    Parameter3) { FunctionBody; } \
-int2   FunctionName(int2   Parameter1, int2   Parameter2, int2   Parameter3) { FunctionBody; } \
-int3   FunctionName(int3   Parameter1, int3   Parameter2, int3   Parameter3) { FunctionBody; } \
-int4   FunctionName(int4   Parameter1, int4   Parameter2, int4   Parameter3) { FunctionBody; } \
-uint   FunctionName(uint   Parameter1, uint   Parameter2, uint   Parameter3) { FunctionBody; } \
-uint2  FunctionName(uint2  Parameter1, uint2  Parameter2, uint2  Parameter3) { FunctionBody; } \
-uint3  FunctionName(uint3  Parameter1, uint3  Parameter2, uint3  Parameter3) { FunctionBody; } \
-uint4  FunctionName(uint4  Parameter1, uint4  Parameter2, uint4  Parameter3) { FunctionBody; }
+#ifdef SHADER_API_GLES
+    #define TEMPLATE_3_INT(FunctionName, Parameter1, Parameter2, Parameter3, FunctionBody) \
+    int    FunctionName(int    Parameter1, int    Parameter2, int    Parameter3) { FunctionBody; } \
+    int2   FunctionName(int2   Parameter1, int2   Parameter2, int2   Parameter3) { FunctionBody; } \
+    int3   FunctionName(int3   Parameter1, int3   Parameter2, int3   Parameter3) { FunctionBody; } \
+    int4   FunctionName(int4   Parameter1, int4   Parameter2, int4   Parameter3) { FunctionBody; }
+#else
+    #define TEMPLATE_3_INT(FunctionName, Parameter1, Parameter2, Parameter3, FunctionBody) \
+    int    FunctionName(int    Parameter1, int    Parameter2, int    Parameter3) { FunctionBody; } \
+    int2   FunctionName(int2   Parameter1, int2   Parameter2, int2   Parameter3) { FunctionBody; } \
+    int3   FunctionName(int3   Parameter1, int3   Parameter2, int3   Parameter3) { FunctionBody; } \
+    int4   FunctionName(int4   Parameter1, int4   Parameter2, int4   Parameter3) { FunctionBody; } \
+    uint   FunctionName(uint   Parameter1, uint   Parameter2, uint   Parameter3) { FunctionBody; } \
+    uint2  FunctionName(uint2  Parameter1, uint2  Parameter2, uint2  Parameter3) { FunctionBody; } \
+    uint3  FunctionName(uint3  Parameter1, uint3  Parameter2, uint3  Parameter3) { FunctionBody; } \
+    uint4  FunctionName(uint4  Parameter1, uint4  Parameter2, uint4  Parameter3) { FunctionBody; }
+#endif
-#define TEMPLATE_SWAP(FunctionName) \
-void FunctionName(inout float  a, inout float  b) { float  t = a; a = b; b = t; } \
-void FunctionName(inout float2 a, inout float2 b) { float2 t = a; a = b; b = t; } \
-void FunctionName(inout float3 a, inout float3 b) { float3 t = a; a = b; b = t; } \
-void FunctionName(inout float4 a, inout float4 b) { float4 t = a; a = b; b = t; } \
-void FunctionName(inout int    a, inout int    b) { int    t = a; a = b; b = t; } \
-void FunctionName(inout int2   a, inout int2   b) { int2   t = a; a = b; b = t; } \
-void FunctionName(inout int3   a, inout int3   b) { int3   t = a; a = b; b = t; } \
-void FunctionName(inout int4   a, inout int4   b) { int4   t = a; a = b; b = t; } \
-void FunctionName(inout uint   a, inout uint   b) { uint   t = a; a = b; b = t; } \
-void FunctionName(inout uint2  a, inout uint2  b) { uint2  t = a; a = b; b = t; } \
-void FunctionName(inout uint3  a, inout uint3  b) { uint3  t = a; a = b; b = t; } \
-void FunctionName(inout uint4  a, inout uint4  b) { uint4  t = a; a = b; b = t; } \
-void FunctionName(inout bool   a, inout bool   b) { bool   t = a; a = b; b = t; } \
-void FunctionName(inout bool2  a, inout bool2  b) { bool2  t = a; a = b; b = t; } \
-void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
-void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
+#ifdef SHADER_API_GLES
+    #define TEMPLATE_SWAP(FunctionName) \
+    void FunctionName(inout float  a, inout float  b) { float  t = a; a = b; b = t; } \
+    void FunctionName(inout float2 a, inout float2 b) { float2 t = a; a = b; b = t; } \
+    void FunctionName(inout float3 a, inout float3 b) { float3 t = a; a = b; b = t; } \
+    void FunctionName(inout float4 a, inout float4 b) { float4 t = a; a = b; b = t; } \
+    void FunctionName(inout int    a, inout int    b) { int    t = a; a = b; b = t; } \
+    void FunctionName(inout int2   a, inout int2   b) { int2   t = a; a = b; b = t; } \
+    void FunctionName(inout int3   a, inout int3   b) { int3   t = a; a = b; b = t; } \
+    void FunctionName(inout int4   a, inout int4   b) { int4   t = a; a = b; b = t; } \
+    void FunctionName(inout bool   a, inout bool   b) { bool   t = a; a = b; b = t; } \
+    void FunctionName(inout bool2  a, inout bool2  b) { bool2  t = a; a = b; b = t; } \
+    void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
+    void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
+#else
+    #define TEMPLATE_SWAP(FunctionName) \
+    void FunctionName(inout float  a, inout float  b) { float  t = a; a = b; b = t; } \
+    void FunctionName(inout float2 a, inout float2 b) { float2 t = a; a = b; b = t; } \
+    void FunctionName(inout float3 a, inout float3 b) { float3 t = a; a = b; b = t; } \
+    void FunctionName(inout float4 a, inout float4 b) { float4 t = a; a = b; b = t; } \
+    void FunctionName(inout int    a, inout int    b) { int    t = a; a = b; b = t; } \
+    void FunctionName(inout int2   a, inout int2   b) { int2   t = a; a = b; b = t; } \
+    void FunctionName(inout int3   a, inout int3   b) { int3   t = a; a = b; b = t; } \
+    void FunctionName(inout int4   a, inout int4   b) { int4   t = a; a = b; b = t; } \
+    void FunctionName(inout uint   a, inout uint   b) { uint   t = a; a = b; b = t; } \
+    void FunctionName(inout uint2  a, inout uint2  b) { uint2  t = a; a = b; b = t; } \
+    void FunctionName(inout uint3  a, inout uint3  b) { uint3  t = a; a = b; b = t; } \
+    void FunctionName(inout uint4  a, inout uint4  b) { uint4  t = a; a = b; b = t; } \
+    void FunctionName(inout bool   a, inout bool   b) { bool   t = a; a = b; b = t; } \
+    void FunctionName(inout bool2  a, inout bool2  b) { bool2  t = a; a = b; b = t; } \
+    void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
+    void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
+#endif
 
 
 // MACRO from Legacy Untiy

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/EntityLighting.hlsl

 // RGBM lightmaps are currently always gamma encoded, so we use a constant of range^2.2 = 5^2.2
 #define LIGHTMAP_RGBM_RANGE 34.493242f
 
+// DLRD lightmaps are currently always gamma encoded, so we use a constant of 2.0^2.2 = 4.59
+#define LIGHTMAP_DLDR_RANGE 4.59f
+
 // TODO: This is the max value allowed for emissive (bad name - but keep for now to retrieve it) (It is 8^2.2 (gamma) and 8 is the limit of punctual light slider...), comme from UnityCg.cginc. Fix it!
 // Ask Jesper if this can be change for HDRenderPipeline
 #define EMISSIVE_RGBM_SCALE 97.0
     return rgbmInput.rgb * pow(rgbmInput.a, 2.2f) * LIGHTMAP_RGBM_RANGE;
 }
 
-float3 SampleSingleLightmap(TEXTURE2D_ARGS(lightmapTex, lightmapSampler), float2 uv, float4 transform, bool lightmapRGBM)
+float3 UnpackLightmapDoubleLDR(float4 encodedColor)
+{
+    return encodedColor.rgb * LIGHTMAP_DLDR_RANGE;
+}
+
+float3 DecodeLightmap(float4 encodedIlluminance)
+{
+#if defined(UNITY_LIGHTMAP_RGBM_ENCODING)
+    return UnpackLightmapRGBM(encodedIlluminance);
+#else // DLDR encoding on mobile platforms
+    return UnpackLightmapDoubleLDR(encodedIlluminance);
+#endif
+}
+
+float3 DecodeHDREnvironment(float4 encodedIrradiance, float4 decodeInstructions)
+{
+    // Take into account texture alpha if decodeInstructions.w is true(the alpha value affects the RGB channels)
+    float alpha = max(decodeInstructions.w * (encodedIrradiance.a - 1.0) + 1.0, 0.0);
+
+    // If Linear mode is not supported we can skip exponent part
+    return (decodeInstructions.x * pow(alpha, decodeInstructions.y)) * encodedIrradiance.rgb;
+}
+
+float3 SampleSingleLightmap(TEXTURE2D_ARGS(lightmapTex, lightmapSampler), float2 uv, float4 transform, bool encodedLightmap)
-    if (lightmapRGBM)
+    if (encodedLightmap)
-        illuminance = UnpackLightmapRGBM(SAMPLE_TEXTURE2D(lightmapTex, lightmapSampler, uv).rgba);
+        float4 encodedIlluminance = SAMPLE_TEXTURE2D(lightmapTex, lightmapSampler, uv).rgba;
+        illuminance = DecodeLightmap(encodedIlluminance);
     }
     else
     {
 }
 
-float3 SampleDirectionalLightmap(TEXTURE2D_ARGS(lightmapTex, lightmapSampler), TEXTURE2D_ARGS(lightmapDirTex, lightmapDirSampler), float2 uv, float4 transform, float3 normalWS, bool lightmapRGBM)
+float3 SampleDirectionalLightmap(TEXTURE2D_ARGS(lightmapTex, lightmapSampler), TEXTURE2D_ARGS(lightmapDirTex, lightmapDirSampler), float2 uv, float4 transform, float3 normalWS, bool encodedLightmap)
 {
     // In directional mode Enlighten bakes dominant light direction
     // in a way, that using it for half Lambert and then dividing by a "rebalancing coefficient"
     float4 direction = SAMPLE_TEXTURE2D(lightmapDirTex, lightmapDirSampler, uv);
     // Remark: baked lightmap is RGBM for now, dynamic lightmap is RGB9E5
     float3 illuminance = float3(0.0, 0.0, 0.0);
-    if (lightmapRGBM)
+    if (encodedLightmap)
-        illuminance = UnpackLightmapRGBM(SAMPLE_TEXTURE2D(lightmapTex, lightmapSampler, uv).rgba);
+        half4 encodedIlluminance = SAMPLE_TEXTURE2D(lightmapTex, lightmapSampler, uv).rgba;
+        illuminance = DecodeLightmap(encodedIlluminance);
     }
     else
     {

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/CommonLighting.hlsl

 
     NdotV = dot(N, V);
 
-    N = (NdotV >= 0.0) ? N : (N - 2.0 * NdotV * V);
+    // N = (NdotV >= 0.0) ? N : (N - 2.0 * NdotV * V);
+    N += (2.0 * saturate(-NdotV)) * V;
     NdotV = abs(NdotV);
 
     return N;

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 #include "API/Metal.hlsl"
 #elif defined(SHADER_API_VULKAN)
 #include "API/Vulkan.hlsl"
+#elif defined(SHADER_API_GLCORE)
+#include "API/GLCore.hlsl"
+#elif defined(SHADER_API_GLES3)
+#include "API/GLES3.hlsl"
+#elif defined(SHADER_API_GLES)
+#include "API/GLES2.hlsl"
 #else
 #error unsupported shader api
 #endif
 // ----------------------------------------------------------------------------
 // Common intrinsic (general implementation of intrinsic available on some platform)
 // ----------------------------------------------------------------------------
+
+// Error on GLES2 undefined functions
+#ifdef SHADER_API_GLES
+#define BitFieldExtract ERROR_ON_UNSUPPORTED_FUNC(BitFieldExtract)
+#define IsBitSet ERROR_ON_UNSUPPORTED_FUNC(IsBitSet)
+#define SetBit ERROR_ON_UNSUPPORTED_FUNC(SetBit)
+#define ClearBit ERROR_ON_UNSUPPORTED_FUNC(ClearBit)
+#define ToggleBit ERROR_ON_UNSUPPORTED_FUNC(ToggleBit)
+#define FastMulBySignOfNegZero ERROR_ON_UNSUPPORTED_FUNC(FastMulBySignOfNegZero)
+#define LODDitheringTransition ERROR_ON_UNSUPPORTED_FUNC(LODDitheringTransition)
+#endif
+
+#if !defined(SHADER_API_GLES)
 
 #ifndef INTRINSIC_BITFIELD_EXTRACT
 // Unsigned integer bit field extraction.
 {
     data ^= 1u << offset;
 }
+
+#endif
+
 
 #ifndef INTRINSIC_WAVEREADFIRSTLANE
     // Warning: for correctness, the argument must have the same value across the wave!
 // PositivePow remove this warning when you know the value is positive and avoid inf/NAN.
 TEMPLATE_2_FLT(PositivePow, base, power, return pow(max(abs(base), FLT_EPS), power))
 
+
+
+#if !defined(SHADER_API_GLES)
     if (ignoreNegZero)
     {
         return (s >= 0) ? x : -x;
         uint signBit = negZero & asuint(s);
         return asfloat(signBit ^ asuint(x));
     }
+#else
+    return (s >= 0) ? x : -x;
+#endif
 }
 
 // Returns -1 for negative numbers and 1 for positive numbers.
 // Misc utilities
 // ----------------------------------------------------------------------------
 
+// Normalize that account for vectors with zero length
+float3 SafeNormalize(float3 inVec)
+{
+    float dp3 = max(FLT_MIN, dot(inVec, inVec));
+    return inVec * rsqrt(dp3);
+}
+
+// Normalize that account for vectors with zero length
+half3 SafeNormalize(half3 inVec)
+{
+    half dp3 = max(HALF_MIN, dot(inVec, inVec));
+    return inVec * rsqrt(dp3);
+}
+
 // Generates a triangle in homogeneous clip space, s.t.
 // v0 = (-1, -1, 1), v1 = (3, -1, 1), v2 = (-1, 3, 1).
 float2 GetFullScreenTriangleTexCoord(uint vertexID)
     return float4(uv * 2.0 - 1.0, z, 1.0);
 }
 
+#if !defined(SHADER_API_GLES)
+
 // LOD dithering transition helper
 // LOD0 must use this function with ditherFactor 1..0
 // LOD1 must use this function with ditherFactor 0..1
     p = (ditherFactor >= 0.5) ? p : 1 - p;
     clip(ditherFactor - p);
 }
+
+#endif
 
 
 #endif // UNITY_COMMON_INCLUDED

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/XBoxOne.hlsl

 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
 #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
 #define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
 
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/Vulkan.hlsl

 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
 #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
 #define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
 
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/PSSL.hlsl

 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
 #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
 #define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
 
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/Metal.hlsl

 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
 #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
 #define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
 
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/API/D3D11.hlsl

 #define LOAD_TEXTURE2D_MSAA(textureName, unCoord2, sampleIndex)     textureName.Load(unCoord2, sampleIndex)
 #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)          textureName.Load(int4(unCoord2, index, 0))
 #define LOAD_TEXTURE2D_ARRAY_LOD(textureName, unCoord2, index, lod) textureName.Load(int4(unCoord2, index, lod))
+#define LOAD_TEXTURE3D(textureName, unCoord3)                       textureName.Load(int4(unCoord3, 0))
+#define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
 
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))

ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeParameter.cs

 
         internal abstract void SetValue(VolumeParameter parameter);
 
+        // This is used in case you need to access fields/properties that can't be accessed in the
+        // constructor of a ScriptableObject (VolumeParameter are generally declared and inited in
+        // a VolumeComponent which is a ScriptableObject). This will be called right after the
+        // VolumeComponent object has been constructed, thus allowing access to previously
+        // "forbidden" fields/properties.
+        protected internal virtual void OnEnable()
+        {
+        }
+
+        // Called when the parent VolumeComponent OnDisabled is called
+        protected internal virtual void OnDisable()
+        {
+        }
+
         public static bool IsObjectParameter(Type type)
         {
             if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ObjectParameter<>))
         {
             this.hdr = hdr;
             this.showAlpha = showAlpha;
+            this.showEyeDropper = showEyeDropper;
             this.overrideState = overrideState;
         }
 
         {
             this.hdr = hdr;
             this.showAlpha = showAlpha;
+            this.showEyeDropper = showEyeDropper;
             this.overrideState = overrideState;
         }
     }

ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeComponent.cs

                 .Select(t => (VolumeParameter)t.GetValue(this))
                 .ToList()
                 .AsReadOnly();
+
+            foreach (var parameter in parameters)
+                parameter.OnEnable();
+            if (parameters == null)
+                return;
+
+            foreach (var parameter in parameters)
+                parameter.OnDisable();
         }
 
         public void SetAllOverridesTo(bool state)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _FilterKernelsBasic = Shader.PropertyToID("_FilterKernelsBasic");
         public static readonly int _HalfRcpWeightedVariances = Shader.PropertyToID("_HalfRcpWeightedVariances");
 
-        public static readonly int _CameraPosDiff = Shader.PropertyToID("_CameraPosDiff");
-
         public static readonly int _CameraDepthTexture = Shader.PropertyToID("_CameraDepthTexture");
         public static readonly int _CameraMotionVectorsTexture = Shader.PropertyToID("_CameraMotionVectorsTexture");
         public static readonly int _FullScreenDebugMode = Shader.PropertyToID("_FullScreenDebugMode");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

             cameraPos = pos;
             screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
 
+            if (ShaderConfig.s_CameraRelativeRendering != 0)
+            {
+                Matrix4x4 cameraDisplacement = Matrix4x4.Translate(cameraPos - prevCameraPos); // Non-camera-relative positions
+                prevViewProjMatrix *= cameraDisplacement; // Now prevViewProjMatrix correctly transforms this frame's camera-relative positionWS
+            }
+
             // Warning: near and far planes appear to be broken.
             GeometryUtility.CalculateFrustumPlanes(viewProjMatrix, frustumPlanes);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
 
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewMaterialGBuffer.shader

 
             #pragma multi_compile _ SHADOWS_SHADOWMASK
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
 
             // CAUTION: In case deferred lighting need to support various lighting model statically, we will require to do multicompile with different define like UNITY_MATERIAL_LIT
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "../Debug/DebugDisplay.cs.hlsl"
             #include "../ShaderVariables.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplayLatlong.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #include "ShaderLibrary/Common.hlsl"
-            #include "ShaderLibrary/ImageBasedLighting.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 
             TEXTURECUBE(_InputCubemap);
             SAMPLER(sampler_InputCubemap);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.cs

         [SerializeField]
         public SubsurfaceScatteringSettings sssSettings;
 
-        // Default Material / Shader
-        [SerializeField]
-        Material m_DefaultDiffuseMaterial;
-        [SerializeField]
-        Shader m_DefaultShader;
-
-        public Material defaultDiffuseMaterial
-        {
-            get { return m_DefaultDiffuseMaterial; }
-            set { m_DefaultDiffuseMaterial = value; }
-        }
-
-        public Shader defaultShader
-        {
-            get { return m_DefaultShader; }
-            set { m_DefaultShader = value; }
-        }
-
-            return m_DefaultShader;
+            return m_RenderPipelineResources.defaultShader;
-            return m_DefaultDiffuseMaterial;
+            return m_RenderPipelineResources.defaultDiffuseMaterial;
         }
 
         public override Material GetDefaultParticleMaterial()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/SceneSettings/Resources/DrawTransmittanceGraph.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "ShaderLibrary/Common.hlsl"
-            #include "ShaderLibrary/CommonMaterial.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/CommonMaterial.hlsl"
             #define USE_LEGACY_UNITY_MATRIX_VARIABLES
             #include "../../ShaderVariables.hlsl"
             #include "../../Material/SubsurfaceScattering/CommonSubsurfaceScattering.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/SceneSettings/Resources/DrawSssProfile.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
             #define USE_LEGACY_UNITY_MATRIX_VARIABLES
             #include "../../ShaderVariables.hlsl"
         #ifdef SSS_MODEL_BASIC

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/ProceduralSky/Resources/ProceduralSky.shader

 
     #pragma multi_compile _ _ENABLE_SUN_DISK
 
-    #include "ShaderLibrary/Common.hlsl"
-    #include "ShaderLibrary/Color.hlsl"
-    #include "ShaderLibrary/CommonLighting.hlsl"
+    #include "CoreRP/ShaderLibrary/Common.hlsl"
+    #include "CoreRP/ShaderLibrary/Color.hlsl"
+    #include "CoreRP/ShaderLibrary/CommonLighting.hlsl"
 
     float4   _SkyParam; // x exposure, y multiplier, z rotation
     float4x4 _PixelCoordToViewDirWS; // Actually just 3x3, but Unity can only set 4x4

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/OpaqueAtmosphericScattering.shader

 
             #pragma enable_d3d11_debug_symbols
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "../ShaderVariables.hlsl"
             #include "AtmosphericScattering/AtmosphericScattering.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/HDRISky/Resources/SkyHDRI.shader

     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
-    #include "ShaderLibrary/Common.hlsl"
-    #include "ShaderLibrary/Color.hlsl"
-    #include "ShaderLibrary/CommonLighting.hlsl"
+    #include "CoreRP/ShaderLibrary/Common.hlsl"
+    #include "CoreRP/ShaderLibrary/Color.hlsl"
+    #include "CoreRP/ShaderLibrary/CommonLighting.hlsl"
 
     TEXTURECUBE(_Cubemap);
     SAMPLER(sampler_Cubemap);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/BlitCubemap.shader

             #pragma fragment frag
             #pragma target 4.5
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
 
             TEXTURECUBE(_MainTex);
             SAMPLER(sampler_MainTex);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/AtmosphericScattering/AtmosphericScattering.hlsl

 #ifndef UNITY_ATMOSPHERIC_SCATTERING_INCLUDED
 #define UNITY_ATMOSPHERIC_SCATTERING_INCLUDED
 
-#include "ShaderLibrary/VolumeRendering.hlsl"
+#include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
 
 #include "AtmosphericScattering.cs.hlsl"
 #include "../SkyVariables.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 #if UNITY_EDITOR
         static readonly SupportedRenderingFeatures s_NeededFeatures = new SupportedRenderingFeatures()
         {
-            reflectionProbeSupportFlags = SupportedRenderingFeatures.ReflectionProbeSupportFlags.Rotation
+            reflectionProbeSupportFlags = SupportedRenderingFeatures.ReflectionProbeSupportFlags.Rotation,
+            defaultMixedLightingMode = SupportedRenderingFeatures.LightmapMixedBakeMode.IndirectOnly,
+            supportedMixedLightingModes = SupportedRenderingFeatures.LightmapMixedBakeMode.IndirectOnly | SupportedRenderingFeatures.LightmapMixedBakeMode.Shadowmask,
+            supportedLightmapBakeTypes = LightmapBakeType.Baked | LightmapBakeType.Mixed | LightmapBakeType.Realtime,
+            supportedLightmapsModes = LightmapsMode.NonDirectional | LightmapsMode.CombinedDirectional,
+            rendererSupportsLightProbeProxyVolumes = true,
+            rendererSupportsMotionVectors = true,
+            rendererSupportsReceiveShadows = true,
+            rendererSupportsReflectionProbes = true
         };
 #endif
 
 
 	                InitAndClearBuffer(hdCamera, enableBakeShadowMask, cmd);
 
-                    RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd, true);
+                    RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd);
 
                     RenderObjectsVelocity(m_CullResults, hdCamera, renderContext, cmd);
 
         // Forward only renderer: We always render everything
         // Deferred renderer: We render a depth prepass only if engine request it. We can decide if we render everything or only opaque alpha tested object.
         // Forward opaque with deferred renderer (DepthForwardOnly pass): We always render everything
-        void RenderDepthPrepass(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool hasDecals)
+        void RenderDepthPrepass(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
             // In case of deferred renderer, we can have forward opaque material. These materials need to be render in the depth buffer to correctly build the light list.
             // And they will tag the stencil to not be lit during the deferred lighting pass.
             using (new ProfilingSample(cmd, addAlphaTestedOnly ? "Depth Prepass alpha test" : "Depth Prepass", GetSampler(CustomSamplerId.DepthPrepass)))
             {
                 CoreUtils.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
-                if (hasDecals || (addFullDepthPrepass && !addAlphaTestedOnly)) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
+                if (m_FrameSettings.enableDBuffer || (addFullDepthPrepass && !addAlphaTestedOnly)) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
                 {
                     // We render first the opaque object as opaque alpha tested are more costly to render and could be reject by early-z (but not Hi-z as it is disable with clip instruction)
                     // This is handled automatically with the RenderQueue value (OpaqueAlphaTested have a different value and thus are sorted after Opaque)
                 // These flags are still required in SRP or the engine won't compute previous model matrices...
                 // If the flag hasn't been set yet on this camera, motion vectors will skip a frame.
                 hdcamera.camera.depthTextureMode |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth;
-
-                // TODO: This is not safe ? as we don't use cmd buffer we can have a delay no ?
-                m_CameraMotionVectorsMaterial.SetVector(HDShaderIDs._CameraPosDiff, hdcamera.prevCameraPos - hdcamera.cameraPos);
 
                 // Setup stencil buffer
                 CoreUtils.DrawFullScreen(cmd, m_CameraMotionVectorsMaterial, m_VelocityBufferRT, m_CameraDepthStencilBufferRT, null, 0);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/RenderPipelineResources.cs

 {
     public class RenderPipelineResources : ScriptableObject
     {
+        // Default Material / Shader
+        public Material defaultDiffuseMaterial;
+        public Shader defaultShader;
+
         // Debug
         public Shader debugDisplayLatlongShader;
         public Shader debugViewMaterialGBufferShader;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   m_Script: {fileID: 11500000, guid: 8b6f86e1523e69a4282e92d393be89a4, type: 3}
   m_Name: HDRenderPipelineResources
   m_EditorClassIdentifier: 
+  defaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
+    type: 2}
+  defaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   debugDisplayLatlongShader: {fileID: 4800000, guid: c1d1d149a043a5349ba367da6c2051ba,
     type: 3}
   debugViewMaterialGBufferShader: {fileID: 4800000, guid: 439949ea1bfa91b4ba0d04269fcde33d,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DepthDownsample.compute

-#include "ShaderLibrary/Common.hlsl"
-
-Texture2D<float> _Source;
-RWTexture2D<float> _Result;
-
-SamplerState sampler_PointClamp;    //TODO: could we use min-sampler instead of using ALU?
-
-CBUFFER_START(cb)
-float4 _SrcSize;
-CBUFFER_END
-
-#pragma kernel KMain
-[numthreads(8, 8, 1)]
-void KMain(uint2 groupId : SV_GroupID, uint2 groupThreadId : SV_GroupThreadID, uint2 dispatchThreadId : SV_DispatchThreadID)
-{
-    // Upper-left pixel coordinate of quad that this thread will read
-    int2 threadUL = dispatchThreadId;
-
-    // Downsample the block
-    float2 offset = float2(threadUL) * 2.0f + 1.0f;
-    float4 depths = _Source.GatherRed(sampler_PointClamp, offset * _SrcSize.zw, 0.0);
-
-    float minDepth = min(min(depths.x, depths.y), min(depths.z, depths.w));
-
-    // Write to the final target
-    _Result[dispatchThreadId] = minDepth;
+#include "CoreRP/ShaderLibrary/Common.hlsl"
+
+Texture2D<float> _Source;
+RWTexture2D<float> _Result;
+
+SamplerState sampler_PointClamp;    //TODO: could we use min-sampler instead of using ALU?
+
+CBUFFER_START(cb)
+float4 _SrcSize;
+CBUFFER_END
+
+#pragma kernel KMain
+[numthreads(8, 8, 1)]
+void KMain(uint2 groupId : SV_GroupID, uint2 groupThreadId : SV_GroupThreadID, uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+    // Upper-left pixel coordinate of quad that this thread will read
+    int2 threadUL = dispatchThreadId;
+
+    // Downsample the block
+    float2 offset = float2(threadUL) * 2.0f + 1.0f;
+    float4 depths = _Source.GatherRed(sampler_PointClamp, offset * _SrcSize.zw, 0.0);
+
+    float minDepth = min(min(depths.x, depths.y), min(depths.z, depths.w));
+
+    // Write to the final target
+    _Result[dispatchThreadId] = minDepth;
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/CopyStencilBuffer.shader

     #pragma only_renderers d3d11 ps4 xboxone vulkan metal
     // #pragma enable_d3d11_debug_symbols
 
-    #include "ShaderLibrary/Common.hlsl"
-    #include "ShaderLibrary/Packing.hlsl"
+    #include "CoreRP/ShaderLibrary/Common.hlsl"
+    #include "CoreRP/ShaderLibrary/Packing.hlsl"
     #include "../ShaderVariables.hlsl"
     #include "../Lighting/LightDefinition.cs.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/CameraMotionVectors.shader

 
         #pragma target 4.5
 
-        #include "ShaderLibrary/Common.hlsl"
+        #include "CoreRP/ShaderLibrary/Common.hlsl"
-
-        float4 _CameraPosDiff;
 
         struct Attributes
         {
             UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
             float4 worldPos = float4(posInput.positionWS, 1.0);
             float4 prevPos = worldPos;
-
-        #if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
-            prevPos -= _CameraPosDiff;
-        #endif
 
             float4 prevClipPos = mul(_PrevViewProjMatrix, prevPos);
             float4 curClipPos = mul(_NonJitteredViewProjMatrix, worldPos);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/ApplyDistorsion.compute

-#include "ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../Material/Builtin/BuiltinData.hlsl"
 
 TEXTURE2D(_DistortionTexture);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.cs

                 if (settings.cookie != null && m_LightShape == LightShape.Directional)
                 {
                     EditorGUI.indentLevel++;
-                    EditorGUILayout.Slider(m_AdditionalLightData.shapeWidth, 0.01f, 10f, s_Styles.cookieSizeX);
-                    EditorGUILayout.Slider(m_AdditionalLightData.shapeHeight, 0.01f, 10f, s_Styles.cookieSizeY);
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.shapeWidth, s_Styles.cookieSizeX);
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.shapeHeight, s_Styles.cookieSizeY);
                     EditorGUI.indentLevel--;
                 }
             }
                 }
 
                 EditorGUI.indentLevel++;
-
-                using (var scope = new EditorGUI.ChangeCheckScope())
-                {
-                    // Draw each field first...
-                    int arraySize = m_AdditionalShadowData.cascadeRatios.arraySize;
-                    for (int i = 0; i < arraySize; i++)
-                        EditorGUILayout.Slider(m_AdditionalShadowData.cascadeRatios.GetArrayElementAtIndex(i), 0f, 1f, s_Styles.shadowCascadeRatios[i]);
-
-                    if (scope.changed)
-                    {
-                        // ...then clamp values to avoid out of bounds cascade ratios
-                        for (int i = 0; i < arraySize; i++)
-                        {
-                            var ratios = m_AdditionalShadowData.cascadeRatios;
-                            var ratioProp = ratios.GetArrayElementAtIndex(i);
-                            float val = ratioProp.floatValue;
-
-                            if (i > 0)
-                            {
-                                var prevRatioProp = ratios.GetArrayElementAtIndex(i - 1);
-                                float prevVal = prevRatioProp.floatValue;
-                                val = Mathf.Max(val, prevVal);
-                            }
-
-                            if (i < arraySize - 1)
-                            {
-                                var nextRatioProp = ratios.GetArrayElementAtIndex(i + 1);
-                                float nextVal = nextRatioProp.floatValue;
-                                val = Mathf.Min(val, nextVal);
-                            }
-
-                            ratioProp.floatValue = val;
-                        }
-                    }
-                }
-
+                int arraySize = m_AdditionalShadowData.cascadeRatios.arraySize;
+                for (int i = 0; i < arraySize; i++)
+                    EditorGUILayout.Slider(m_AdditionalShadowData.cascadeRatios.GetArrayElementAtIndex(i), 0f, 1f, s_Styles.shadowCascadeRatios[i]);
                 EditorGUI.indentLevel--;
             }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineMenuItems.cs

                     camera.gameObject.AddComponent<HDAdditionalCameraData>();
             }
         }
+        static void CheckOutFile(bool VSCEnabled, Material mat)
+        {
+            if (VSCEnabled)
+            {
+                UnityEditor.VersionControl.Task task = UnityEditor.VersionControl.Provider.Checkout(mat, UnityEditor.VersionControl.CheckoutMode.Both);
+
+                if (!task.success)
+                {
+                    Debug.Log(task.text + " " + task.resultCode);
+                }
+            }
+        }
 
         // This script is a helper for the artists to re-synchronize all layered materials
         [MenuItem("Internal/HDRenderPipeline/Synchronize all Layered materials")]
 
+            bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
+
+                    CheckOutFile(VSCEnabled, mat);
                     LayeredLitGUI.SynchronizeAllLayers(mat);
                     EditorUtility.SetDirty(mat);
                 }
             try
             {
                 var materials = Resources.FindObjectsOfTypeAll<Material>();
+
+                bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
 
                 for (int i = 0, length = materials.Length; i < length; i++)
                 {
                         i / (float)(length - 1));
 
+                    CheckOutFile(VSCEnabled, materials[i]);
                     HDEditorUtils.ResetMaterialKeywords(materials[i]);
                 }
             }
             try
             {
                 var matIds = AssetDatabase.FindAssets("t:Material");
+
+                bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
 
                 for (int i = 0, length = matIds.Length; i < length; i++)
                 {
                         string.Format("{0} / {1} materials cleaned.", i, length),
                         i / (float)(length - 1));
 
+                    CheckOutFile(VSCEnabled, mat);
                     HDEditorUtils.ResetMaterialKeywords(mat);
                 }
             }
-            }
-        }
-
-        static void CheckOutFile(bool VSCEnabled, Material mat)
-        {
-            if (VSCEnabled)
-            {
-                UnityEditor.VersionControl.Task task = UnityEditor.VersionControl.Provider.Checkout(mat, UnityEditor.VersionControl.CheckoutMode.Both);
-
-                if (!task.success)
-                {
-                    Debug.Log(task.text + " " + task.resultCode);
-                }
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineInspector.cs

     public sealed partial class HDRenderPipelineInspector : HDBaseEditor<HDRenderPipelineAsset>
     {
         SerializedProperty m_RenderPipelineResources;
-        SerializedProperty m_DefaultDiffuseMaterial;
-        SerializedProperty m_DefaultShader;
 
         // Global Frame Settings
         // Global Render settings
         void InitializeProperties()
         {
             m_RenderPipelineResources = properties.Find("m_RenderPipelineResources");
-            m_DefaultDiffuseMaterial = properties.Find("m_DefaultDiffuseMaterial");
-            m_DefaultShader = properties.Find("m_DefaultShader");
 
             // Global FrameSettings
             // Global Render settings
 
         void SettingsUI(HDRenderPipelineAsset hdAsset)
         {
-            EditorGUILayout.LabelField(s_Styles.settingsLabel, EditorStyles.boldLabel);
-            EditorGUI.indentLevel++;
-
-
             GlobalRenderSettingsUI(hdAsset);
             GlobalShadowSettingsUI(hdAsset);
             GlobalLightLoopSettingsUI(hdAsset);
 
             RendereringSettingsUI(hdAsset);
             LightLoopSettingsUI(hdAsset);
-
-            EditorGUI.indentLevel--;
-
-            EditorGUILayout.Space();
-            EditorGUILayout.PropertyField(m_SubsurfaceScatteringSettings, s_Styles.sssSettings);
         }
 
         protected override void OnEnable()
 
             serializedObject.Update();
 
-            EditorGUILayout.LabelField(s_Styles.defaults, EditorStyles.boldLabel);
-            EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_DefaultDiffuseMaterial, s_Styles.defaultDiffuseMaterial);
-            EditorGUILayout.PropertyField(m_DefaultShader, s_Styles.defaultShader);
-            EditorGUI.indentLevel--;
+            EditorGUILayout.Space();
+            EditorGUILayout.PropertyField(m_SubsurfaceScatteringSettings, s_Styles.sssSettings);
             EditorGUILayout.Space();
 
             SettingsUI(m_Target);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineInspector.Styles.cs

         {
             public readonly GUIContent defaults = new GUIContent("Defaults");
             public readonly GUIContent renderPipelineResources = new GUIContent("Render Pipeline Resources", "Set of resources that need to be loaded when creating stand alone");
-            public readonly GUIContent defaultDiffuseMaterial = new GUIContent("Default Diffuse Material", "Material to use when creating objects");
-            public readonly GUIContent defaultShader = new GUIContent("Default Shader", "Shader to use when creating materials");
 
             public readonly GUIContent settingsLabel = new GUIContent("Settings");
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDEditorUtils.cs

         {
             var srpPath = GetScriptableRenderPipelinePath();
             if (srpPath != null)
-                return Path.Combine(srpPath, "ScriptableRenderPipeline/HDRenderPipeline/");
+                return Path.Combine(srpPath, "ScriptableRenderPipeline/HDRenderPipeline/HDRP/");
-            return "Packages/com.unity.render-pipelines.high-definition/";
+            return "Packages/com.unity.render-pipelines.high-definition/HDRP/";
         }
 
         public static string GetPostProcessingPath()
         {
             var srpPath = GetScriptableRenderPipelinePath();
             if (srpPath != null)
-                return Path.Combine(srpPath, "ScriptableRenderPipeline/Core/");
+                return Path.Combine(srpPath, "ScriptableRenderPipeline/Core/CoreRP/");
-            return "Packages/com.unity.render-pipelines.core/";
+            return "Packages/com.unity.render-pipelines.core/CoreRP/";
         }
 
         public static bool ResetMaterialKeywords(Material material)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

             get { return HDEditorUtils.GetHDRenderPipelinePath() + "RenderPipelineResources/HDRenderPipelineResources.asset"; }
         }
 
-        static string s_DefaultMaterialPath
-        {
-            get { return HDEditorUtils.GetHDRenderPipelinePath() + "RenderPipelineResources/DefaultHDMaterial.mat"; }
-        }
-
-        static string s_DefaultShaderPath
-        {
-            get { return HDEditorUtils.GetHDRenderPipelinePath() + "Material/Lit/Lit.shader"; }
-        }
-
         class DoCreateNewAssetHDRenderPipeline : ProjectWindowCallback.EndNameEditAction
         {
             public override void Action(int instanceId, string pathName, string resourceFile)
                 // Load default renderPipelineResources / Material / Shader
                 newAsset.renderPipelineResources = AssetDatabase.LoadAssetAtPath<RenderPipelineResources>(s_RenderPipelineResourcesPath);
-                newAsset.defaultDiffuseMaterial = AssetDatabase.LoadAssetAtPath<Material>(s_DefaultMaterialPath);
-                newAsset.defaultShader = AssetDatabase.LoadAssetAtPath<Shader>(s_DefaultShaderPath);
                 AssetDatabase.CreateAsset(newAsset, pathName);
                 ProjectWindowUtil.ShowCreatedAsset(newAsset);
             }
                 string HDRenderPipelinePath = HDEditorUtils.GetHDRenderPipelinePath();
                 string PostProcessingPath = HDEditorUtils.GetPostProcessingPath();
                 string CorePath = HDEditorUtils.GetCorePath();
+
+                newAsset.defaultDiffuseMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDMaterial.mat");
+                newAsset.defaultShader = Load<Shader>(HDRenderPipelinePath + "Material/Lit/Lit.shader");
 
                 newAsset.debugDisplayLatlongShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugDisplayLatlong.Shader");
                 newAsset.debugViewMaterialGBufferShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewMaterialGBuffer.Shader");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Lighting.hlsl

 #ifndef UNITY_LIGHTING_INCLUDED
 #define UNITY_LIGHTING_INCLUDED
 
-#include "ShaderLibrary/CommonLighting.hlsl"
-#include "ShaderLibrary/CommonShadow.hlsl"
-#include "ShaderLibrary/Sampling/Sampling.hlsl"
-#include "ShaderLibrary/AreaLighting.hlsl"
-#include "ShaderLibrary/ImageBasedLighting.hlsl"
+#include "CoreRP/ShaderLibrary/CommonLighting.hlsl"
+#include "CoreRP/ShaderLibrary/CommonShadow.hlsl"
+#include "CoreRP/ShaderLibrary/Sampling/Sampling.hlsl"
+#include "CoreRP/ShaderLibrary/AreaLighting.hlsl"
+#include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 
 // The light loop (or lighting architecture) is in charge to:
 // - Define light list

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/scrbound.compute

 
 #pragma kernel ScreenBoundsAABB
 
-#include "ShaderLibrary/common.hlsl"
+#include "CoreRP/ShaderLibrary/common.hlsl"
 #include "LightLoop.cs.hlsl"
 
 uniform int g_isOrthographic;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/materialflags.compute

 
 // #pragma enable_d3d11_debug_symbols
 
-#include "ShaderLibrary/common.hlsl"
+#include "CoreRP/ShaderLibrary/common.hlsl"
 #include "ShaderBase.hlsl"
 #include "LightLoop.cs.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild.compute

 
 //#pragma #pragma enable_d3d11_debug_symbols
 
-#include "ShaderLibrary/common.hlsl"
+#include "CoreRP/ShaderLibrary/common.hlsl"
 #include "ShaderBase.hlsl"
 #include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-clustered.compute

 #pragma kernel TileLightListGen_DepthRT_MSAA_SrcBigTile		LIGHTLISTGEN=TileLightListGen_DepthRT_MSAA_SrcBigTile		ENABLE_DEPTH_TEXTURE_BACKPLANE		MSAA_ENABLED		USE_TWO_PASS_TILED_LIGHTING
 #pragma kernel ClearAtomic
 
-#include "ShaderLibrary/common.hlsl"
+#include "CoreRP/ShaderLibrary/common.hlsl"
 #include "ShaderBase.hlsl"
 #include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-bigtile.compute

 #pragma kernel BigTileLightListGen
 
-#include "ShaderLibrary/common.hlsl"
+#include "CoreRP/ShaderLibrary/common.hlsl"
 #include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
 #include "SortingComputeUtils.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/builddispatchindirect.compute

 #pragma kernel BuildDispatchIndirect
 
-#include "ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "LightLoop.cs.hlsl"
 
 #include "../../ShaderVariables.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/ShadowContext.hlsl

 #define SHADOWCONTEXT_MAX_COMPSAMPLER  1
 #define SHADOW_OPTIMIZE_REGISTER_USAGE 1
 
-#include "ShaderLibrary/Shadow/Shadow.hlsl"
+#include "CoreRP/ShaderLibrary/Shadow/Shadow.hlsl"
 
 TEXTURE2D_ARRAY(_ShadowmapExp_VSM_0);
 SAMPLER(sampler_ShadowmapExp_VSM_0);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

         FrameSettings m_FrameSettings = null;
         RenderPipelineResources m_Resources = null;
 
+        // this defualt additionalLightData is use for lights that don't have any (like preview light)
+        HDAdditionalLightData defaultHDAdditionalLightData = new HDAdditionalLightData();
+
         // Following is an array of material of size eight for all combination of keyword: OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
         Material[] m_deferredLightingMaterial;
         Material m_DebugViewTilesMaterial;
             // Light direction for directional is opposite to the forward direction
             directionalLightData.forward = light.light.transform.forward;
             // Rescale for cookies and windowing.
-            directionalLightData.up         = light.light.transform.up    * 2 / additionalData.shapeHeight;
-            directionalLightData.right      = light.light.transform.right * 2 / additionalData.shapeWidth;
+            directionalLightData.right      = light.light.transform.right * 2 / Mathf.Max(additionalData.shapeWidth, 0.001f);
+            directionalLightData.up         = light.light.transform.up    * 2 / Mathf.Max(additionalData.shapeHeight, 0.001f);
             directionalLightData.positionWS = light.light.transform.position;
             directionalLightData.color = GetLightColor(light);
             directionalLightData.diffuseScale = additionalData.affectDiffuse ? diffuseDimmer : 0.0f;
                 lightData.size.x = light.range;
 
                 // Rescale for cookies and windowing.
-                lightData.right *= 2.0f / additionalLightData.shapeWidth;
-                lightData.up    *= 2.0f / additionalLightData.shapeHeight;
+                lightData.right *= 2.0f / Mathf.Max(additionalLightData.shapeWidth, 0.001f);
+                lightData.up    *= 2.0f / Mathf.Max(additionalLightData.shapeHeight, 0.001f);
             }
             else if (lightData.lightType == GPULightType.ProjectorPyramid)
             {
         {
             using (new ProfilingSample(cmd, "Prepare Lights For GPU"))
             {
+                // If any light require it, we need to enabled bake shadow mask feature
+                m_enableBakeShadowMask = false;
-            // If any light require it, we need to enabled bake shadow mask feature
-            m_enableBakeShadowMask = false;
+                m_lightList.Clear();
-            m_lightList.Clear();
+                Vector3 camPosWS = camera.transform.position;
-            Vector3 camPosWS = camera.transform.position;
-
-            // Note: Light with null intensity/Color are culled by the C++, no need to test it here
-            if (cullResults.visibleLights.Count != 0 || cullResults.visibleReflectionProbes.Count != 0)
-            {
-                // 0. deal with shadows
+                // Note: Light with null intensity/Color are culled by the C++, no need to test it here
+                if (cullResults.visibleLights.Count != 0 || cullResults.visibleReflectionProbes.Count != 0)
-                    m_FrameId.frameCount++;
-                    // get the indices for all lights that want to have shadows
-                    m_ShadowRequests.Clear();
-                    m_ShadowRequests.Capacity = cullResults.visibleLights.Count;
-                    int lcnt = cullResults.visibleLights.Count;
-                    for (int i = 0; i < lcnt; ++i)
+                    // 0. deal with shadows
-                        VisibleLight vl = cullResults.visibleLights[i];
-                        if (vl.light.shadows == LightShadows.None)
-                            continue;
+                        m_FrameId.frameCount++;
+                        // get the indices for all lights that want to have shadows
+                        m_ShadowRequests.Clear();
+                        m_ShadowRequests.Capacity = cullResults.visibleLights.Count;
+                        int lcnt = cullResults.visibleLights.Count;
+                        for (int i = 0; i < lcnt; ++i)
+                        {
+                            VisibleLight vl = cullResults.visibleLights[i];
+                            if (vl.light.shadows == LightShadows.None)
+                                continue;
+
+                            AdditionalShadowData asd = vl.light.GetComponent<AdditionalShadowData>();
+                            if (asd != null && asd.shadowDimmer > 0.0f)
+                                m_ShadowRequests.Add(i);
+                        }
+                        // pass this list to a routine that assigns shadows based on some heuristic
+                        uint    shadowRequestCount = (uint)m_ShadowRequests.Count;
+                        //TODO: Do not call ToArray here to avoid GC, refactor API
+                        int[]   shadowRequests = m_ShadowRequests.ToArray();
+                        int[]   shadowDataIndices;
+                        m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, ShaderConfig.s_CameraRelativeRendering != 0, cullResults.visibleLights,
+                            ref shadowRequestCount, shadowRequests, out shadowDataIndices);
-                        AdditionalShadowData asd = vl.light.GetComponent<AdditionalShadowData>();
-                        if (asd != null && asd.shadowDimmer > 0.0f)
-                            m_ShadowRequests.Add(i);
+                        // update the visibleLights with the shadow information
+                        m_ShadowIndices.Clear();
+                        for (uint i = 0; i < shadowRequestCount; i++)
+                        {
+                            m_ShadowIndices.Add(shadowRequests[i], shadowDataIndices[i]);
+                        }
-                    // pass this list to a routine that assigns shadows based on some heuristic
-                    uint    shadowRequestCount = (uint)m_ShadowRequests.Count;
-                    //TODO: Do not call ToArray here to avoid GC, refactor API
-                    int[]   shadowRequests = m_ShadowRequests.ToArray();
-                    int[]   shadowDataIndices;
-                    m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, ShaderConfig.s_CameraRelativeRendering != 0, cullResults.visibleLights,
-                        ref shadowRequestCount, shadowRequests, out shadowDataIndices);
-                    // update the visibleLights with the shadow information
-                    m_ShadowIndices.Clear();
-                    for (uint i = 0; i < shadowRequestCount; i++)
-                    {
-                        m_ShadowIndices.Add(shadowRequests[i], shadowDataIndices[i]);
-                    }
-                }
+                    // 1. Count the number of lights and sort all lights by category, type and volume - This is required for the fptl/cluster shader code
+                    // If we reach maximum of lights available on screen, then we discard the light.
+                    // Lights are processed in order, so we don't discards light based on their importance but based on their ordering in visible lights list.
+                    int directionalLightcount = 0;
+                    int punctualLightcount = 0;
+                    int areaLightCount = 0;
-                // 1. Count the number of lights and sort all lights by category, type and volume - This is required for the fptl/cluster shader code
-                // If we reach maximum of lights available on screen, then we discard the light.
-                // Lights are processed in order, so we don't discards light based on their importance but based on their ordering in visible lights list.
-                int directionalLightcount = 0;
-                int punctualLightcount = 0;
-                int areaLightCount = 0;
+                    int lightCount = Math.Min(cullResults.visibleLights.Count, k_MaxLightsOnScreen);
+                    var sortKeys = new uint[lightCount];
+                    int sortCount = 0;
-                int lightCount = Math.Min(cullResults.visibleLights.Count, k_MaxLightsOnScreen);
-                var sortKeys = new uint[lightCount];
-                int sortCount = 0;
+                    for (int lightIndex = 0, numLights = cullResults.visibleLights.Count; (lightIndex < numLights) && (sortCount < lightCount); ++lightIndex)
+                    {
+                        var light = cullResults.visibleLights[lightIndex];
-                for (int lightIndex = 0, numLights = cullResults.visibleLights.Count; (lightIndex < numLights) && (sortCount < lightCount); ++lightIndex)
-                {
-                    var light = cullResults.visibleLights[lightIndex];
+                        // Light should always have additional data, however preview light right don't have, so we must handle the case by assigning defaultHDAdditionalLightData
+                        var additionalData = light.light.GetComponent<HDAdditionalLightData>();
+                        if (additionalData == null)
+                            additionalData = defaultHDAdditionalLightData;
-                    // We only process light with additional data
-                    var additionalData = light.light.GetComponent<HDAdditionalLightData>();
+                        LightCategory lightCategory = LightCategory.Count;
+                        GPULightType gpuLightType = GPULightType.Point;
+                        LightVolumeType lightVolumeType = LightVolumeType.Count;
-                    // Debug.Assert(additionalData == null, "Missing HDAdditionalData on a light - Should have been create by HDLightEditor");
+                        if (additionalData.lightTypeExtent == LightTypeExtent.Punctual)
+                        {
+                            lightCategory = LightCategory.Punctual;
-                    if (additionalData == null)
-                        return false;
+                            switch (light.lightType)
+                            {
+                                case LightType.Spot:
+                                    if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
+                                        continue;
+                                    switch (additionalData.spotLightShape)
+                                    {
+                                        case SpotLightShape.Cone:
+                                            gpuLightType = GPULightType.Spot;
+                                            lightVolumeType = LightVolumeType.Cone;
+                                            break;
+                                        case SpotLightShape.Pyramid:
+                                            gpuLightType = GPULightType.ProjectorPyramid;
+                                            lightVolumeType = LightVolumeType.Cone;
+                                            break;
+                                        case SpotLightShape.Box:
+                                            gpuLightType = GPULightType.ProjectorBox;
+                                            lightVolumeType = LightVolumeType.Box;
+                                            break;
+                                        default:
+                                            Debug.Assert(false, "Encountered an unknown SpotLightShape.");
+                                            break;
+                                    }
+                                    break;
-                    LightCategory lightCategory = LightCategory.Count;
-                    GPULightType gpuLightType = GPULightType.Point;
-                    LightVolumeType lightVolumeType = LightVolumeType.Count;
+                                case LightType.Directional:
+                                    if (directionalLightcount >= k_MaxDirectionalLightsOnScreen)
+                                        continue;
+                                    gpuLightType = GPULightType.Directional;
+                                    // No need to add volume, always visible
+                                    lightVolumeType = LightVolumeType.Count; // Count is none
+                                    break;
-                    if (additionalData.lightTypeExtent == LightTypeExtent.Punctual)
-                    {
-                        lightCategory = LightCategory.Punctual;
+                                case LightType.Point:
+                                    if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
+                                        continue;
+                                    gpuLightType = GPULightType.Point;
+                                    lightVolumeType = LightVolumeType.Sphere;
+                                    break;
-                        switch (light.lightType)
+                                default:
+                                    Debug.Assert(false, "Encountered an unknown LightType.");
+                                    break;
+                            }
+                        }
+                        else
-                            case LightType.Spot:
-                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
-                                    continue;
-                                switch (additionalData.spotLightShape)
-                                {
-                                    case SpotLightShape.Cone:
-                                        gpuLightType = GPULightType.Spot;
-                                        lightVolumeType = LightVolumeType.Cone;
-                                        break;
-                                    case SpotLightShape.Pyramid:
-                                        gpuLightType = GPULightType.ProjectorPyramid;
-                                        lightVolumeType = LightVolumeType.Cone;
-                                        break;
-                                    case SpotLightShape.Box:
-                                        gpuLightType = GPULightType.ProjectorBox;
-                                        lightVolumeType = LightVolumeType.Box;
-                                        break;
-                                    default:
-                                        Debug.Assert(false, "Encountered an unknown SpotLightShape.");
-                                        break;
-                                }
-                                break;
+                            lightCategory = LightCategory.Area;
-                            case LightType.Directional:
-                                if (directionalLightcount >= k_MaxDirectionalLightsOnScreen)
-                                    continue;
-                                gpuLightType = GPULightType.Directional;
-                                // No need to add volume, always visible
-                                lightVolumeType = LightVolumeType.Count; // Count is none
-                                break;
+                            switch (additionalData.lightTypeExtent)
+                            {
+                                case LightTypeExtent.Rectangle:
+                                    if (areaLightCount >= k_MaxAreaLightsOnScreen)
+                                        continue;
+                                    gpuLightType = GPULightType.Rectangle;
+                                    lightVolumeType = LightVolumeType.Box;
+                                    break;
-                            case LightType.Point:
-                                if (punctualLightcount >= k_MaxPunctualLightsOnScreen)
-                                    continue;
-                                gpuLightType = GPULightType.Point;
-                                lightVolumeType = LightVolumeType.Sphere;
-                                break;
+                                case LightTypeExtent.Line:
+                                    if (areaLightCount >= k_MaxAreaLightsOnScreen)
+                                        continue;
+                                    gpuLightType = GPULightType.Line;
+                                    lightVolumeType = LightVolumeType.Box;
+                                    break;
-                            default:
-                                Debug.Assert(false, "Encountered an unknown LightType.");
-                                break;
+                                default:
+                                    Debug.Assert(false, "Encountered an unknown LightType.");
+                                    break;
+                            }
+
+                        uint shadow = m_ShadowIndices.ContainsKey(lightIndex) ? 1u : 0;
+                        // 5 bit (0x1F) light category, 5 bit (0x1F) GPULightType, 5 bit (0x1F) lightVolume, 1 bit for shadow casting, 16 bit index
+                        sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 17 | shadow << 16 | (uint)lightIndex;
-                    else
-                    {
-                        lightCategory = LightCategory.Area;
-                        switch (additionalData.lightTypeExtent)
-                        {
-                            case LightTypeExtent.Rectangle:
-                                if (areaLightCount >= k_MaxAreaLightsOnScreen)
-                                    continue;
-                                gpuLightType = GPULightType.Rectangle;
-                                lightVolumeType = LightVolumeType.Box;
-                                break;
+                    CoreUtils.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
-                            case LightTypeExtent.Line:
-                                if (areaLightCount >= k_MaxAreaLightsOnScreen)
-                                    continue;
-                                gpuLightType = GPULightType.Line;
-                                lightVolumeType = LightVolumeType.Box;
-                                break;
+                    // TODO: Refactor shadow management
+                    // The good way of managing shadow:
+                    // Here we sort everyone and we decide which light is important or not (this is the responsibility of the lightloop)
+                    // we allocate shadow slot based on maximum shadow allowed on screen and attribute slot by bigger solid angle
+                    // THEN we ask to the ShadowRender to render the shadow, not the reverse as it is today (i.e render shadow than expect they
+                    // will be use...)
+                    // The lightLoop is in charge, not the shadow pass.
+                    // For now we will still apply the maximum of shadow here but we don't apply the sorting by priority + slot allocation yet
+                    m_CurrentSunLight = null;
+                    m_CurrentSunLightShadowIndex = -1;
-                            default:
-                                Debug.Assert(false, "Encountered an unknown LightType.");
-                                break;
-                        }
-                    }
+                    // 2. Go through all lights, convert them to GPU format.
+                    // Create simultaneously data for culling (LigthVolumeData and rendering)
+                    var worldToView = WorldToCamera(camera);
-                    uint shadow = m_ShadowIndices.ContainsKey(lightIndex) ? 1u : 0;
-                    // 5 bit (0x1F) light category, 5 bit (0x1F) GPULightType, 5 bit (0x1F) lightVolume, 1 bit for shadow casting, 16 bit index
-                    sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 17 | shadow << 16 | (uint)lightIndex;
-                }
+                    for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
+                    {
+                        // In 1. we have already classify and sorted the light, we need to use this sorted order here
+                        uint sortKey = sortKeys[sortIndex];
+                        LightCategory lightCategory = (LightCategory)((sortKey >> 27) & 0x1F);
+                        GPULightType gpuLightType = (GPULightType)((sortKey >> 22) & 0x1F);
+                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 17) & 0x1F);
+                        int lightIndex = (int)(sortKey & 0xFFFF);
-                CoreUtils.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
+                        var light = cullResults.visibleLights[lightIndex];
-                // TODO: Refactor shadow management
-                // The good way of managing shadow:
-                // Here we sort everyone and we decide which light is important or not (this is the responsibility of the lightloop)
-                // we allocate shadow slot based on maximum shadow allowed on screen and attribute slot by bigger solid angle
-                // THEN we ask to the ShadowRender to render the shadow, not the reverse as it is today (i.e render shadow than expect they
-                // will be use...)
-                // The lightLoop is in charge, not the shadow pass.
-                // For now we will still apply the maximum of shadow here but we don't apply the sorting by priority + slot allocation yet
-                m_CurrentSunLight = null;
-                m_CurrentSunLightShadowIndex = -1;
+                        m_enableBakeShadowMask = m_enableBakeShadowMask || IsBakedShadowMaskLight(light.light);
-                // 2. Go through all lights, convert them to GPU format.
-                // Create simultaneously data for culling (LigthVolumeData and rendering)
-                var worldToView = WorldToCamera(camera);
+                        // Light should always have additional data, however preview light right don't have, so we must handle the case by assigning defaultHDAdditionalLightData
+                        var additionalLightData = light.light.GetComponent<HDAdditionalLightData>();
+                        if (additionalLightData == null)
+                            additionalLightData = defaultHDAdditionalLightData;
-                for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
-                {
-                    // In 1. we have already classify and sorted the light, we need to use this sorted order here
-                    uint sortKey = sortKeys[sortIndex];
-                    LightCategory lightCategory = (LightCategory)((sortKey >> 27) & 0x1F);
-                    GPULightType gpuLightType = (GPULightType)((sortKey >> 22) & 0x1F);
-                    LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 17) & 0x1F);
-                    int lightIndex = (int)(sortKey & 0xFFFF);
+                        var additionalShadowData = light.light.GetComponent<AdditionalShadowData>(); // Can be null
-                    var light = cullResults.visibleLights[lightIndex];
+                        // Directional rendering side, it is separated as it is always visible so no volume to handle here
+                        if (gpuLightType == GPULightType.Directional)
+                        {
+                            if (GetDirectionalLightData(cmd, shadowSettings, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex))
+                            {
+                                directionalLightcount++;
-                    m_enableBakeShadowMask = m_enableBakeShadowMask || IsBakedShadowMaskLight(light.light);
+                                // We make the light position camera-relative as late as possible in order
+                                // to allow the preceding code to work with the absolute world space coordinates.
+                                if (ShaderConfig.s_CameraRelativeRendering != 0)
+                                {
+                                    // Caution: 'DirectionalLightData.positionWS' is camera-relative after this point.
+                                    int n = m_lightList.directionalLights.Count;
+                                    DirectionalLightData lightData = m_lightList.directionalLights[n - 1];
+                                    lightData.positionWS -= camPosWS;
+                                    m_lightList.directionalLights[n - 1] = lightData;
+                                }
+                            }
+                            continue;
+                        }
-                    var additionalLightData = light.light.GetComponent<HDAdditionalLightData>();
-                    var additionalShadowData = light.light.GetComponent<AdditionalShadowData>(); // Can be null
+                        Vector3 lightDimensions = new Vector3(); // X = length or width, Y = height, Z = range (depth)
-                    // Directional rendering side, it is separated as it is always visible so no volume to handle here
-                    if (gpuLightType == GPULightType.Directional)
-                    {
-                        if (GetDirectionalLightData(cmd, shadowSettings, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex))
+                        // Punctual, area, projector lights - the rendering side.
+                        if (GetLightData(cmd, shadowSettings, camera, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex, ref lightDimensions))
-                            directionalLightcount++;
+                            switch (lightCategory)
+                            {
+                                case LightCategory.Punctual:
+                                    punctualLightcount++;
+                                    break;
+                                case LightCategory.Area:
+                                    areaLightCount++;
+                                    break;
+                                default:
+                                    Debug.Assert(false, "TODO: encountered an unknown LightCategory.");
+                                    break;
+                            }
+
+                            // Then culling side. Must be call in this order as we pass the created Light data to the function
+                            GetLightVolumeDataAndBound(lightCategory, gpuLightType, lightVolumeType, light, m_lightList.lights[m_lightList.lights.Count - 1], lightDimensions, worldToView);
-                                // Caution: 'DirectionalLightData.positionWS' is camera-relative after this point.
-                                int n = m_lightList.directionalLights.Count;
-                                DirectionalLightData lightData = m_lightList.directionalLights[n - 1];
+                                // Caution: 'LightData.positionWS' is camera-relative after this point.
+                                int n = m_lightList.lights.Count;
+                                LightData lightData = m_lightList.lights[n - 1];
-                                m_lightList.directionalLights[n - 1] = lightData;
+                                m_lightList.lights[n - 1] = lightData;
-                        continue;
-                    Vector3 lightDimensions = new Vector3(); // X = length or width, Y = height, Z = range (depth)
-
-                    // Punctual, area, projector lights - the rendering side.
-                    if (GetLightData(cmd, shadowSettings, camera, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex, ref lightDimensions))
-                    {
-                        switch (lightCategory)
-                        {
-                            case LightCategory.Punctual:
-                                punctualLightcount++;
-                                break;
-                            case LightCategory.Area:
-                                areaLightCount++;
-                                break;
-                            default:
-                                Debug.Assert(false, "TODO: encountered an unknown LightCategory.");
-                                break;
-                        }
+                    // Sanity check
+                    Debug.Assert(m_lightList.directionalLights.Count == directionalLightcount);
+                    Debug.Assert(m_lightList.lights.Count == areaLightCount + punctualLightcount);
-                        // Then culling side. Must be call in this order as we pass the created Light data to the function
-                        GetLightVolumeDataAndBound(lightCategory, gpuLightType, lightVolumeType, light, m_lightList.lights[m_lightList.lights.Count - 1], lightDimensions, worldToView);
+                    m_punctualLightCount = punctualLightcount;
+                    m_areaLightCount     = areaLightCount;
-                        // We make the light position camera-relative as late as possible in order
-                        // to allow the preceding code to work with the absolute world space coordinates.
-                        if (ShaderConfig.s_CameraRelativeRendering != 0)
-                        {
-                            // Caution: 'LightData.positionWS' is camera-relative after this point.
-                            int n = m_lightList.lights.Count;
-                            LightData lightData = m_lightList.lights[n - 1];
-                            lightData.positionWS -= camPosWS;
-                            m_lightList.lights[n - 1] = lightData;
-                        }
-                    }
-                }
+                    // Redo everything but this time with envLights
+                    int envLightCount = 0;
-                // Sanity check
-                Debug.Assert(m_lightList.directionalLights.Count == directionalLightcount);
-                Debug.Assert(m_lightList.lights.Count == areaLightCount + punctualLightcount);
+                    int probeCount = Math.Min(cullResults.visibleReflectionProbes.Count, k_MaxEnvLightsOnScreen);
+                    sortKeys = new uint[probeCount];
+                    sortCount = 0;
-                m_punctualLightCount = punctualLightcount;
-                m_areaLightCount     = areaLightCount;
+                    for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Count; (probeIndex < numProbes) && (sortCount < probeCount); probeIndex++)
+                    {
+                        VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
-                // Redo everything but this time with envLights
-                int envLightCount = 0;
+                        // probe.texture can be null when we are adding a reflection probe in the editor
+                        if (probe.texture == null || envLightCount >= k_MaxEnvLightsOnScreen)
+                            continue;
-                int probeCount = Math.Min(cullResults.visibleReflectionProbes.Count, k_MaxEnvLightsOnScreen);
-                sortKeys = new uint[probeCount];
-                sortCount = 0;
+                        // Work around the culling issues. TODO: fix culling in C++.
+                        if (probe.probe == null || !probe.probe.isActiveAndEnabled)
+                            continue;
-                for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Count; (probeIndex < numProbes) && (sortCount < probeCount); probeIndex++)
-                {
-                    VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
+                        // Work around the data issues.
+                        if (probe.localToWorld.determinant == 0)
+                        {
+                            Debug.LogError("Reflection probe " + probe.probe.name + " has an invalid local frame and needs to be fixed.");
+                            continue;
+                        }
-                    // probe.texture can be null when we are adding a reflection probe in the editor
-                    if (probe.texture == null || envLightCount >= k_MaxEnvLightsOnScreen)
-                        continue;
+                        // TODO: Support LightVolumeType.Sphere, currently in UI there is no way to specify a sphere influence volume
+                        LightVolumeType lightVolumeType = probe.boxProjection != 0 ? LightVolumeType.Box : LightVolumeType.Box;
+                        ++envLightCount;
-                    // Work around the culling issues. TODO: fix culling in C++.
-                    if (probe.probe == null || !probe.probe.isActiveAndEnabled)
-                        continue;
+                        float boxVolume = 8 * probe.bounds.extents.x * probe.bounds.extents.y * probe.bounds.extents.z;
+                        float logVolume = Mathf.Clamp(256 + Mathf.Log(boxVolume, 1.1f), 0, 8191); // Allow for negative exponents
-                    // Work around the data issues.
-                    if (probe.localToWorld.determinant == 0)
-                    {
-                        Debug.LogError("Reflection probe " + probe.probe.name + " has an invalid local frame and needs to be fixed.");
-                        continue;
+                        // 13 bit volume, 3 bit LightVolumeType, 16 bit index
+                        sortKeys[sortCount++] = (uint)logVolume << 19 | (uint)lightVolumeType << 16 | ((uint)probeIndex & 0xFFFF); // Sort by volume
-                    // TODO: Support LightVolumeType.Sphere, currently in UI there is no way to specify a sphere influence volume
-                    LightVolumeType lightVolumeType = probe.boxProjection != 0 ? LightVolumeType.Box : LightVolumeType.Box;
-                    ++envLightCount;
-
-                    float boxVolume = 8 * probe.bounds.extents.x * probe.bounds.extents.y * probe.bounds.extents.z;
-                    float logVolume = Mathf.Clamp(256 + Mathf.Log(boxVolume, 1.1f), 0, 8191); // Allow for negative exponents
+                    // Not necessary yet but call it for future modification with sphere influence volume
+                    CoreUtils.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
-                    // 13 bit volume, 3 bit LightVolumeType, 16 bit index
-                    sortKeys[sortCount++] = (uint)logVolume << 19 | (uint)lightVolumeType << 16 | ((uint)probeIndex & 0xFFFF); // Sort by volume
-                }
+                    for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
+                    {
+                        // In 1. we have already classify and sorted the light, we need to use this sorted order here
+                        uint sortKey = sortKeys[sortIndex];
+                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3);
+                        int probeIndex = (int)(sortKey & 0xFFFF);
-                // Not necessary yet but call it for future modification with sphere influence volume
-                CoreUtils.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
+                        VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
-                for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
-                {
-                    // In 1. we have already classify and sorted the light, we need to use this sorted order here
-                    uint sortKey = sortKeys[sortIndex];
-                    LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3);
-                    int probeIndex = (int)(sortKey & 0xFFFF);
+                        if (GetEnvLightData(cmd, camera, probe))
+                        {
+                            GetEnvLightVolumeDataAndBound(probe, lightVolumeType, worldToView);
-                    VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
-
-                    if (GetEnvLightData(cmd, camera, probe))
-                    {
-                    GetEnvLightVolumeDataAndBound(probe, lightVolumeType, worldToView);
-
-                    // We make the light position camera-relative as late as possible in order
-                    // to allow the preceding code to work with the absolute world space coordinates.
-                    if (ShaderConfig.s_CameraRelativeRendering != 0)
-                    {
-                        // Caution: 'EnvLightData.positionWS' is camera-relative after this point.
-                        int n = m_lightList.envLights.Count;
-                        EnvLightData envLightData = m_lightList.envLights[n - 1];
-                        envLightData.positionWS -= camPosWS;
-                        m_lightList.envLights[n - 1] = envLightData;
+                            // We make the light position camera-relative as late as possible in order
+                            // to allow the preceding code to work with the absolute world space coordinates.
+                            if (ShaderConfig.s_CameraRelativeRendering != 0)
+                            {
+                                // Caution: 'EnvLightData.positionWS' is camera-relative after this point.
+                                int n = m_lightList.envLights.Count;
+                                EnvLightData envLightData = m_lightList.envLights[n - 1];
+                                envLightData.positionWS -= camPosWS;
+                                m_lightList.envLights[n - 1] = envLightData;
+                            }
+                        }
-                }
-            }
-            m_lightCount = m_lightList.lights.Count + m_lightList.envLights.Count;
-            Debug.Assert(m_lightList.bounds.Count == m_lightCount);
-            Debug.Assert(m_lightList.lightVolumes.Count == m_lightCount);
+                m_lightCount = m_lightList.lights.Count + m_lightList.envLights.Count;
+                Debug.Assert(m_lightList.bounds.Count == m_lightCount);
+                Debug.Assert(m_lightList.lightVolumes.Count == m_lightCount);
-            UpdateDataBuffers();
+                UpdateDataBuffers();
-            m_maxShadowDistance = shadowSettings.maxShadowDistance;
+                m_maxShadowDistance = shadowSettings.maxShadowDistance;
-            return m_enableBakeShadowMask;
-        }
+                return m_enableBakeShadowMask;
+            }
         }
 
         void VoxelLightListGeneration(CommandBuffer cmd, Camera camera, Matrix4x4 projscr, Matrix4x4 invProjscr, RenderTargetIdentifier cameraDepthBufferRT)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Deferred.compute

 // Include
 //-------------------------------------------------------------------------------------
 
-#include "ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../../Debug/DebugDisplay.hlsl"
 
 // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/HDAdditionalLightData.cs

         public SpotLightShape spotLightShape = SpotLightShape.Cone;
 
         // Only for Rectangle/Line/box projector lights
-        [Range(0.0f, 20.0f)]
-        [Range(0.0f, 20.0f)]
         [FormerlySerializedAs("lightHeight")]
         public float shapeHeight = 0.5f;
 
         // This is specific for the LightEditor GUI and not use at runtime
         public bool useOldInspector = false;
         public bool featuresFoldout = true;
-        public bool showAdditionalSettings = true; // TODO: Maybe we can remove if if we decide to always show additional settings
+        public bool showAdditionalSettings = false;
 
 #if UNITY_EDITOR
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/DeferredDirectionalShadow.compute

 // Each #kernel tells which function to compile; you can have many kernels
 #pragma kernel DeferredDirectionalShadow
 
-#include "ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../ShaderVariables.hlsl"
 #include "Lighting.hlsl" 
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Deferred.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "../Debug/DebugDisplay.hlsl"
 
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/Unlit.shader

     // Include
     //-------------------------------------------------------------------------------------
 
-    #include "ShaderLibrary/common.hlsl"
+    #include "CoreRP/ShaderLibrary/common.hlsl"
     #include "../../ShaderVariables.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.shader

             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
             #include "../../ShaderVariables.hlsl"
             #include "SubsurfaceScattering.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.hlsl

 #include "SubsurfaceScatteringSettings.cs.hlsl"
-#include "ShaderLibrary\Packing.hlsl"
+#include "CoreRP/ShaderLibrary/Packing.hlsl"
 #include "CommonSubsurfaceScattering.hlsl"
 
 // Subsurface scattering constant

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.compute

 // Included headers
 //--------------------------------------------------------------------------------------------------
 
-#include "ShaderLibrary/Common.hlsl"
-#include "ShaderLibrary/Packing.hlsl"
-#include "ShaderLibrary/Sampling/Sampling.hlsl"
-#include "ShaderLibrary/SpaceFillingCurves.hlsl"
+#include "CoreRP/ShaderLibrary/Common.hlsl"
+#include "CoreRP/ShaderLibrary/Packing.hlsl"
+#include "CoreRP/ShaderLibrary/Sampling/Sampling.hlsl"
+#include "CoreRP/ShaderLibrary/SpaceFillingCurves.hlsl"
 #include "../../ShaderVariables.hlsl"
 #include "../../Lighting/LightDefinition.cs.hlsl"
 #include "SubsurfaceScattering.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SSSProfile.meta

 fileFormatVersion: 2
-guid: a0ba759eadcfdcc44bc08adad4960ed0
+guid: 89c37ca558ceb6c4dadf385321baf125
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/CombineLighting.shader

             #pragma vertex Vert
             #pragma fragment Frag
 
-            #include "ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
 
             TEXTURE2D(_IrradianceSource);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Material.hlsl

 #ifndef UNITY_MATERIAL_INCLUDED
 #define UNITY_MATERIAL_INCLUDED
 
-#include "ShaderLibrary/Color.hlsl"
-#include "ShaderLibrary/Packing.hlsl"
-#include "ShaderLibrary/BSDF.hlsl"
-#include "ShaderLibrary/Debug.hlsl"
-#include "ShaderLibrary/GeometricTools.hlsl"
-#include "ShaderLibrary/CommonMaterial.hlsl"
-#include "ShaderLibrary/EntityLighting.hlsl"
-#include "ShaderLibrary/ImageBasedLighting.hlsl"
+#include "CoreRP/ShaderLibrary/Color.hlsl"
+#include "CoreRP/ShaderLibrary/Packing.hlsl"
+#include "CoreRP/ShaderLibrary/BSDF.hlsl"
+#include "CoreRP/ShaderLibrary/Debug.hlsl"
+#include "CoreRP/ShaderLibrary/GeometricTools.hlsl"
+#include "CoreRP/ShaderLibrary/CommonMaterial.hlsl"
+#include "CoreRP/ShaderLibrary/EntityLighting.hlsl"
+#include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 #include "../Sky/AtmosphericScattering/AtmosphericScattering.hlsl"
 
 // Guidelines for Material Keyword.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Resources/PreIntegratedFGD.shader

             #pragma target 4.5
             #pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
-            #include "ShaderLibrary/Common.hlsl"
-            #include "ShaderLibrary/ImageBasedLighting.hlsl"
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
             #include "../../../ShaderVariables.hlsl"
 
             struct Attributes

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

     // Include
     //-------------------------------------------------------------------------------------
 
-    #include "ShaderLibrary/common.hlsl"
-    #include "ShaderLibrary/Wind.hlsl"
-    #include "ShaderLibrary/GeometricTools.hlsl"
-    #include "ShaderLibrary/tessellation.hlsl"
+    #include "CoreRP/ShaderLibrary/common.hlsl"
+    #include "CoreRP/ShaderLibrary/Wind.hlsl"
+    #include "CoreRP/ShaderLibrary/GeometricTools.hlsl"
+    #include "CoreRP/ShaderLibrary/tessellation.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitDataDisplacement.hlsl

     return SAMPLE_TEXTURE2D_LOD(_HeightMap, sampler_HeightMap, param.uv + texOffsetCurrent, lod).r;
 }
 
-#include "ShaderLibrary/PerPixelDisplacement.hlsl"
+#include "CoreRP/ShaderLibrary/PerPixelDisplacement.hlsl"
 
 void ApplyDisplacementTileScale(inout float height)
 {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitData.hlsl

 //-------------------------------------------------------------------------------------
 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
-#include "ShaderLibrary/Sampling/SampleUVMapping.hlsl"
+#include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
 #include "../MaterialUtilities.hlsl"
 #include "../Decal/DecalUtilities.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

     // Include
     //-------------------------------------------------------------------------------------
 
-    #include "ShaderLibrary/Common.hlsl"
-    #include "ShaderLibrary/Wind.hlsl"
+    #include "CoreRP/ShaderLibrary/Common.hlsl"
+    #include "CoreRP/ShaderLibrary/Wind.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

 // Define refraction keyword helpers
 #define HAS_REFRACTION (defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE))
 #if HAS_REFRACTION
-# include "ShaderLibrary/Refraction.hlsl"
+# include "CoreRP/ShaderLibrary/Refraction.hlsl"
 
 # if defined(_REFRACTION_PLANE)
 #  define REFRACTION_MODEL(V, posInputs, bsdfData) RefractionModelPlane(V, posInputs.positionWS, bsdfData.normalWS, bsdfData.ior, bsdfData.thickness)
         F = Sq(-F * bsdfData.coatCoverage + 1.0);
     }
 
+    // When we are rough, we tend to see outward shifting of the reflection when at the boundary of the projection volume
+    // Also it appear like more sharp. To avoid these artifact and at the same time get better match to reference we lerp to original unmodified reflection.
+    // Formula is empirical.
+
     float4 preLD = SampleEnv(lightLoopContext, lightData.envIndex, R, preLightData.iblMipLevel);
     envLighting += F * preLD.rgb;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

     // Include
     //-------------------------------------------------------------------------------------
 
-    #include "ShaderLibrary/common.hlsl"
-    #include "ShaderLibrary/Wind.hlsl"
-    #include "ShaderLibrary/GeometricTools.hlsl"
-    #include "ShaderLibrary/tessellation.hlsl"
+    #include "CoreRP/ShaderLibrary/common.hlsl"
+    #include "CoreRP/ShaderLibrary/Wind.hlsl"
+    #include "CoreRP/ShaderLibrary/GeometricTools.hlsl"
+    #include "CoreRP/ShaderLibrary/tessellation.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitDataDisplacement.hlsl

     return BlendLayeredScalar(height0, height1, height2, height3, weights);
 }
 
-#include "ShaderLibrary/PerPixelDisplacement.hlsl"
+#include "CoreRP/ShaderLibrary/PerPixelDisplacement.hlsl"
 
 #endif // defined(_PIXEL_DISPLACEMENT) && LAYERS_HEIGHTMAP_ENABLE